C++中类的默认成员函数详解

目录

• 一、构造函数
• 二、析构函数
• 三、拷贝构造函数
• 四、赋值函数(赋值运算符重载)
• 总结

c++中，对于任意一个类，都会为我们提供4个默认的成员函数(如果我们不显示的去声明)——构造函数、析构函数、拷贝构造函数、赋值函数。这些函数在特定的情况下会被自动调用，但自动调用并不意味着它们能像用户所期望的那样能实现特定的功能或者完成特定的任务，更多的时候需要我们自己实现这些函数的功能

a();                         //默认的构造函数
~a();                        //析构函数
a(const a&);                 //默认的拷贝函数
a& operator = (const a& a);  //默认赋值函数

一、构造函数

构造函数是一个特殊的成员函数，名字与类名相同,通过类创建对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。构造函数的功能是由类的实现者实现，根据实际情况设计函数体和函数参数，构造函数必须有一个，或者可以有多个。

class person
{
public:
   //无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
   //注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
   person(string name = "冯同学", int age = 18)
   {
     _name = name;
     _age = age;
   }
   //打印信息
   void print() const
   {
     cout << "姓名:" << _name << "——年龄:" << _age << endl;
   }
   
private:
  string _name;
  int _age;
};

int main()
{
	person a;//调用全缺省的构造函数
	person b("风同学");//调用半缺省的构造函数
	person c("疯同学",20);
	a.print();
	b.print();
	c.print();
}

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

class person
{
public:
	void print() const
	{
		cout << "姓名:" << _name << "——年龄:" << _age << endl;
	}
private:
	string _name;
	int _age;
};

int main()
{
	person a;
	a.print();
}

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

class b
{
public:
	b(int b)
	{
		_b = b;
	}
private:
	int _b = 0;
};

class a
{
private:
	int _a;
	b bb;
};
int main()
{
	a aa;
	return 0;
}

在a类中，用b类创建了一个bb对象，bb对象就会调用构造函数，因为是自定义的构造函数，编译器就不会给出默认的构造函数，所以就会报错。如果将b的构造函数改为无参的构造函数和全缺省的构造函数，那么程序就对了，这样也就证明了自定类型成员会调用的它的默认成员函数

构造函数的特点

函数名与类名相同。无返回值。对象实例化时编译器自动调用对应的构造函数。构造函数可以重载。在定义类时，如果没有定义构造函数，则c++编译器会自动提供一个默认构造函数(没有参数)，一旦我们定义构造函数，c++编译器就不会提供默认构造函数无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。并且默认构造函数只能有一个(如果默认构造函数出现多个，在创建对象调用构造函数时，可能会出现二义性)

二、析构函数

与构造函数相反的是析构函数，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作，例如在构造函数中，我们为成员变量申请了内存，我们就可以在析构函数中将申请的内存释放

class person
{
public:
	person(string name = "冯同学", int age = 18)
	{
		_name = name;
		_age = age;
	}

	void print() const
	{
		cout << "姓名:" << _name << "——年龄:" << _age << endl;
	}
	
	~person()
	{
		cout << _name << "正在调用~person()" << endl;
	}

private:
	string _name;
	int _age;
};

int main()
{
	person a;
	person b("风同学");
	person c("疯同学", 20);
	a.print();
	b.print();
	c.print();
}

关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对会自定类型成员调用它的析构函数。

class b
{
public:
	b(int b = 0)
	{
		_b = b;
	}

	~b()
	{
		cout << "正在调用~b()" << endl;
	}

private:
	int _b = 0;
};

class a
{

private:
	int _a;
	b bb;
};

int main()
{
	a aa;
	return 0;
}

析构函数的特点

析构函数名是在类名前加上字符 ~。无参数无返回值。一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。对象生命周期结束时，c++编译系统系统自动调用析构函数。

三、拷贝构造函数

拷贝构造函数是一个特殊的构造函数(构造函数的重载形式)。用基于同一类的已经存在的一个对象拷贝初始化另一个马上创建的对象。

class person
{
public:
	person(string name = "冯同学", int age = 18)
	{
		_name = name;
		_age = age;
	}

	void print() const
	{
		cout << "姓名:" << _name << "——年龄:" << _age << endl;
	}
	
	person(const person& p)
	{
		_name = p._name;
		_age = p._age;
	}
	
private:
	string _name;
	int _age;
};

int main()
{
	person f("风同学", 20);
	person l(f);
	f.print();
	l.print();
}

如果没有定义拷贝构造函数，c++编译器也会提供一个默认的拷贝构造函数，不过该函数实现的是一个浅拷贝功能(将拷贝源按字节序赋值给拷贝对象)。浅拷贝对内置类型基本存在什么影响，但对于在堆上开辟的对象会存在安全隐患，来看看一下程序

class person
{
public:
	person(int age = 18)
	{
		_name = new string("冯同学");
		_age = age;
	}

	~person()
	{
		cout << "正在调用~person()——" << _name << endl;
		delete _name;
		_name = nullptr;
	}
	
private:
	string* _name;
	int _age;
};

int main()
{
	person f(20);
	person l(f);
}

通过打印的结果我们可以发现用对象 f 去拷贝构造对象 l 时,f 中的_name和 l 中的_name指向同一块内存空间(010c5440)，并且在调用析构函数时，对同一块内存空间进行了两次释放，最终导致了程序崩溃，这就是浅拷贝带来的程序安全隐患。
不过我们可以将浅拷贝转换为深拷贝从而解决问题

//自己实现拷贝构造函数
person(const person& p)
	{
		_name = new string;
		*_name = *p._name;
		_age = p._age;
	}

先申请内存，在进行赋值就很好解决了浅拷贝问题

拷贝构造函数的特点

拷贝构造函数是构造函数的一个重载形式。拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

四、赋值函数(赋值运算符重载)

赋值函数和拷贝构造函数有点类似，不过赋值函数只是把一个已存在的对象赋值给另一个已存在的对象，使得那个已存在的对象具有和原对象相同的状态。

class person
{
public:
	person(string name = "冯同学", int age = 18)
	{
		_name = name;
		_age = age;
	}

	person& operator=(const person& p)
	{
		_name = p._name;
		_age = p._age;
	}
	
	void print() const
	{
		cout << "姓名:" << _name << "——年龄:" << _age << endl;
	}
	
private:
	string _name;
	int _age;
};

int main()
{
	person f("风同学", 21);
	person l("凤同学", 20);
	f = l;
	f.print();
	l.print();
}

赋值函数的特点

使用关键字operator(所有的运算符重载都会使用这个关键字)返回值为类的引用(返回*this)不能改变运算符的优先级/结合性/操作数个数一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

总结

到此这篇关于c++中类的默认成员函数详解的文章就介绍到这了,更多相关c++成员函数内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！