C++ 类和对象上（this指针，六个默认成员函数）

对象大小如何计算：

对象中只存储成员变量，不存储成员函数。因为一个类可以实例化出多个对象，每个对象的成员变量可以存储不同的值，但是调用的函数却是一个。如果每个对象都放成员函数，而这些成员函数都一样，那么空间就浪费了，所以把成员函数放在一个公共区域。所以对象的大小是成员变量之和，并且考虑内存对齐。没有成员变量的类的大小是1个字节。
这一个字节不是为了存储数据，是为了占位表示对象存在。

this指针：

我们先来定义一个日期类Date：

class Date { 
    public : 
        void Display () { 
            cout <<_year<< "-" <<_month << "-"<< _day <<endl;
        }
        void SetDate(int year , int month , int day) { 
            _year = year; _month = month; _day = day; 
        }
    private : 
        int _year ; // 年 
        int _month ; // 月 
        int _day ; // 日 
};
int main() { 
    Date d1, d2; 
    d1.SetDate(2018,5,1); 
    d2.SetDate(2018,7,1); 
    d1.Display(); 
    d2.Display(); 
    return 0; 
}

this指针本质上其实是一个成员函数的形参,比如SetDate(int year , int month , int day)函数，我们定义时是无参数但是编译时会自动加上一个参数 SetDate(Date* this,int year , int month , int day)如下图所示：

而在调用时谁调用就传入谁的地址例如：d1.SetDate(2018,5,1); -》 SetDate(&d1,2018,5,1)。相应的d2调会传入d2的地址。
（1）this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this 形参。所以对象中不存储this指针。
（2）this指针是成员函数第一个隐含的指针形参，一般情况下比如vs编译器通过ecx寄存器自动传递，不需要用户传递。
（3）this指针的类型：类类型* const。

那么this指针可以为空吗？
我们看如下代码：

class A { 
public: 
    void PrintA() { 
        cout<<_a<<endl;
    }
    void Show() { 
        cout<<"Show()"<<endl;
    }
private: 
    int _a;
}
int main(){
    A* ptr = NULL;
    ptr ->PeintA();//(1)
    ptr ->Show();//(2)
}

首先这段代码编译没有错误，在运行时（1）会崩溃。因为ptr为空 在执行ptr ->_a时就会崩溃。
而（2）会正常运行。这就说明了对象不保存成员函数，虽然ptr为空，但是成员函数是放在公共代码段的，而不是放在ptr所指向的对象里的。

构造函数

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员 都有 一个合适的初始值，并且在对象的生命周期内只调用一次。
特征如下：

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

class Date{
public:
	Date(){//无参构造函数
		_year = 0;
		_month = 0;
		_day = 0;
	}
	Date(int year,int month,int day){//函数重载
		_year = year;
		_month = month;
		_day = day;
	}
	void Print(){
		cout<<_year << _month << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main(){
	Date d1;
	Date d2(2020,1,1);
	d1.Print();
	d2.Print();
	return 0;
}

上述代码构造函数Date（）；和Date（int year,int month,int day）其实可以使用一个全缺省构造函数代替：

Date(int year = 0,int month = 0,int day = 0){//全缺省构造函数
    _year = year;
    _month = month;
    _day = day;
}

需要注意的是：
（1）全缺省构造函数，和无参构造函数不可以同时存在，因为若同时存在，执行代码 Date d1;就会出现对重载函数的调用不明确。
（2）如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
（3）无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参 构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数
6. ：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如 int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现 编译器默认生成的构造函数，会调用自定义类型成员_t的构造函数。

class Time{
public:
	Time(int hour,int minute,int second){
		cout <<"Time"<<endl;
		_hour = hour;
		_minute = minute;
		_second = second;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date{
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
int main(){
	Date d1;
	return 0;
}

上述代码会编译不通过，因为_t是自定义类型，在它实例化的过程中会调用（Time类）构造函数，又因为Time类定义了有参的构造函数，系统就不会定义默认构造函数了。所以编译器找不到合适的构造函数使用，就会报错。

析构函数：

与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而 对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。比如：
（1）我们在构造函数里打开文件，在析构函数里关闭打开的文件。这是一个比较好的做法。
（2）在构造函数里，我们去连接数据库的连接，在析构函数里关闭数据库的连接。
（3）在构造函数里动态的分配内存，那么在析构函数里把动态分配的内存回收。

析构函数的特征：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。对于编译器自己生成的默认析构函数它不是什么事情都不做，因为他的默认构造函数很像，碰到自定义类型会调用该类型的析构函数。
5. 关于析构函数的调用顺序，后进先出：先定义的后析构，后定义的先析构。

拷贝构造：

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象 创建新对象时由编译器自动调用。

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。比如：

class Date{//日期类
public:
	Date(){//无参构造函数
		_year = 0;
		_month = 0;
		_day = 0;
	}
     Date(Date d){//拷贝构造函数
		_year = d.year;
		_month = d.month;
		_day = d.day;
	}
     
private:
	int _year;
	int _month;
	int _day;
};
int main(){
    Date d1;//调用（无参的）默认构造函数
    Date d2(d1);//调用拷贝构造函数
}

例如在执行 Date d2(d1);的时候调用拷贝构造函数：
Date(Date d){//拷贝构造函数
_year = d.year;
_month = d.month;
_day = d.day;
}
调用的是拷贝构造函数，但是因为调用的时候要传参，用实参d1传给形参d，d = d1又要调用拷贝构造函数，Date d2(d1) -> Date(Date d(d1)); -> Date d(d1) -> Date (Date d(d1)) …无限循环下去。
所以拷贝构造函数必须使用引用传参Date d2(d1) -> Date(const Date &d = d1);

3. 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷 贝，这种拷贝我们叫做浅拷贝，或者值拷贝。
   如果是像上边的的日期类，我们可以不写拷贝构造函数，因为编译器帮我们生成的磨人的拷贝构造函数就够用了。但如果在构造函数里动态的分配内存，那么这种浅拷贝的构造函数就会出现问题比如下边的类：

class String {
public: 
    String(const char* str = "jack"){
        _str = (char*)malloc(strlen(str) + 1);
        strcpy(_str, str);
    }
    ~String(){
        free(_str);
    }
private:
    char* _str;
}
int main(){
    String s1("hello");
    String s2(s1); 
}

上边的程序会崩溃，因为使用浅拷贝后s2._str 和 s1._str指向同一块内存空间。所以在最后析构的时候同一块内存空间会被free();两次，所以程序会崩溃。
想要解决这个问题就要自己写一个拷贝构造函数，给s2._str 重新开辟空间，并将s1的字符串拷贝过来。代码如下：

String(const String& s){
    _str = (char* )malloc(strlen(s._str) + 1);
    strcpy(_str, s._str);
}

运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意点：
（1）不能通过连接其他符号来创建新的操作符：比如operator@
（2）重载操作符必须有一个类类型或者枚举类型的操作数
（3）用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义
（4）.* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。
赋值运算符的重载：
（1）赋值运算符的重载是默认成员函数，一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，但是与拷贝构造函数一样，这种赋值是按字节序的值拷贝（浅拷贝）。
（2）既然赋值运算符的重载和拷贝构造函数完成的是相同的工作，那么他存在的意义是什么呢？
拷贝构造函数是用来初始化的，只能在对象实例化的时候调用，而赋值运算符重载则是对两个已经初始化的对象使用的。
（3）用上边的日期类举例：
Date d1(2020, 4, 11);//构造函数
Date d2 = d1;//这里会调用拷贝构造，而不是赋值运算符。因为是对d2的初始化。
取地址及const取地址操作符重载:
&操作符的重载也是一个默认成员函数，它的功能就是返回this指针。以Date类为例实现如下：

Date* operator&() {//成员函数1
    return this ; 
}
const Date* operator&()const{//成员函数2
    return this ; 
}
int main(){
    Date d1;
    const Date d2;
    &d1;//调用成员函数1
    &d2;//调用成员函数2
}

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载。