30天学习C++从入门到入土 --- Day04

落日映苍穹つ 2023-06-15 07:14 40阅读 0赞

### 文章目录 ###

*  对象的构造和析构
 *   *  构造和析构函数
     *   *  1. 定义及调用
         *   *  1.1 有关构造函数
             *  1.2有关析构函数
         *  2. 构造函数的分类及调用
         *   *  有参构造函数的三种调用方法：
         *  3.为什么需要构造函数和析构函数
         *  4.赋值构造函数（copy构造函数）调用的时机
         *   *  1，2
             *  3
             *  4
         *  5. 构造函数调用规则
         *  6. 浅层拷贝
         *  7. 构造函数的参数列表
         *   *  7.1构造函数初始化列表问题的解决
             *  7.2 构造函数个析构函数的调用顺序：
         *  8. new 和 delete
         *   *  8.1 new 分配 基础数据类型、数组、类的对象
         *  9. static
         *   *  9.1 静态成员变量
             *  9.2 静态成员变量

# 对象的构造和析构 #

创建一个对象时，需要做某些初始化工作，例如，对数据成员赋值。  
类的数据成员不能再声明类的时候初始化  
为了解决这个问题，C++编译器提供了构造函数来处理对象的初始化。

## 构造和析构函数 ##

### 1. 定义及调用 ###

#### 1.1 有关构造函数 ####

定义：

1.  C++中类可以定义**与类名相同**的特殊成员函数，这种与类名相同的成员函数叫**析构函数**
2.  构造函数在定义时可以有参数
3.  没有任何返回类型的声明

调用：  
4. 自动调用：一般情况下C++编译器会自动调用构造函数  
5. 手动调用：一些情况下需要自己手工调用构造函数

#### 1.2有关析构函数 ####

定义：

1.  C++中类可以定义一个特殊的成员函数清理对象，这个特殊的成员函数叫做析构函数
2.  语法：  
    ~ClassName()
3.  析构函数也没有参数和返回类型的声明
4.  析构函数在对象销毁时自动被调用

#include<iostream>
    using namespace std;
    
    class Test
    { 
    public:
    	Test()//无参数，无返回类型，构造函数
    	{ 
    		cout << "调用构造函数" << endl;
    	}
    	~Test()//无参数，无返回类型，析构函数
    	{ 
    		cout << "调用析构函数" << endl;
    	}
    };
    int main()
    { 
    	Test t1;
    
    	return 0;
    }

### 2. 构造函数的分类及调用 ###

#### 有参构造函数的三种调用方法： ####

1.  括号法 C++编译器自动调用的构造函数
2.  等号法 C++编译器自动调用的构造函数
3.  直接调用构造函数 手动调用构造函数

#include<iostream>
    using namespace std;
    
    class Test
    { 
    private:
    	int m_a;
    	int m_b;
    
    public:
    	Test()//1 无参构造函数
    	{ 
    		m_a = 0;
    		m_b = 0;
    		cout << "调用无参构造函数" << endl;
    	}
    
    	Test(int a , int b )//2 调用有参构造函数 有三种方法
    	{ 
    		m_a = a;
    		m_b = b;
    		cout << "调用有两个参数的构造函数" << endl;
    	}
    	Test(int a)
    	{ 
    		m_a = a;
    		m_b = 0;
    		cout << "调用一个参数的构造函数" << endl;
    	}
    	Test(const Test&object)//3
    	{ 
    		cout << "调用拷贝构造函数" << endl;
    
    	}
    
    	void prinT()
    	{ 
    		cout << "调用普通成员函数 \n" << endl;
    	}
    };
    
    
    int main()
    { 
    	Test t0;//调用无参构造函数
    	//调用有参构造函数 
    	//①括号法 C++编译器自动调用的构造函数
    	cout << "①括号法:" << endl;
    	Test t1(1,2);
    	t1.prinT();
    
    	cout << "②等号法:" << endl;
    	//②等号法 C++编译器自动调用的构造函数
    	//括号里的是逗号表达式，只输出逗号的最后一个值
    	//C++对等号的功能的增强
    	Test t2 = (1, 2,3,4,5);
    	Test t3 = 5;
    	cout << endl;
    	cout << "③直接调用构造函数:" << endl;
    	//③直接调用构造函数 手动调用构造函数
    	Test t4 = Test(1, 2);//t4对象的初始化
    
    	return 0;
    }

![在这里插入图片描述][20191121145432757.png]

### 3.为什么需要构造函数和析构函数 ###

#include<iostream>
    using namespace std;
    
    class Test
    { 
    private:
    	int m_a;
    	int m_b;
    public:
    	//显式初始化
    	void init(int a, int b)
    	{ 
    		m_a = a;
    		m_b = b;
    	}
    };
    int main()
    { 
    	//类没有提供构造函数，C++编译器会自动提供一个默认的构造函数
    	//类没有提供拷贝构造函数，C++编译器也会自动提供一个拷贝构造函数
    	Test t;
    	t.init(1, 2);
    
    	//显式的初始化 显得很累赘
    	Test tArray[3];
    	tArray[0].init(1, 2);
    	tArray[1].init(1, 2);
    	tArray[2].init(1, 2);
    
    	//如果涉及到参数个数过多的 很不适用
    	Test tArray1[100];
    
    	return 0;
    }

### 4.赋值构造函数（copy构造函数）调用的时机 ###

> 完成两个对象之间的赋值，用一个对象去初始化另外一个初始化

4种调用场景

#### 1，2 ####

#include<iostream>
    using namespace std;
    
    class Test
    { 
    private:
    	int m_a;
    	int m_b;
    
    public:
    	Test(int a, int b)
    	{ 
    		m_a = a;
    		m_b = b;
    		cout << "调用有两个参数的构造函数" << endl;
    	}
    	Test(const Test& object)
    	{ 
    		cout << "调用拷贝构造函数" << endl;
    		m_a = object.m_a + 100;
    		m_b = object.m_b + 100;
    	}
    
    	void prinT()
    	{ 
    		cout << "调用普通成员函数 \n" << endl;
    		cout << "m_a" << m_a << endl
    			 << "m_b" << m_b << endl;
    	}
    };
    
    //赋值构造函数的功能：
    //两个对象之间的赋值，用一个对象来初始化另外一个初始化
    
    int main()
    { 
    	Test t(1, 2);
    	Test t1(2, 3);
    	//①第一种调用方法
    	Test t0 = t;//用t对象来初始化t1对象 -------初始化操作
    	t0.prinT();
    	//赋值操作不会调用copy构造函数
    	t1 = t0;//用t0对象来给t1赋值 --------赋值操作
    	t1.prinT();
    
    	//②第二种调用方法 
    	Test t2(t);
    	t2.prinT();
    	
    	return 0;
    }

#### 3 ####

#include<iostream>
    using namespace std;
    
    class Location
    { 
    private:
    	int X, Y;
    public:
    	Location(int xx, int yy)
    	{ 
    		X = xx;
    		Y = yy;
    		cout << "调用构造函数\n" << endl;
    	}
    	//复制构造函数 完成一个对象初始化另外一个对象
    	Location(const Location& obj)
    	{ 
    		X = obj.X;
    		Y = obj.Y;
    		cout << "调用复制构造函数\n" << endl;
    	}
    
    	~Location()
    	{ 
    		cout << "X:" << X << endl
    			<< "Y:" << Y << endl;
    		cout << "调用析构函数\n" << endl;
    	}
    
    	int getX()
    	{ 
    		return X;
    	}
    	int getY()
    	{ 
    		return Y;
    	}
    };
    
    //业务函数 , 形参p是一个元素
    void fun(Location p)
    { 
    	
    	cout << "业务函数的 X:" << p.getX() << endl;
    
    }
    
    int main()
    { 
    	Location L(1, 2);
    	Location L1 = L;//L对象初始化L1对象，调用复制构造函数
    	fun(L);//③去实参L的值去初始化形参p,会调用复制函数
    
    
    	return 0;
    }

#### 4 ####

**匿名对象的去和留**

> 如果使用匿名对象 初始化 同类型的另外一个对象，匿名对象转成有名对象 ，匿名对象不会被析构掉  
> 如果使用匿名对象 ‘=’ 赋值 同类型的另外一个对象，匿名对象就会被析构掉

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70]

#include<iostream>
    using namespace std;
    
    class Location
    { 
    private:
    	int X, Y;
    public:
    	Location(int xx, int yy)
    	{ 
    		X = xx;
    		Y = yy;
    		cout << "调用构造函数" << endl;
    	}
    	Location(const Location& obj)
    	{ 
    		X = obj.X;
    		Y = obj.Y;
    		cout << "调用拷贝构造函数" << endl;
    	}
    	~Location()
    	{ 
    		cout << "调用析构函数" << endl;
    	}
    
    	int getX()
    	{ 
    		return X;
    	}
    
    };
    
    //返回一个匿名对象
    Location g()
    { 
    	Location L2(2, 3);
    	return L2;
    }
    void fun(Location L3)
    { 
    	cout << "调用业务函数" << endl;
    	cout << "X:" << L3.getX()<< endl;
    }
    int main()
    { 
    	Location L(1, 2);
    	Location L1 = L;
    	fun(L);
    
    	Location L3 = g();//用匿名对象初始化L3；把匿名对象转成有名对象L3
    	cout << "匿名对象扶正，不会被析构掉\n" << endl;
    	cout << L3.getX() << endl;
    
    	Location L4(1, 2);
    	L4 = g();
    	cout << "使用=赋值给L4，此时会被析构掉\n" << endl;
    	cout << L4.getX() << endl;
    
    
    	return 0;
    }

### 5. 构造函数调用规则 ###

1.  当类中没有定义任何一个构造函数时，c++编译器会提供默认无参构造函数和默认拷贝构造函数
2.  当类中定义了拷贝构造函数时，c++编译器不会提供无参数构造函数
3.  当类中定义了任意的非拷贝构造函数（即：当类中提供了有参构造函数或无参构造函数），c++编译器不会提供默认无参构造函数
4.  默认拷贝构造函数成员变量简单赋值  
    总结：只要你写了构造函数，那么你必须用。

### 6. 浅层拷贝 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 1]

### 7. 构造函数的参数列表 ###

#### 7.1构造函数初始化列表问题的解决 ####

1.  构造函数初始化列表的解决；因为在B种中组合了一个A类的对象，并且A类的构造函数带有参数
2.  根据构造函数调用规则，A类设计了有参数的构造函数，就必须要用的到，这里没有机会初始化A
3.  新的语法： Constructor::Constructor():m1(v1),m2(v1,v2),m3(v3)\{\}

#include<iostream>
    using namespace std;
    
    class A
    { 
    private:
    	int m_a;
    
    public:
    	A(int a)
    	{ 
    		m_a = a;
    		
    		cout << "m_a的构造函数:" << m_a << endl;
    
    	}
    	~A()
    	{ 
    		cout << "m_a的析构函数:" << m_a << endl;
    
    	}
    };
    
    class B
    { 
    private:
    	int m_b1;
    	int m_b2;
    	//B里面组合了A
    	//定义B的时候需要初始化A类，A类必须提供一个有参数的构造函数
    	A m_a1;
    	A m_a2;
    public:
    	
    	//构造函数初始化列表的解决；因为在B种中组合了一个A类的对象，并且A类的构造函数带有参数
    	//根据构造函数调用规则，A类设计了有参数的构造函数，就必须要用的到，这里没有机会初始化A
    	//新的语法： Constructor::Constructor():m1(v1),m2(v1,v2),m3(v3){}
    	B(int b1, int b2, int m, int n):m_a1(m),m_a2(n)
    	{ 
    		m_b1 = b1;
    		m_b2 = b2;
    		cout << "m_b1的构造函数:" << m_b1 << endl
    			<< "m_b2的构造函数:" << m_b2 << endl;
    	}
    	~B()
    	{ 
    		cout << "m_b1的析构函数:" << m_b1 << endl
    			<< "m_b2的析构函数:" << m_b2 << endl;
    	}
    
    };
    int main()
    { 
    	//参数传递
    	//如果有组合其他类的对象，先执行其他类的构造函数
    	//如果组合对象有多个，按定义顺序，不是按照初始化列表的顺序
    	B b(1,2,3,4);
    	return 0;
    }

#### 7.2 构造函数个析构函数的调用顺序： ####

1.  如果有组合其他类的对象，先执行其他类的构造函数
2.  如果组合对象有多个，按定义顺序，与初始化列表的顺序
3.  析构函数和构造函数的调用顺序相反  
    ![在这里插入图片描述][2019112514055288.png]

### 8. new 和 delete ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 3]

#### 8.1 new 分配 基础数据类型、数组、类的对象 ####

#include<iostream>
    using namespace std;
    
    class Test
    { 
    private:
    	int m_a;
    public:
    	Test(int a)
    	{ 
    		m_a = a;
    		cout << "调用构造函数" << endl;
    	}
    	~Test()
    	{ 
    		cout << "调用析构函数" << endl;
    	}
    };
    int main()
    { 
    	//1. 分配基础类型
    	int* p0 = (int*)malloc(sizeof(int));//C语言表示方法
    	*p0 = 5;
    
    	int* p1 = new int;
    	*p1 = 10;
    
    	int* p2 = new int(20);
    
    	cout << "*p0: " << *p0 << endl;
    	cout << "*p1: " << *p1 << endl;
    	cout << "*p2: " << *p2 << endl;
    	free(p0);
    	delete p1;
    	delete p2;
    
    	//2. 分配数组类型
    	int* p3 = (int*)malloc(sizeof(int) * 10);//C语言表示方法
    	p3[0] = 1;
    
    	int* p4 = new int[10];
    	p4[1] = 2;
    	free(p3);
    	delete[]p4;//数组要加一个中括号
    
    	//3. 动态分配对象
    	//new delete 和malloc free不同的地方
    	//new 能执行类的构造函数， delete 能执行类的析构函数
    	Test* pT1 = (Test*)malloc(sizeof(Test));//C语言表示方法
    	
    	Test* pT2 = new Test(10);
    	free(pT1);
    	delete pT2;
    	return 0;
    }

> malloc 和 free 是C语言的函数  
> new 和delete 是C++的操作符  
> new 能执行类的构造函数， delete 能执行类的析构函数  
> C语言不是面对对象的，不能调用类里面的函数

用 malloc 分配的内存用delete可以释放嘛  
用 new 分配的内存用 free可以释放嘛

### 9. static ###

#### 9.1 静态成员变量 ####

1.  关键字 **static** 可以用于说明一个类的成员，静态成员提供了一个同类对象的共享机制
2.  把一个类的成员说明为 static 时，这个类无论有多少个对象被创建，这些对象共享这个 static 成员
3.  静态成员局部于类，它不是对象成员

#### 9.2 静态成员变量 ####

> 疑难问题：静态成员函数中，不能使用普通变量。  
> 静态成员变量属于整个类的，是每个对象都具有的属性  
> 分不清楚普通变量是哪个具体对象的属性。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 4]

#include<iostream>
    using namespace std;
    
    class Test
    { 
    private:
    	int a = 0;
    	static int c;//声明static静态变量成员 
    public:
    	void printC()
    	{ 
    		cout << "c:" << c << endl;
    	}
    	void addC() 
    	{ 
    		c += 1;
    		cout << "addC:" << c << endl;
    	}
    	static void getC()//静态成员函数
    	{ 
    		//cout << "a:" << a << endl;//在静态函数中不能调用普通成员变量
    		cout << "c:" << c << endl;
    	}
    };
    int Test::c = 10;//定义静态变量成员
    int main()
    { 
    	Test b1, b2, b3;
    	//static修饰的变量属于类。所有的对象都能使用
        //b1，b2, b3可以操作的是同一个函数
    	b1.printC();
    	b2.addC();
    	b3.printC();
    
    	//静态成员函数的调用
    	b3.getC();//1. 对象调用
    	Test::getC();//2. 类调用
    
    	return 0;
    }

![在这里插入图片描述][20191127130524684.png]

[20191121145432757.png]: https://img-blog.csdnimg.cn/20191121145432757.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2019112213042284.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191122144910469.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA==,size_16,color_FFFFFF,t_70
[2019112514055288.png]: https://img-blog.csdnimg.cn/2019112514055288.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191125155334146.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2019112613330158.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191127111849761.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjIzNTE5OA==,size_16,color_FFFFFF,t_70
[20191127130524684.png]: https://img-blog.csdnimg.cn/20191127130524684.png