c++类中的默认成员函数——构造，析构，拷贝构造，赋值重载...

本文章可支持学过一遍把握不到重点和时间久了忘记这四个玩意的调用规则的人群，另外两个取对象地址的在最后。

重点是每个函数大标题下的小标题

目录

构造函数特性：

重点一，6.自动生成的构造函数对内置类型可能处理，对自定义类型调用它的构造。（char，int，double，char* 等为内置类型，class/struct/union等为自定义类型）

析构函数特性：

重点二，ps自动生成的析构函数对内置不做处理（int* , char*等类型所指向的资源也不被free），对自定义类型调用它的析构。自己生成的也会自动调用自定义类型的析构。

拷贝构造函数特性：

重点三，默认生成的是浅拷贝（值拷贝），对内置值拷贝，对自定义调用它的拷贝构造。自己实现的拷贝构造，调用了自定义类型的默认构造

运算符重载中的赋值运算符重载特性：

重点四，用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。ps自己实现的不调用自定义类型的赋值运算符重载。

取地址及const取地址操作符重载

---

看前须知：

默认成员函数：在一个class中，如果用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

函数重载：C++入门3.省缺参数和函数重载-CSDN博客

内置类型和自定义类型：（char，int，double，char* 等为内置类型，class/struct/union等为自定义类型）

先来bb两下，这四个玩意是函数，

构造函数用途是初始化（init）所在类模板所创建的对象，

析构函数用途是free释放对象申请的堆空间内存，

拷贝构造是构造函数的一种重载，用同类对象初始化一个对象，

赋值重载是运算符重载，用来对“=”这个运算符重载，使“=”运算符支持它所在的那个类。

构造函数特性：

1. 函数名与类名相同。

2. 无返回值。

3. 对象实例化时编译器自动调用对应的构造函数。

4. 构造函数可以重载。

class Date
{
public:
    // 1.无参构造函数
    Date()
    {}
    // 2.带参构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
void TestDate()
{
    Date d1; // 调用无参构造函数
    Date d2(2015, 1, 1); // 调用带参的构造函数
    // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
    Date d3();
}

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。（自己弄的拷贝构造也会影响编译器自己生成构造函数）

重点一，6.自动生成的构造函数对内置类型可能处理，对自定义类型调用它的构造。（char，int，double，char* 等为内置类型，class/struct/union等为自定义类型）

ps自己写的构造也会自动调用自定义类型的默认构造。

class A {
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A() {
		cout << "~A()" << endl;
	}
	A(A& a) {
		cout << "A(A& a)"  << endl;
	}
private:
	int _a;
};

class B {
public:
	B() {
		cout << "B()" << endl;
	}
	~B() {
		cout << "~B()" << endl;
	}
	//B(B& b) {
	//	cout << "B(B& b)" << endl;
	//}
private:
	int _b;
	A _a;
};

int main()
{
	B b1;
	B b2(b1);
	return 0;
}

7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个（调用歧义）。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

补充：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。ps逐步调试的时候看起来很像初始化列表。

class Time
{
public:
    Time()
    {
        cout << "Time()" << endl;
        _hour = 0;
        _minute = 0;
        _second = 0;
    }
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
private:
    // 基本类型(内置类型)
    int _year = 1970;
    int _month = 1;
    int _day = 1;
    // 自定义类型
    Time _t;
};
int main()
{
    Date d;
    return 0;
}

析构函数特性：

析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。对象中资源——构造的时候额外申请的堆上的空间（局部在栈上，new的在堆上，要用delete销毁）

重点二，ps自动生成的析构函数对内置不做处理（int* , char*等类型所指向的资源也不被free），对自定义类型调用它的析构。自己生成的也会自动调用自定义类型的析构。

class A {
public:
	A(int* tmp)
		:_a(tmp)//初始化列表
		,_b(1)
	{
		cout << "A(int* tmp)" << endl;
	}
	~A() {
		cout << "~A()" << endl;
	}
private:
	int* _a;
	int _b;
};
int main()
{
	int* tmp = (int*)malloc(4);
	{
		A a1(tmp);
	}
	cout << "will to free" << endl;
	free(tmp);
	return 0;
}

特性：

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值类型。

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构 函数不能重载

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

5. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

拷贝构造函数特性：

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

特性：

1. 拷贝构造函数是构造函数的一个重载形式。 

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。——因为对于类类型传值形参的创建就要用到对应的拷贝构造。

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

4. 拷贝构造函数典型调用场景：

。使用已存在对象创建新对象

。函数参数类型为类类型对象

。函数返回值类型为类类型对象

重点三，默认生成的是浅拷贝（值拷贝），对内置值拷贝，对自定义调用它的拷贝构造。自己实现的拷贝构造，调用了自定义类型的默认构造

class A {
public:
	A()
		:_a(3)
	{
		cout << "A()" << endl;
	}
	~A() {
		cout << "~A()" << endl;
	}
	A(A& a) {
		cout << "A(A& a)"  << endl;
	}
private:
	int _a;
};

class B {
public:
	B() 
		:_b(4)
	{
		cout << "B()" << endl;
	}
	~B() {
		cout << "~B()" << endl;
	}
	B(B& b) {
		cout << "B(B& b)" << endl;
	}
private:
	int _b;
	A _a;
};

int main()
{
	B b1;
	B b2(b1);

	return 0;
}

运算符重载中的赋值运算符重载特性：

1. 赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率 

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

检测是否自己给自己赋值——可能会造成资源的浪费（当swap自己时候，谁用谁知道）

返回*this ：要符合连续赋值的含义 

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数——因为是默认的成员函数，不实现会默认生成，

重点四，用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。ps自己实现的不调用自定义类型的赋值运算符重载。

class A {
public:

	A& operator=(const A& a) {
		cout << "A& operator=(const A& a) " << endl;
		return *this;
	}
private:
	int _a;
};

class B {
public:

	//B& operator=(B& b) {
	//	cout << "B& operator=(B& b)" << endl;
	//	return *this;
	//}
private:
	int _b;
	A _a;
};

int main()
{
	B b1;
	B b2;
	b2 = b1;

	return 0;
}

取地址及const取地址操作符重载

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; 
	int _month; 
	int _day; 
};

默认生成的就够用，