1.C++中的切片问题

class Object
{int value;
public:Object(int x = 0):value(x) {}
};
class Base : public Object
{int num;
public:Base(int x = 0):Object(x + 10),num(x) {}
};
int main()
{Object obja;Base base(10);return 0;
}

切片问题是继承关系，必须是公有继承，只有把子对象赋给父对象时，才存在切片问题，obja对象成员只有一个value，是4字节，对于base对象来说，它继承了一个隐藏父对象，一共是8字节(value和num)，value的值为20，num的值为10，可以把子对象赋给父对象，但是不能把父对象赋给子对象，赋值的时候，就把子对象的value值赋值给了父对象的value值

2.下面程序的内存分布是怎么样的？

#define SEQ_INIT_SIZE 10
class SeqList
{int data[SEQ_INIT_SIZE];int maxsize;int cursize;
public:SeqList() :maxsize(SEQ_INIT_SIZE),cursize(0) {}~SeqList() {}
};
int main()
{SeqList seqa;return 0;
}

进入到主函数的时候要给seqa分配空间，直接分配48个字节

写出上面程序的缺省拷贝构造函数和缺省赋值运算符重载函数

//拷贝构造函数
SeqList(const SeqList& src) :maxsize(src.maxsize), cursize(src.cursize)
{//memcpy(data,src.data,sizeof(data));//yesmemcpy(data,src.data,sizeof(int) * cursize);//yes
}
//赋值运算符重载函数
SeqList operator=(const SeqList& src) 
{if(this != &src){maxsize = src.maxsize;cursize = src.cursize;//memcpy(data,src.data,sizeof(data));//yesmemcpy(data,src.data,sizeof(int) * cursize);//yes}	  return *this;
}

为了使拷贝构造函数具有很好的通用性，加了一个const，既可以用普通对象来拷贝构造，也可以用常对象来拷贝构造，而为了防止死递归，拷贝构造函数必须传引用

初始化列表只能在构造函数和拷贝构造函数中出现，在其他成员函数中不具有这种方式，原因是防止重复构建对象，如：SeqList seqa;SeqList seqb; seqb = seqa;当执行完前两句的时候seqa和seqb已经被构建出来了，如果赋值运算符重载函数有初始化列表，那么seqb就被重复构建了，对象只能构建一次，对象中的数据成员也只能构建一次

3.如果不希望用一个对象去初始化另一个对象，怎么办？将拷贝构造函数设计成私有的

如果我把main函数设计成类的友元函数后，还是可以用一个对象去初始化另一个对象，怎么办才能禁止呢？我在把拷贝构造函数设计成私有的以后，函数体我也不要了，只留下一个声明(SeqList(const SeqList& seq)😉，这样的好处是只给一个声明是告诉编译器我已经给出拷贝构造函数了，你不要再产生拷贝构造函数了，没有函数体意味着所有能进行拷贝构造的方法我都给你禁止了，这时就算是友元函数也没有办法进行拷贝构造函数了，因为没有函数体了，在c11标准中，可以将声明改为SeqList(const SeqList& seq) = delete;告诉编译器我们将会把拷贝构造函数删除，我不提供拷贝构造函数，我也不希望编译器你提供缺省的拷贝构造函数，这样我就可以阻碍对象的拷贝构造

其他函数也一样，如果我们不想用对象给另一个对象赋值，就把赋值运算符重载函数放到私有里面，只留一个函数体，即SeqList& operator=(const SeqList& src) = delete;//c11标准下

如果我们把构造函数定义成私有的，那么外界是没有办法直接构造对象的，那么应该怎么做，才能让外界构造对象呢？

一般情况下不能把析构函数定义为私有，如果定义成私有了，对象一旦创建，就没有办法销毁了

4.下面程序的内存分布是怎么样的？

#define SEQ_INIT_SIZE 10
#define SEQ_INC_SIZE 2	
class Vector
{int* first;int* last;int* end;
public:Vector():_first(NULL),_last(NULL),_end(NULL){_first = (int *)malloc(sizeof(int) * SEQ_INIT_SIZE);_last = _first;_end = _first + SEQ_INIT_SIZE;}~Vector(){free(_first);_first = _last = _end;}
};
int main()
{Vector vec;return 0;
}

vec._last - vec._first; 它的差值是元素的个数，也是当前元素的个数(cursize)
vec._end - vec._fist; 它的差值是容量的大小，也就是maxsize

5.写出下面程序的缺省拷贝构造函数和缺省赋值运算符重载函数

#define SEQ_INIT_SIZE 10
class SeqList
{int* data;int maxsize;int cursize;
public:SeqList() :data(NULL),maxsize(SEQ_INIT_SIZE),cursize(0){data = (int *)malloc(sizeof(int) * maxsize);}~SeqList(){free(data);data = NULL;}//缺省拷贝构造函数SeqList(const SeqList& src):maxsize(src.maxsize),cursize(src.cursize){data = seq.data;}//缺省赋值运算符重载函数SeqList operator=(const SeqList& src){if(this != &seq){maxsize = src.maxsize;cursize = src.cursize;data = seq.data;}return *this;}
};
int main()
{SeqList seqa;SeqList seqb(seqa);return 0;
}

那么上面程序存在的问题是什么？
由于seqa和seqb的data指针都指向堆区的一个空间，那么当第二次析构也就是析构seqa的时候，就会导致一块空间被重复析构，就会导致程序崩溃

如果main函数改成如下程序，存在的问题是什么？

int main()
{SeqList seqa;SeqList seqb;seqb = seqa;return 0;
}

先构造对象seqa，再构造对象seqb，此时seqa指向一块堆空间，seqb指向一块堆空间，当seqb = seqa时，seqb.data就会指向seqa.data，导致seqb之前指向的堆空间丢失了，①会造成内存泄露，其次，seqb再析构完成后，析构seqa时会重复释放seqa.data指向的空间，②会导致程序崩溃

那问题来了：什么情况下缺省构造和缺省赋值就已经足够，又什么情况下必须需要写自己的拷贝构造函数和赋值运算符重载函数呢？
凡是在类设计的过程中，如果有指针(指向堆区或者文件指针)或者设计线程id号时，都必须重写自己的拷贝构造和赋值运算符重载函数

那么上述程序的拷贝构造如何修改呢？

	//拷贝构造函数SeqList(const SeqList& src):maxsize(src.maxsize),cursize(src.cursize){data = (int *)malloc(sizeof(int) * src.maxsize);memcpy(data,src.data,sizeof(int) * src.cursize);}

上面拷贝构造函数为深拷贝，就不会导致程序崩溃了，seqa.data指向一块堆空间，seqa.maxsize = 10，seqa.cursize = 0，seqb.data也指向一块堆空间，seqb.maxsize = 10，seqb.cursize = 0，当析构的时候，seqb析构自己指向的堆空间，seqa析构自己指向的堆空间，两个对象互不冲突

那么上述程序的赋值语句如何修改呢？

	//赋值运算符重载函数SeqList operator=(const SeqList& src){if(this != &seq){maxsize = src.maxsize;cursize = src.cursize;//先释放原有空间free(data);data = (int *)malloc(sizeof(int) * src.maxsize);memcpy(data,src.data,sizeof(int) * src.cursize);}return *this;}

上面的赋值为深赋值，seqa.data指向一块堆空间，seqa.maxsize = 10，seqa.cursize = 0，seqb.data指向另一块堆空间，seqb.maxsize = 10，seqa.cursize = 0，当执行seqb = seqa;时，先把seqb指向的堆空间free掉，然后再重新申请一块堆空间，再把seqa的数据拷贝到seqb中

6.String类

class String
{
private:char* str;String(char *p,int){str = p;}
public:String(const char* p = NULL):str(NULL){if(p != NULL){str = new char[strlen(p) + 1];strcpy(str,p);}else{str = new char[1];//为什么只开辟一个空间，而不是str = NULL;?*str = '\0'';}}~String(){if(str != NULL){delete[] str;}str = NULL;}ostream& operator<<(ostream& out) const{if(str != NULL){out << str;}return out;}String(const String& s){//str = s.str;//error，是浅拷贝，两个str都指向同一块空间str =  new char[strlen(s.str) + 1];//深拷贝strcpy(str,s.str);}String& operator=(const String& s){if(this != &s){delete[] str;str = new char[strlen(s.str) + 1];strcpy(s,s.str);}return *this;}String operator+(const String& s) const{char *p = new char[strlen(this->str) + strlen(s.str) + 1];strcpy(p,this->str);strcat(p,s.str);return String(p,1);//去调动私有构造函数，就可以解决p的内存泄露问题}String operator+(const char *p) const{char *p = new char[strlen(this->str) + strlen(s) + 1];strcpy(p,this->str);strcat(p,s);return String(p,1);//去调动私有构造函数，就可以解决p的内存泄露问题}
};
ostream& operator<<(ostream& out,const String& s)
{s << out;return out;
}
String operator+(const char *p,const String& s)
{return String(p) + s;
}
int main()
{String s1("sunpeng");cout << s1 << endl;operator<<(cout,s1);String s2("hello");String s3;s3 = s1 + s2;s3 = s1 + "newdata";s3 = "newdata" + s1;return 0;
}

s1 << cout;等同于s1.operator<<(cout);等同于operator(&s1,cout);
ostream& operator<<(ostream& out) const 等同于 ostream& operator<<(const String* const this,ostream& out)

ostream& operator<<(ostream& out) const 形参列表中的ostream& out必须是引用，原因是 cout 的拷贝构造函数定义成了保护类型，所以不能用cout去初始化out，因为拷贝构造函数是保护类型的，所以必须用引用，引用并不构建对象，不需要调动拷贝构造函数

移动构造和移动赋值的目的是尽可能少的对堆区进行new和delete

String(String&& s);
String& operator=(String&& s);

lvalue：左值
xvalue：将亡值
rvalue：右值
prvalue：重右值

一般返回值还要继续被处理的情况就返回引用 ，运算符重载返回为引用的运算符有:[],=,输入 >> 输出 << 运算符，自加++自减–运算符