3.调用

推荐使用无参构造，另外要注意匿名对象只在其所在的语句有效

(1)分类

按构造的参数来说:

• 无参
• 有参

按构造的方式来说:

• 隐式构造
  • 语法简单，推荐
• 显示构造
  • 语句较多，意义不大

按是否有对象来说:

• 非匿名对象，就是正常构造得到的
• 匿名对象，其对象会在当期语句结束被立即释放

特殊：构造函数的隐式转换

• 只有在类中只有一个数据成员时才会出现

  就其底层其实就是调用了类的有参构造

  类名 对象名 = 值;
  

(2)示例

int main()
{
    //隐式调用无参构造
    Data obj1;
    //显示调用无参构造
    Data obj2 = Data();

    //隐式调用有参构造
    Data obj3(8);
    //显示调用有参构造
    Data obj4 = Data(6);
     
    //匿名对象，只要当前语句结束，该对象就会释放
    Data();
    Data(9);
    return 0;
}

六.析构函数

1.概述

当类中没有指针成员时，虽然析构函数显得多余，但仍需创建析构函数，置空就好

(1)介绍

析构函数在对象生命周期结束的时候，会被系统自动调用，它的调用是先于系统对空间的清理的，它主要用于清理系统自动清理无法清除的东西，例如类内部指针指向对的堆区

(2)使用场景

• 当类内存在指针成员时，必须写析构函数

  系统自动清理只能清理类对象所占用的空间，如果其内部有指针成员指向堆空间，那它是无法清理的，需要借助析构函数在它之前进行对堆区空间进行处理

2.语法

(1)特点

1. 析构函数的名称是在类名前加上波浪符(~)
2. 析构函数没有返回类型，也没有参数
3. 析构函数不能是const、volatile或static的
4. 一个类只能有一个析构函数,即不能重载

(2)格式

~类名() {  
    // 释放资源、执行清理操作的代码  
}

3.示例

下面的例子中str构造的形参是const char * str，这是C++标准规定的

下面的例子中str是一个指针变量，其指向了对象外的堆区，此时需要使用析构函数调用free()对str指向的堆区进行释放，后再进行对象的清理，以避免堆区的泄露

#include 
#include 
#include 
#pragma warning(disable:4996)
using namespace std;

class Data {
private:
	int num;
	char* str;
public:
	Data() {
		num = 0;
		cout << "无参构造,初始化num的值为:" << num << endl;
	}
	Data(int a) {
		num = a;
		cout << "有参构造,初始化num的值为:" << num << endl;
	}
	Data(const char* Mstr) {
		str = (char*)calloc(1, strlen(Mstr) + 1);
		strcpy(str, Mstr);
		cout << "构造结果: " << str << endl;

	}
	~Data() {
		cout << "析构函数" << endl;
		if (str != NULL) {
			free(str);
			str = NULL;
		}

	}

};

void test() {
	Data obj5("hello");
}

int main()
{
	test();
}

七.拷贝构造函数

1.概述

本质: 拷贝构造的本质就是构造函数，用于拷贝旧对象初始化新对象的构造函数

**默认拷贝函数:**如果用户不提供拷贝函数，编译器默认也会提供一个拷贝函数，它会将旧对象的所有属性值拷贝到新对象--浅拷贝

调用时机:

必须要创建对象的时候就用旧对象对其进行初始化，才会调用构造函数

旧对象 初始化 新对象时才会调用拷贝构造

Data ob1(10);//创建对象，对后面来说就是旧对象
Data ob2 = ob1;//调用了拷贝函数
//----------------------------------------------------
Data ob3(10);//创建对象，对后面来说就是旧对象
Data ob4;//调用了无参构造
ob4 = ob3;//只是进行了简单的赋值，并没有调用拷贝函数

2.格式&示例

1.格式

**内部定义：**拷贝函数一般要在函数内将传入对象的数据考到新对象的对应位置

注意点：

• 为了不让函数修改旧对象，一般使用Const修饰
• 为了节省空间，一般参数使用引用

    类名(const 类名 &旧对象引用){
        cout << "拷贝函数" << endl;
        //拷贝旧对象信息到新对象的语句
    }

2.拷贝构造 和 无参构造 有参构造的关系

• 如果用户定义了 拷贝构造或者有参构造 都会屏蔽无参构造。
• 如果用户定义了 无参构造或者有参构造 不会屏蔽拷贝构造

3.示例

代码：

#include 

using namespace std;

class Data {
public:
    int num;
public:
    Data() {
        num = 0;
        cout << "无参构造,初始化num的值为:" << num << endl;
    }
    Data(int a) {
        num = a;
        cout << "有参构造,初始化num的值为:" << num << endl;
    }
    Data(const Data &p){
        cout << "拷贝函数" << endl;
        //拷贝函数一般要在函数内将传入对象的数据考到新对象的对应位置
        num = p.num;
    }
    ~Data() {
        //析构函数的调用次数间接表示了该类所创建的对象数量
        cout << "析构函数" << endl;
    }

};

int main()
{
    Data ob1(19);
    Data ob2 = ob1;
    cout << "ob2的num为：" << ob2.num << endl;
    return 0;
}

结果:

只调用了一次构造，就完成了两个对象的初始化，这就是调用了拷贝函数

有参构造,初始化num的值为:19
拷贝函数
ob2的num为：19
析构函数
析构函数

3.拷贝构造的调用时机

(1)旧对象给新对象初始化

当用旧对象给新对象初始化时会调用拷贝构造，将旧对象的值拷贝给新对象

Data obj(10);
Data obj2 =obj1;//调用拷贝构造

(2)普通对象作为函数参数

当使用普通函数作为函数参数时，调用函数会发生拷贝构造，将转入值拷贝给函数参数

void fun(Data obj){//调用拷贝构造，将obj1的值拷贝给obj,相当于Data4 obj = obj1;
    cout << ob.mA << endl;
}
void test(){
    Data obj1(100);
    fun(ob1);
}

(3)函数返回值普通对象

在vs和qt, Linux中因为优化策略不同，导致前者会调用拷贝函数，而后两者不会，就原理而言，后者两者更加高效

① Visual Studio

Ⅰ.概述

Visual Studio会发生拷贝构造

Ⅱ.图解

至于ob2的赋值，编译器是让ob2直接接管匿名对象的空间，而不另外开辟空间，所以也不存在调用拷贝函数一说

在Vscode中，拷贝构造的调用是在return的，它返回数据时是将数据存储在临时栈区，它会在临时栈区创建一个匿名对象，而这拷贝构造的调用旧体现在其将返回对象交给临时栈区的匿名对象的时候

② Qtcreater,linux

Qtcreater,linux不会调用拷贝函数

Qtcreater,Linux的编译器在上面的基础上进一步优化，它会先整体"审视"代码，发现函数返回的对象的内容最终还是会被调用函数的对象接收的，它就干脆不释放了，直接让接收的对象接管本该释放对象的空间，即将接收对象的指针指向了它。这样就省略了中间的拷贝和释放了

4.拷贝函数的浅/深拷贝

(1)概念

① 浅深拷贝的概念

1. 浅拷贝（Shallow Copy）：

   就是简单的赋值操作，普通变量还好，遇到指针变量就会让新旧指针指向同一内存空间，造成内存管理问题

   • 浅拷贝仅复制对象的成员变量的值，而不复制对象所拥有的资源（如动态分配的内存）。
   • 如果对象中包含指针并指向动态分配的内存，那么浅拷贝会导致两个对象共享同一块内存。
   • 当其中一个对象被销毁时，它可能会释放这块内存，导致另一个对象的指针指向无效的内存。

2. 深拷贝（Deep Copy）：

   就是为新对象申请了和旧对象一样的内存空间，并存储相关信息

   • 深拷贝不仅复制对象的成员变量的值，还复制对象所拥有的资源。
   • 对于每个对象，深拷贝都会为其分配新的资源，确保每个对象都有其自己的资源副本。
   • 这样，即使一个对象被销毁，也不会影响到其他对象。

(2)使用时机

**前置:**默认的拷贝构造是浅拷贝

• 如果类中没有指针成员，不用实现拷贝函数和析构函数
• 如果类中存在指针成员。则必须实现析构函数释放指针所指向的堆区空间，必须实现拷贝函数完成深拷贝动作

① 对含指针变量类使用浅拷贝(错例)

概述：

浅拷贝只是单纯的将旧对象的指针交给了新对象的指针，二者其实指向的是同一个堆空间，当其中一方生命周期结束，释放空间，该堆空间就消失了。这样，等到新对象生命周期结束，要释放对象调用析构释放空间时，就会出现双free()的情况了

代码： 下面没有下拷贝函数，因为默认的就是浅拷贝

#include 
#include 

using namespace std;

class Data {
public:
    char *name;
public:
    Data() {
        name = NULL;
    }

    Data(const char *input) {
        name = (char *) calloc(1, strlen(input) + 1);
        strcpy(name, input);
        cout << "有参构造" << endl;
    }

    ~Data() {
        cout << "析构函数" << endl;
        if (name != NULL) {
            free(name);
            name = NULL;
        }
    }
};

int main(){
    Data obj1("HelloWorld!");
    Data obj2 = obj1;
}

返回值:

显示检测到双重free(),这就是新旧对象的指针成员都指向了同一个内存空间所导致的，第一个对象生命周期结束，空间释放，当第二个对象生命周期结束，再次调用析构尝试释放已释放空间，就导致了双重free()的出现

有参构造
析构函数
析构函数
free(): double free detected in tcache 2
Aborted

② 对含指针变量类使用深拷贝

当进行深度拷贝时，每一个对象都有独立的成员

代码：

#include 
#include 

using namespace std;

class Data {
public:
    char *name;
public:
    Data() {
        name = NULL;
    }

    Data(const char *input) {
        name = (char *) calloc(1, strlen(input) + 1);
        strcpy(name, input);
        cout << "有参构造" << endl;
    }

/*    Data(const Data &input){
        //浅拷贝
        name = input.name;
        cout << "浅拷贝" << endl;
    }*/
    Data(const Data &input){
        name = (char *)calloc(1,strlen(input.name) +1);
        strcpy(name,input.name);
        cout << "深拷贝" << endl;

    }

    ~Data() {
        cout << "析构函数" << endl;
        if (name != NULL) {
            free(name);
            name = NULL;
        }
    }
};

int main() {
    Data obj1("HelloWorld!");
    Data obj2 = obj1;
}

输出:

可以看到，调用了两次析构函数释放对象的空间，程序也没有报错，那就是因为深拷贝使两个对象拥有了各自独立的空间，不会因为一边的释放空间而导致另一边出现问题

有参构造
深拷贝
析构函数
析构函数

八.初始化列表

简单说下用途，当类的成员对象包含其它类对象时，就要使用初始化列表对其它类的对象进行初始化

1.概述

(1)介绍

初始化列表（Initializer List）是一种在构造函数中初始化类成员变量的方法。初始化列表在构造函数体执行之前执行，因此它可以用于初始化那些不能在构造函数体中初始化的成员变量

(2)应用场景

就是类嵌套

简单说下用途，当类的成员对象包含其它类对象时，就要使用初始化列表优先对成员类对象进行初始化，否则默认会调用该类的无参构造为其赋值

**例:**Data2中包含了Data1的成员ob1，此时如果想要对Ob1进行初始化，就必须使用初始化列表

class Data1{
public:
    int num;
public:
/*省略构造*/
};

class Data2 {
public:
    char *name;
    Data1 ob1;
public:
/*省略构造*/
};

2.类内存在其它类成员对象的构造顺序

说这个是为了解释为什么不能用类自身的构造去构造其内部包含的其它类成员对象

构造类内包含其它类成员的类时，最先是进行类成员对象的构造的，而后才是类自身的对象，这也就导致了不能使用类自身的构造函数为其内部包含的类成员进行初始化的情况，因为等到类自身构造函数调用的时候，它内部的其它类成员早已使用默认的无参构造构造完了，完全轮不到类自身构造的什么事情

3.初始化列表格式

初始化列表，其实就是在构造函数参数列表后加:号，然后接成员对象的构造方法

**格式:**在参数列表右边:后接的，就是初始化列表了，它的执行顺序优先于类自身的构造函数

• 初始化列表的值：来源于参数列表，即外部传入用来构造的值

类名(参数列表):成员对象1(值),成员对象2(值){
    
}

4.示例

Data2类内包含Data1的成员方法，所以下面的例程中使用了参数列表对成员对象进行了初始化

#include 
#include 

using namespace std;

class Data1{
public:
    int num;
public:
    Data1(){
        num = 0;
    }
    Data1(int input){
        num = input;
    }
};


class Data2 {
public:
    char *name;
    //成员对象包含Data1类的对象
    Data1 ob1;
public:
    Data2() {
        name = NULL;
    }
    //使用了参数列表对Data1的对象进行初始化
    Data2(const char *input,int num):ob1(num){
        name = (char *) calloc(1, strlen(input) + 1);
        strcpy(name, input);
        cout << "有参构造" << endl;
    }
    Data2(const Data2 &input){
        ob1.num = input.ob1.num;
        name = (char *)calloc(1,strlen(input.name) +1);
        strcpy(name,input.name);
        cout << "深拷贝" << endl;
    }
    ~Data2() {
        cout << "析构函数" << endl;
        if (name != NULL) {
            free(name);
            name = NULL;
        }
    }
};

int main() {
    Data2 obj1("hello List",66);
    Data2 obj2 = obj1;
    cout << "obj2的值: " << obj2.name << obj2.ob1.num <

对象类型 数组名[数组长度];

对象类型 数组名[数组长度] = {
    对象类型(值),
    对象类型(值2),
    .....
}

class Data1{
public:
    int num;
public:
/*省略构造*/
};

class Data2 {
public:
    char *name;
    Data1 ob1;
public:
/*省略构造*/
};

int main() {
    Data2 obj[5];//不初始化成员
    Data2 arr[5] = {
            Data2("yiyi",21),
            Data2("erer",22),
            Data2("zhangsan",23),
            Data2("lisi",24),
            Data2("wangwu",25)
    };
    int index = sizeof(arr) / sizeof(Data2);//计算数组长度
    for(int i = 0;i < index;i++){//遍历对象数组
        cout << arr[i].name << " " << arr[i].ob1.num << endl;
    }
}

yiyi21
erer22
zhangsan23
lisi24
wangwu25

class Data3{
public:
    int num;
public:
    Data3(){
        num = 0;
    }
    Data3(int input){
        num = input;
    }
};
int main(){
    //构造函数的隐式转换
    Data3 obj1 = 100;
    cout<<"obj1的num："<

obj1的num：100

class Data3{
public:
    int num;
public:
    Data3(){
        num = 0;
    }
    //附加explicit关键字
    explicit Data3(int input){
        num = input;
    }
};
int main(){
    //构造函数的隐式转换
    Data3 obj1 = 100;
    cout<<"obj1的num："<

honestliu@My-Pc:/mnt/C++Poject$ g++ test01.cpp -o test01
test01.cpp: In function ‘int main()’:
test01.cpp:17:18: error: conversion from ‘int’ to non-scalar type ‘Data3’ requested
   17 |     Data3 obj1 = 100;
      |                  ^~~

int* p = new int;  // 分配一个int类型的内存，并返回指向它的指针

int* arr = new int[10];  // 分配一个包含10个int的数组的内存，并返回指向第一个元素的指针

delete p;  // 释放p指向的内存

delete[] arr;  // 释放arr指向的数组内存

 //创建字符数组
    char *pStr = new char[100];
    //创建整型数组
    int *pArr1 = new int[100];
    //创建整型数组并初始化
    int *pArr2 = new int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    //释放数组内存 
    delete[] pStr; 
    delete[] pArr1; 
    delete[] pArr2;