C++入门--构造函数、拷贝构造函数、析构函数

最新推荐文章于 2023-08-06 09:25:50 发布

小太阳....

最新推荐文章于 2023-08-06 09:25:50 发布

阅读量452

点赞数 3

分类专栏： C/C++ 文章标签： c++

本文链接：https://blog.csdn.net/weixin_44627813/article/details/113745144

版权

C/C++ 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

构造函数

构造函数：主要作用在于创建对象时为对象的成员属性赋值，由编译器自动调用，无须手动调用。在对象的生命周期中只调用一次。

特性

特性如下：

■ 1、函数名和类名相同。

■ 2、没有返回值，而且不能有void。

■ 3、有参数，支持重载。

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

class Date{
public:
	//无参构造函数(默认构造函数)
	Date(){
	}
	//有参构造函数
	Date(int year,int month,int day){
		_year=year;
		_month=month;
		_day=day;
	}
	Date(int year){
		_year=year;
	}
private:
	int _year;
	int _month;
	int _date;
}
int main(){
	Date d1;	//调用无参构造函数
	
	//Date d2(2021,2,7);等价于 Date d2=Date(2021,2,7);
	Date d2(2021,2,7);	//调用带参构造函数
	//注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就变成了函数声明
	//请看一下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
	//Date d3();
	
	//对于这样声明，是匿名对象。执行当前行后就会释放这个对象
	//Date(2021,2,8);
	
	Date d4=2021;	//隐式转换 Date d4=Date(2021);
	
}

b为A的实例化对象,A a = A(b) 和 A(b)的区别？
解：当A(b) 有变量来接的时候，那么编译器认为他是一个匿名对象，当没有变量来接的时候，编译器认为你A(b) 等价于 A b.

构造函数调用规则

■ 默认情况下，c++编译器至少为我们写的类增加3个函数

默认构造函数(无参，函数体为空)。
默认析构函数(无参，函数体为空)。
默认拷贝构造函数，对类中非静态成员属性简单值拷贝。

■ 如果用户定义拷贝构造函数，c++不会再提供任何默认构造函数

■ 如果用户定义了普通构造(非拷贝)，c++不在提供默认无参构造，但是会提供默认拷贝构造

问题：

关于编译器生成的默认成员函数，很多小伙伴会有疑惑：当我们不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？当对象调用了编译器生成的默认构造函数，但是对象中的数据，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？

解答：

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员 time 调用的它的默认成员函数。

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}	
	
	//如果我们只提供这个构造函数，那么编译失败，无法初始化完成，因为我们有了有参构造函数将不会给我们提供默认构造函数。
	//Time()=default; 要求编译器生成默认的构造函数
	/*Time(int year,int month,int day){
		_year=year;
		_month=month;
		_day=day;
	}*/
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main(){
	Date d;
	return 0;
}
//运行结果：Time()

在C++11新标准中，如果我们需要默认的行为，那么可以通过在参数列表后面写上 =deault (Time() = default )来要求编译器生成构造函数。

提示：当类对象作为类的成员时候，构造顺序是先构造类对象的构造，然后构造自己，析构顺序与构造相反。析构顺序相反可以想象成栈的先进后出所以顺序相反。

默认构造函数只能有一个

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

// 默认构造函数
class Date
{
public:
	Date()
	{
		_year = 1900 ;
		_month = 1 ;
		_day = 1;
	}
	Date (int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private :
	int _year ;
	int _month ;
	int _day ;
};
// 以下测试函数能通过编译吗？
void Test()
{
	Date d1;
}
//答：不能，因为两个构造函数都是默认构成函数。

析构函数

析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

特性

特性如下：
■ 1、析构函数名是在类名前加上字符 ~。

■ 2、无参数无返回值。

■ 3、一个类有且只有一个析构函数。程序员没有未显式定义析构，系统会默认提供，空实现，且只调用一次。

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

class SeqList
{
public :
	SeqList (int capacity = 10)
	{
		_pData = (int*)malloc(capacity * sizeof(int));
		assert(_pData);
		_size = 0;
		_capacity = capacity;
	}
	~SeqList()
	{
		if (_pData)
		{
			free(_pData); // 释放堆上的空间
			_pData = NULL; // 将指针置为空
			_capacity = 0;
			_size = 0;
		}
	}
private :
	int* _pData ;
	size_t _size;
	size_t _capacity;
};

拷贝构造函数

构造函数：在用已存在的类类型对象创建新对象时由编译器自动调用。

特性

特性如下：

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

■ 2、拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

■ 3、若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

■ 4、对象实例化新对象时编译器自动调用对应的拷贝构造函数。如果不写，编译器默认会自动提供。

对于特性的第二点看图：

在这里插入图片描述

对于特性的第三点解释：

浅拷贝

同一类型的对象之间可以赋值，使得两个对象的成员变量的值相同，两个对象仍然是独立的两个对象，这种情况被称为浅拷贝。一般情况下，浅拷贝没有任何副作用，但是当类中有指针，并且指针指向动态分配的内存空间，析构函数做了动态内存释放的处理，当拷贝对象释放一次内存空间之后，第二次原本的对象又释放了一次内存空间，就会导致错误。

class String
{
public:
	String(const char* str = "jack",int Age)
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
		_Age=Age;
	}
	~String()
	{
		cout << "~String()" << endl;
		free(_str);
		_str=NULL;
	}
private:
	char* _str;
	int _Age;
};
int main()
{
	String s1("hello",19);
	String s2(s1);
}

深拷贝

当类中有指针，并且此指针有动态分配空间，析构函数做了释放处理，往往需要自定义拷贝构造函数，自行给指针动态分配空间，这种叫做深拷贝。

class String
{
public:
	String(const char* str = "jack",int Age)
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
		_Age=Age;
	}
	String(const String& string){
		_str= (char*)malloc(strlen(string._str) + 1);
		strcpy(_str, string._str);
		_Age= string._Age;
	}
	~String()
	{
		if(_str!=NULL){
			free(_str);
			_str=NULL;
		}
	}
private:
	char* _str;
	int _Age;
};
int main()
{
	String s1("hello",19);
	String s2(s1);
}

深浅拷贝图

在这里插入图片描述

拷贝构造函数调用时机

■ 1、用已经创建好的对象来初始化新的对象。

■ 2、对象以值传递的方式给函数参数传值。

■ 3、函数局部对象以值传递的方式从函数返回。

class Person{
public:
	Person(){
		cout << "no param contructor!" << endl;
		mAge = 10;
	}
	Person(int age){
		cout << "param constructor!" << endl;
		mAge = age;
	}
	Person(const Person& person){
		cout << "copy constructor!" << endl;
		mAge = person.mAge;
	}
	~Person(){
		cout << "destructor!" << endl;
	}
public:
	int mAge;
};
//1. 旧对象初始化新对象
void test01(){
	Person p(10);
	Person p1(p);
	Person p2 = Person(p);
	Person p3 = p; // 相当于Person p3 = Person(p);
}

//2. 传递的参数是普通对象，函数参数也是普通对象，传递将会调用拷贝构造
void doBussiness(Person p){}

void test02(){
	Person p(10);
	doBussiness(p);
}

//3. 函数返回局部对象
Person MyBusiness(){
	Person p(10);
	return p;
}
void test03(){
	Person p = MyBusiness();
	cout << "局部p的mAge:" << p.mAge << endl;
}

初始化列表

语法：在构造函数后面 + : 属性(值、参数), 属性（值、参数）…{}

class Date{
public:
	//无参构造函数(默认构造函数)
	Date(){
	}
	//有参构造函数
	/*Date(int year,int month,int day){
		_year=year;
		_month=month;
		_day=day;
	}
	*/
	//初始化列表  和上述的初始化是等价的
	Date(int year,int month,int day):_year(year),_day(day),_month(month){}
	Date(int year){
		_year=year;
	}
private:
	int _year;
	int _month;
	int _date;
}

注意：成员的初始化顺序与他们在类定义中的出现顺序一致。虽然上面定义是 _year ,_day,_month，但是类初始化的顺序是_year , _month , _day。

小太阳....

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
C++入门--构造函数、拷贝构造函数、析构函数

构造函数构造函数：主要作用在于创建对象时为对象的成员属性赋值，由编译器自动调用，无须手动调用。在对象的生命周期中只调用一次。特性特性如下：■ 1、函数名和类名相同。■ 2、没有返回值，而且不能有void。■ 3、有参数，支持重载。■ 4、对象实例化时编译器自动调用对应的构造函数。class Date{public: //无参构造函数 Date(){ } //有参构造函数 Date(int year,int month,int day){ _year=year; _mo
复制链接

扫一扫

专栏目录