C++ 类和对象构造函数

一类的6个默认成员函数：

如果一个类中什么成员都没有，简称为空类。

例：

#include <iostream>
class Empty 
{
    // 空类，什么成员都没有
};

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认构造函数：如果用户没有定义任何构造函数，编译器会自动生成一个默认构造函数。

拷贝构造函数：用于创建一个对象是另一个对象的副本。如果用户没有定义，编译器会生成一个默认的拷贝构造函数。

拷贝赋值运算符：用于将一个对象赋值给另一个对象。如果用户没有定义，编译器会生成一个默认的拷贝赋值运算符。

移动构造函数：用于将资源从一个对象移动到另一个对象。如果用户没有定义，编译器会生成一个默认的移动构造函数。

移动赋值运算符：用于将资源从一个对象移动并赋值给另一个对象。如果用户没有定义，编译器会生成一个默认的移动赋值运算符。

析构函数：用于销毁对象并释放资源。如果用户没有定义，编译器会生成一个默认的析构函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

二构造函数：

2.1：构造函数的概念：

构造函数是一个特殊的成员函数，它的名称与类名相同，没有返回值。在创建类的对象时，构造函数由编译器自动调用，用于初始化对象的数据成员。

2.2：构造函数的特征

函数名与类名相同。

没有返回值。

在对象实例化时由编译器自动调用。

构造函数可以重载，即一个类可以有多个构造函数，只要它们的参数列表不同。

2.3：无参/有参构造函数代码示例

class Date
{
public:
    //有参数的构造函数：
    //Date(int _year = 1999 , int _month = 2 , int _day = 26)
    
    // 无参构造函数：
    Date() //函数名与类名相同。
    
    {
        // 使用 this 指针访问成员变量
        this->_year = 2024;
        this->_month = 7;
        this->_day = 6;
    }

    void Print()
    {
        std::cout << this->_year << "-" << this->_month << "-" << this->_day << std::endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1; //调用无参数构造函数 
    d1.Print();

    //Date d2(2022, 7, 6); //调用带参构造函数
    //d2.Print();
    return 0;
}

Date()是无参的构造函数，没有参数。在对象 d1 创建时自动调用。你们有可能会问了，为什么在无参的构造函数里面this指针指向成员变量，那为什么main函数里见不到this指针呢？因为当 Date d1; 创建对象时，编译器会自动传递 d1 的地址给 this 指针所以就不需要显示this指针。

如果类中没有显式定义构造函数，编译器会自动生成一个无参的默认构造函数。一旦用户显式定义了任何构造函数，编译器将不再生成无参的默认构造函数。

2.4：默认构造函数代码示例

class Date 
{
public:
    void Print() 
    {
        std::cout << _year << "-" << _month << "-" << _day << std::endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main() 
{
     Date d1;
    d1.Print();
    return 0;
}

输出：

上面代码因我未显示定义构造函数所以编译器帮我生成了一个默认的构造函数而且是看不见的，那为什么默认生成的输出的值是随机值呢？

原来C++把类型分为内置类型和自定义类型，内置类型就是语言提供的基本数据类型，如int、char等。自定义类型是用户定义的类型，如使用class、struct、union定义的类型。

2.5：内置类型和自定义类型的默认构造函数处理

内置类型：

1.内置类型的成员变量在默认构造函数中不会被自动初始化

2.如果不显式初始化，成员变量的值将是未定义的（即随机值）

自定义类型：

1.自定义类型的成员变量在默认构造函数中会调用其默认构造函数。

这意味着，即使你没有显式定义自定义类型的构造函数，编译器也会自动调用默认构造函数来初始化这些成员变量。

例子：

class Time 
{
public:
    Time() 
    {
         // Time类的无参构造函数
        std::cout << "Time()" << std::endl;
        _hour = 0;
        _minute = 0;
        _second = 0;
    }

private:
    int _hour;
    int _minute;
    int _second;
};

class Date 
{
public:
    Date()// 初始化内置类型成员变量
    {
        this->_year = 2024;
        this->_month = 7;
        this->_day = 5;
    }

    void Print()
    {
        std::cout << _year << "-" << _month << "-" << _day << std::endl;
    }

private:
    int _year;  // 内置类型
    int _month; // 内置类型
    int _day;   // 内置类型
    Time _t;    // 自定义类型
};

int main() 
{
    Date d;  // 调用无参构造函数
    d.Print();
    return 0;
}

输出：

我们来说一下它的执行顺序：首先是执行主函数main当执行到 Date d; 时编译器就会先去调用自定义函数Time_t;然后等它全部初始化完成再去调用无参数构造并且初始化里面的内置类型。

那我们这是显式定义自定义类型的构造函数并且给成员变量赋值了，所以就不会出现随机值，如果想要显式定义自定义类型的构造函数并且不想要随机值那该怎么办呢？这时候C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。

例子：

class Date 
{
public:
    void Print()
    {
        std::cout << _year << "-" << _month << "-" << _day << std::endl;
    }

private:
    int _year = 2024;  // 内置类型
    int _month = 2; // 内置类型
    int _day = 1;   // 内置类型
};

输出：

2.6：默认构造函数

在C++中，默认构造函数是指在创建对象时不需要提供任何参数的构造函数。默认构造函数可以分为两种：

默认构造函数：一个类只能有一个真正的默认构造函数（不需要参数）。
无参构造函数和全缺省参数构造函数：
- 如果参数不同，它们会重载，编译器不会报错。
- 如果参数相同（即都没有参数），它们就相当于有两个默认构造函数，这时编译器会报错，因为无法区分调用哪个构造函数。

关键点

无参构造函数：没有参数的构造函数。 全缺省参数构造函数：所有参数都有默认值的构造函数。重载：当构造函数的参数列表不同，它们可以共存且不会冲突。

例子：

class Date 
{
public:
    // 无参构造函数
    Date() 
    {
        _year = 2024;
        _month = 7;
        _day = 2;
    }

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

    void Print()
    {
        std::cout << _year << "-" << _month << "-" << _day << std::endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main() 
{
    Date d;  // 调用无参构造函数
    d.Print();

    Date d2(2023, 4, 3);  // 调用全缺省参数构造函数
    d2.Print(); 
    return 0;
}

输出：