c 内功修炼-ag真人游戏

this指针是类的指针，指向对象的首地址。

this指针只能在成员函数中使用，在全局函数、静态成员函数中都不能用this。

this指针只有在成员函数中才有定义，且存储位置会因编译器不同有不同存储位置。

类模板是什么？

用于解决多个功能相同、数据类型不同的类需要重复定义的问题。

在建立类时候使用template及任意类型标识符t，之后在建立类对象时，会指定实际的类型，这样才会是一个实际的对象。

类模板是对一批仅数据成员类型不同的类的抽象，只要为这一批类创建一个类模板，即给出一套程序代码，就可以用来生成具体的类。
11.cout和printf有什么区别？
cout<<是一个函数，cout<<后可以跟不同的类型是因为cout<<已存在针对各种类型数据的重载，所以会自动识别数据的类型。输出过程会首先将输出字符放入缓冲区，然后输出到屏幕。
cout是有缓冲输出:
cout < < "abc " < 或cout < < "abc\n ";cout < endl相当于输出回车后，再强迫缓冲输出。
flush立即强迫缓冲输出。
printf是无缓冲输出。有输出时立即输出
12.静态成员与普通成员的区别
1)生命周期
静态成员变量从类被加载开始到类被卸载，一直存在；
普通成员变量只有在类创建对象后才开始存在，对象结束，它的生命期结束；
2)共享方式
静态成员变量是全类共享；普通成员变量是每个对象单独享用的；
3)定义位置
普通成员变量存储在栈或堆中，而静态成员变量存储在静态全局区；
4)初始化位置
普通成员变量在类中初始化；静态成员变量在类外初始化；
5)默认实参
1.可以使用静态成员变量作为默认实参

13.在成员函数中调用delete this会出现什么问题？对象还可以使用吗？
1.在类对象的内存空间中，只有数据成员和虚函数表指针，并不包含代码内容，类的成员函数单独放在代码段中。在调用成员函数时，隐含传递一个this指针，让成员函数知道当前是哪个对象在调用它。当调用delete this时，类对象的内存空间被释放。在delete this之后进行的其他任何函数调用，只要不涉及到this指针的内容，都能够正常运行。一旦涉及到this指针，如操作数据成员，调用虚函数等，就会出现不可预期的问题。
2.为什么是不可预期的问题？
delete this之后不是释放了类对象的内存空间了么，那么这段内存应该已经还给系统，不再属于这个进程。照这个逻辑来看，应该发生指针错误，无访问权限之类的令系统崩溃的问题才对啊？这个问题牵涉到操作系统的内存管理策略。delete this释放了类对象的内存空间，但是内存空间却并不是马上被回收到系统中，可能是缓冲或者其他什么原因，导致这段内存空间暂时并没有被系统收回。此时这段内存是可以访问的，你可以加上100，加上200，但是其中的值却是不确定的。当你获取数据成员，可能得到的是一串很长的未初始化的随机数；访问虚函数表，指针无效的可能性非常高，造成系统崩溃。
1)

1)
14.空类的大小是多少？为什么？
1)c 空类的大小不为0，不同编译器设置不一样，vs设置为1；
2)c 标准指出，不允许一个对象（当然包括类对象）的大小为0，不同的对象不能具有相同的地址；
3)带有虚函数的c 类大小不为1，因为每一个对象会有一个vptr指向虚函数表，具体大小根据指针大小确定；
1.c 中要求对于类的每个实例都必须有独一无二的地址,那么编译器自动为空类分配一个字节大小，这样便保证了每个实例均有独一无二的内存地址。

15.为什么会有大端小端，htol这一类函数的作用
1)这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为 8bit。但是在c语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于 8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于 大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。我们常用的x86结构是小端模式，而keil c51则为大端模式。很多的arm，dsp都为小端模式。有些arm处理器还可以由硬件来选择是大端模式还是小端模式。
16.this指针调用成员变量时，堆栈会发生什么变化？
1)当在类的非静态成员函数访问类的非静态成员时，编译器会自动将对象的地址传给作为隐含参数传递给函数，这个隐含参数就是this指针。即使你并没有写this指针，编译器在链接时也会加上this的，对各成员的访问都是通过this的。例如你建立了类的多个对象时，在调用类的成员函数时，你并不知道具体是哪个对象在调用，此时你可以通过查看this指针来查看具体是哪个对象在调用。this指针首先入栈，然后成员函数的参数从右向左进行入栈，最后函数返回地址入栈。

}

当g_fun()函数执行到return时，会产生以下几个重要步骤：
(1). 先会产生一个临时变量，就叫xxxx吧。
(2). 然后调用拷贝构造函数把temp的值给xxxx。整个这两个步骤有点像：cexample xxxx(temp);
(3). 在函数执行到最后先析构temp局部变量。
(4). 等g_fun()执行完后再析构掉xxxx对象。

3. 对象需要通过另外一个对象进行初始化
   cexample a(100);
   cexample b=a;
   三、浅拷贝与深拷贝
   1. 默认拷贝构造函数
      很多时候在我们都不知道拷贝构造函数的情况下，传递对象给函数参数或者函数返回对象都能很好的进行，这是因为编译器会给我们自动产生一个拷贝构造函数，这就是“默认拷贝构造函数”，这个构造函数很简单，仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值，它一般具有以下形式：
      rect::rect(const rect& r)
      {
      width=r.width;
      height=r.height;
      }
      当然，以上代码不用我们编写，编译器会为我们自动生成。但是如果认为这样就可以解决对象的复制问题，那就错了，让我们来考虑以下一段代码：

#include
using namespace std;
class rect
{
public:
rect()
{
count ;
}
~rect()
{
count--;
}
static int getcount()
{
return count;
}
private:
int width;
int height;
static int count;
};
int rect::count=0;
int main()
{
rect rect1;
cout<<"the count of rect:"< rect rect2(rect1);
cout<<"the count of rect:"< return 0;
}

这段代码对前面的类，加入了一个静态成员，目的是进行计数。在主函数中，首先创建对象rect1，输出此时的对象个数，然后使用rect1复制出对象rect2，再输出此时的对象个数，按照理解，此时应该有两个对象存在，但实际程序运行时，输出的都是1，反应出只有1个对象。此外，在销毁对象时，由于会调用销毁两个对象，类的析构函数会调用两次，此时的计数器将变为负数。

说白了，就是拷贝构造函数没有处理静态数据成员。

出现这些问题最根本就在于在复制对象时，计数器没有递增，我们重新编写拷贝构造函数，如下：

#include
using namespace std;
class rect
{
public:
rect()
{
count ;
}
rect(const rect& r)
{
width=r.width;
height=r.height;
count ;
}
~rect()
{
count--;
}
static int getcount()
{
return count;
}
private:
int width;
int height;
static int count;
};
int rect::count=0;
int main()
{
rect rect1;
cout<<"the count of rect:"< rect rect2(rect1);
cout<<"the count of rect:"< return 0;
}
2. 浅拷贝

所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了，让我们考虑如下一段代码：

#include
#include
using namespace std;
class rect
{
public:
rect()
{
p=new int(100);
}

~rect()
{
 assert(p!=null);
    delete p;
}

private:
int width;
int height;
int *p;
};
int main()
{
rect rect1;
rect rect2(rect1);
return 0;
}

在这段代码运行结束之前，会出现一个运行错误。原因就在于在进行对象复制时，对于动态分配的内容没有进行正确的操作。我们来分析一下：

在运行定义rect1对象后，由于在构造函数中有一个动态分配的语句，因此执行后的内存情况大致如下：

在使用rect1复制rect2时，由于执行的是浅拷贝，只是将成员的值进行赋值，这时 rect1.p = rect2.p，也即这两个指针指向了堆里的同一个空间，如下图所示：

当然，这不是我们所期望的结果，在销毁对象时，两个对象的析构函数将对同一个内存空间释放两次，这就是错误出现的原因。我们需要的不是两个p有相同的值，而是两个p指向的空间有相同的值，解决办法就是使用“深拷贝”。

3. 深拷贝

   在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间，如上面的例子就应该按照如下的方式进行处理：

#include
#include
using namespace std;
class rect
{
public:
rect()
{
p=new int(100);
}

rect(const rect& r)
{
 width=r.width;
    height=r.height;
 p=new int(100);
    *p=*(r.p);
}
~rect()
{
 assert(p!=null);
    delete p;
}

private:
int width;
int height;
int *p;
};
int main()
{
rect rect1;
rect rect2(rect1);
return 0;
}
此时，在完成对象的复制后，内存的一个大致情况如下：

此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”。
3. 防止默认拷贝发生

通过对对象复制的分析，我们发现对象的复制大多在进行“值传递”时发生，这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数，这样因为拷贝构造函数是私有的，如果用户试图按值传递或函数返回该类对象，将得到一个编译错误，从而可以避免按值传递或返回对象。

//防止按值传递
class cexample
{
private:
int a;

public:
//构造函数
cexample(int b)
{
a = b;
cout<<"creat: "< }

private:
//拷贝构造函数，只是声明
cexample(const cexample& c);

public:
~cexample()
{
cout<< "delete: "< }

void show () 
{ 
    cout<

return 0; 

深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。简而言之，当数据成员中有指针时，必须要用深拷贝。

student s;
student s1 = s; // 调用拷贝构造函数
student s2;
s2 = s; // 赋值运算符操作
注：类中有指针变量时要重写析构函数、拷贝构造函数和赋值运算符


移动构造函数

1)有时候我们会遇到这样一种情况，我们用对象a初始化对象b后对象a我们就不在使用了，但是对象a的空间还在呀（在析构之前），既然拷贝构造函数，实际上就是把a对象的内容复制一份到b中，那么为什么我们不能直接使用a的空间呢？这样就避免了新的空间的分配，大大降低了构造的成本。这就是移动构造函数设计的初衷；
2)拷贝构造函数中，对于指针，我们一定要采用深层复制，而移动构造函数中，对于指针，我们采用浅层复制；
3)c  引入了移动构造函数，专门处理这种，用a初始化b后，就将a析构的情况；
4)与拷贝类似，移动也使用一个对象的值设置另一个对象的值。但是，又与拷贝不同的是，移动实现的是对象值真实的转移（源对象到目的对象）：源对象将丢失其内容，其内容将被目的对象占有。移动操作的发生的时候，是当移动值的对象是未命名的对象的时候。这里未命名的对象就是那些临时变量，甚至都不会有名称。典型的未命名对象就是函数的返回值或者类型转换的对象。使用临时对象的值初始化另一个对象值，不会要求对对象的复制：因为临时对象不会有其它使用，因而，它的值可以被移动到目的对象。做到这些，就要使用移动构造函数和移动赋值：当使用一个临时变量对象进行构造初始化的时候，调用移动构造函数。类似的，使用未命名的变量的值赋给一个对象时，调用移动赋值操作；
5)
example6 (example6&& x) : ptr(x.ptr) 
    {
        x.ptr = nullptr;
    }
    // move assignment
    example6& operator= (example6&& x) 
    {
        delete ptr; 
        ptr = x.ptr;
        x.ptr=nullptr;
        return *this;
}

析构函数

程序员定义的析构函数被扩展的过程？
1)析构函数函数体被执行；
2)如果class拥有成员类对象，而后者拥有析构函数，那么它们会以其声明顺序的相反顺序被调用；
3)如果对象有一个vptr，现在被重新定义
4)如果有任何直接的上一层非虚基类拥有析构函数，则它们会以声明顺序被调用；
5)如果任何虚基类拥有析构函数
析构函数的作用，如何起作用？ 
1)构造函数只是起初始化值的作用，但实例化一个对象的时候，可以通过实例去传递参数，从主函数传递到其他的函数里面，这样就使其他的函数里面有值了。规则，只要你一实例化对象，系统自动回调用一个构造函数，就是你不写，编译器也自动调用一次。 
2)析构函数与构造函数的作用相反，用于撤销对象的一些特殊任务处理，可以是释放对象分配的内存空间；特点：析构函数与构造函数同名，但该函数前面加~。 析构函数没有参数，也没有返回值，而且不能重载，在一个类中只能有一个析构函数。 当撤销对象时，编译器也会自动调用析构函数。 每一个类必须有一个析构函数，用户可以自定义析构函数，也可以是编译器自动生成默认的析构函数。一般析构函数定义为类的公有成员。
类什么时候会析构？
1)对象生命周期结束，被销毁时；
2)delete指向对象的指针时，或delete指向对象的基类类型指针，而其基类虚构函数是虚函数时；
3)对象i是对象o的成员，o的析构函数被调用时，对象i的析构函数也被调用。
3.如果在类的析构函数中调用delete this，会发生什么？
会导致堆栈溢出。原因很简单，delete的本质是“为将被释放的内存调用一个或多个析构函数，然后，释放内存”。显然，delete this会去调用本对象的析构函数，而析构函数中又调用delete this，形成无限递归，造成堆栈溢出，系统崩溃。
能否在析构函数 构造函数中抛出异常?
    析构函数
     1. 不要在析构函数中抛出异常！虽然c  并不禁止析构函数抛出异常，但这样会导致程序过早结束或出现不明确的行为。
     2. 如果某个操作可能会抛出异常，class应提供一个普通函数（而非析构函数），来执行该操作。目的是给客户一个处理错误的机会。
     3. 如果析构函数中异常非抛不可，那就用try catch来将异常吞下，但这样方法并不好，我们提倡有错早些报出来。
构造函数
     总结如下：
     1. 构造函数中抛出异常，会导致析构函数不能被调用，但对象本身已申请到的内存资源会被系统释放（已申请到资源的内部成员变量会被系统依次逆序调用其析构函数）。
     2. 因为析构函数不能被调用，所以可能会造成内存泄露或系统资源未被释放。
     3. 构造函数中可以抛出异常，但必须保证在构造函数抛出异常之前，把系统资源释放掉，防止内存泄露。（如何保证？？？使用auto_ptr？？？）

静态的成员函数

静态成员函数

　　与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。下面举个静态成员函数的例子。

#include
using namespace std;
class myclass
{
private:
    int a , b , c;
    static int sum;  //声明静态数据成员
public:
    myclass(int a , int b , int c);
    static void getsum();  //声明静态成员函数
};
int myclass::sum = 0;   //定义并初始化静态数据成员
myclass::myclass(int a , int b , int c)
{
    this->a = a;
    this->b = b;
    this->c = c;
    sum  = a b c;    //非静态成员函数可以访问静态数据成员
}
void myclass::getsum()    //静态成员函数的实现
{
    //cout<
using namespace std;
void checkcpu()
{
    union myunion{
        int a;
        char c;
    }test;
    test.a = 1;
    if (test.c == 1)
        cout << "little endian" <