C++类中默认生成的六个成员函数

---

一、六个默认成员函数——构造函数

• 构造函数完成对该对象的初始化

class Person
{
public:
	Person()
    {
        // 默认无参构造函数， 不写编译器也会自己加上去
    }

    Person(int age, const char* name)
    {
        // 有参构造函数
    }
    
private:
    char* _name;
    int _age;
};

语法

• 函数名与类名相同
• 无返回值类型
• 对象实例化时，编译器自动调用对应的默认构造函数
• 构造函数可以重载

调用时：

Person p;	// 调用无参构造函数
Perosn p(18, "李四");	//调用有参构造函数
// Perosn p(); 这样写，编译器会认为 p 是函数名，无参数，返回值类型是Person 

默认构造函数

• 不需要传递参数就可以调用的构造函数叫默认构造函数

Perosn()
{
    // 无参构造函数
}

Person(int age=1, const char* name="zhangsan")
{
    // 全缺省构造函数
}

构造函数的特点

• 不写构造函数时，编译器会自动生成一个无参的默认构造函数

  一旦手写了一个构造函数，编译器将不再生成。

• 默认生成的构造函数，对于内置类型（基本类型，int/char/double/指针等）不做处理， 自定义类型会调用他的默认构造函数。

• 实例化一个对象时，编译器会自动调用它的默认构造函数。

• 无参构造和全缺省构造函数不能同时出现，否则编译器不知到要调用哪个构造函数。

在C++11中对内置类型成员不初始化的缺陷，做了补丁：

• 内置类型成员变量在声明时可以给默认值。

构造函数的形参部分可以有缺省值

private:
	int year = 2024;
	int month = 2;
	int day = 1;

Person(int age=1, const char* name="zhangsan")
{
    // 这里是全缺省构造函数
}

• 建议提供全缺省构造函数

二、析构函数

• 析构函数完成对象中资源的清理

  ~Person()
  {
  	cout<< "~Person()" << endl;
  }
  

特点：

• 析构函数名在类名前面加上字符~
• 无参数无返回值类型
• 一个类只能有一个析构函数。并且不能重载。
• 不写默认生成。功能：对内置类型不做处理， 对自定义类型成员, 会调用他的析构函数。
• 对象的生命周期结束时，自动调用析构函数。

类中没有资源申请（malloc)时, 可以不写。动态申请了，一定要写，否则会造成内存泄漏。

---

构造顺序：

• 全局对象优先于局部对象构造；
• 局部对象按照出现的顺序依次进行构造，无论是否被static 修饰；

析构顺序

​ 销毁一个对象，是要保证其内部每个自定义对象都可以正确销毁。有类似栈的味道，先构造的后析构。这样确保，当第一个优先构造的对象被销毁时，其他对象也都销毁了。

• 构造顺序是按照语句的顺序进行构造，析构是按照构造的相反顺序进行析构；

• static修饰对象时， 因为static改变了对象的生存作用域，需要等待程序结束时才会析构，释放对象；

  只需注意：static修饰的对象放在局部对象之后析构。

• 局部对象 > static 修饰的对象 > 全局对象（无论是否被static修饰，满足后进先出顺序）（越大，越优先析构）

// 设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？（ ）
C c;

int main()
{
	A a;
	B b;
	static D d;
    
    return 0；
}

分析:

1. 类的析构函数调用一般按照构造函数调用的相反顺序进行调用，但是要注意static对象的存在, 因为static改变了对象的生存作用域，需要等待程序结束时才会析构释放对象
2. 全局对象先于局部对象进行构造
3. 局部对象按照出现的顺序进行构造，无论是否为static
4. 所以构造的顺序为 c a b d
5. 析构的顺序按照构造的相反顺序析构，只需注意static改变对象的生存作用域之后，会放在局部对象之后进行析构
6. 因此析构顺序为B A D C

三、拷贝构造函数

C++ 规定，自定义类型都会调用自己的拷贝构造。传值传参，先调用拷贝构造函数完成实参与形参的赋值，在调用函数。

• 拷贝构造只有单个形参，是对本类对象的引用（一般常用const修饰）。用已经存在的类类型对象创建新对象时由编译器自动调用。
• 区别赋值运算符重载：用一个已经存在的类类型对象拷贝给另一个已经存在的类类型对象

class Date
{
public:
    // 拷贝构造函数
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    
private:
    int _year;
    int _month;
    int _day;
};

特征：

1. 拷贝构造函数是**：构造函数的一个重载形式**
2. 拷贝构造函数的参数只有一个， 且必须是类类型对象的引用（&），使用传值方式编译器会直接报错，因为会引发无穷递归调用。
3. 若未显示定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储字节序完成拷贝，叫做(浅拷贝),或者(值拷贝)
4. 编译器生成的默认拷贝构造函数， 内置类型对象是按照字节方式直接拷贝， 而自定义类型对象是调用其拷贝构造函数完成拷贝。
5. 一般对象传参，尽量使用引用类型，提高程序效率。

使用场景：

• 使用已经经存在的对象创建新对象。
• 函数参数类型为类类型对象。
• 函数返回值类型为类类型对象。

四、赋值运算符重载

class Date
{
public:
    // 等号运算符重载
    bool operator==(const Date& d)
    {
        return _year == d._year
            && _month == d._month
            && _day == d._day;
    }
    
    // 赋值运算符重载 d1 = d2;
    Date& operator=(const Date& d)
    {
       if(*this != &d)
       {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this;
    }
    
private:
    int _year;
    int _month;
    int _day;
};

• //[.*   ::   sizeof   ?:   .], 这5个运算符不能重载
  

• 函数原型：返回值类型 operator操作符(参数列表)

• 赋值操作运算符：

  • if 条件判断， 检查是否自己给自己赋值；
  • 有返回值是为了支持连续赋值。d1 = d2 = d3;
  • 返回*this, 符合连续赋值的含义。

• 赋值运算符只能重载成类的成员函数不能重载成全局函数。

  • 赋值运算符如果不显示实现，编译器会生成一个默认的赋值运算符重载，并且以值的形式逐字节拷贝。此时在类外自己实现一个全局的赋值运算符重载，与编译器默认生成的产生冲突。
  • 所以赋值运算符只能是类的成员函数。

五、六、取地址及const取地址操作符重载

// 。。。不重要

---

以上是C++类的六种默认成员函数，不写，则编译器默认生成。

---

七、知识点

（1）default 关键字

//强制编译器生成default关键字
class Time
{
    // 强制生成默认构造函数
    Time() = default;
};

（2）const 使权限缩小

int a = 10;
const int &b = a;//b 的权限缩小
// ======================
function(const int& x)
{
    // ...
}
function(10);//正确
function(a+b);//正确
// ======================
function(int& x)
{
    // ...
}
function(10);//错误
function(a+b);//错误
// 权限由const小权限，变大了

• 字面量具有常（const）属性

（3）类型转换之间会产生临时变量

• 临时变量具有常属性

  double d = 1.1;
  int i = d;
  
  const int& ri= d;
  

  

• 浮点数类型d，赋值给整型i，会先产生一个临时整型变量，将d的整数部分拷贝给tmp, 在把tmp赋值给整型i。

• 给d取别名，同样也会产生一个临时整型变量，ri 是这个临时变量的别名，且const修饰，不可修改。