类的默认八种函数
1、类的默认八种函数
在C++中，一个类有八个默认函数：
1、默认构造函数；
2、默认拷贝构造函数；
3、默认析构函数；
4、默认重载赋值运算符函数；
5、默认重载取址运算符函数；
6、默认重载取址运算符const函数；
7、默认移动构造函数（C++11）；
8、默认重载移动赋值操作符函数（C++11）。
只是声明一个空类，不做任何事情的话，编译器会自动为你生成一个默认构造函数、一个默认拷贝构造函数、一个默认重载赋值操作符函数和一个默认析构函数。这些函数只有在第一次被调用时，才会被编译器创建，当然这几个生成的默认函数的实现就是什么都不做。所有这些函数都是inline和public的。
我们不希望对象被显示构造（单列模式）或赋值，可以将对应函数声明为private，或者写一个基类，开放部分默认函数，子类去继承就可以了。C++11新增标识符default和delete,控制这些默认函数是否使用。
- default：被标识的默认函数将使用类的默认行为，如：A() = default;
- delete：被标识的默认函数将禁用，如：A() = delete;
- override：被标识的函数需要强制重写基类虚函数；
- final：被标识的函数禁止重写基类虚函数；
class A
{
public:
// 默认构造函数;
A();
// 默认拷贝构造函数
A(const A&);
// 默认析构函数
~A();
// 默认重载赋值运算符函数
A& operator = (const A&);
// 默认重载取址运算符函数
A* operator & ();
// 默认重载取址运算符const函数
const A* operator & () const;
// 默认移动构造函数
A(A&&);
// 默认重载移动赋值操作符
A& operator = (const A&&);
};
1.1、构造函数
- 1.构造函数作用是对对象进行初始化，
在堆上new一个对象或在栈上定义一个临时对象时，会自动调用对象的构造函数。有初始化列表和构造函数体内赋值两种方式，- 初始化列表在初始化对象时更高效（每个成员在初始化列表中只能出现一次），减少了一次赋值操作，推荐此方法；
- 以下成员变量必须在初始化列表中初始化：常量成员变量、引用类型成员变量、没有缺省构造函数的成员变量（如果构造函数的参数列表中有一个类的对象，并且该对象的类里没有缺省参数的构造函数时，要是不使用初始化列表，参数中会调用无参或者全缺省的构造函数，而那个类中又没有）；
- 2.函数名与类名相同，可以重载，不能为虚函数，不能有返回值，连void也不行；
- 3.如果没有显式定义，编译器会自动生成一个默认的构造函数，默认的构造函什么都不会做；
- 4.无参构造函数和带有缺省值的构造函数（全缺省）都认为是缺省的构造函数，并且缺省的构造函数只能有一个；
- 5.函数体内可以使用this指针，但不可以用于初始化列表。
- 因为构造函数只是初始化对象，初始化之前此对象已经存在了，所以可以有this，函数体里面是进行赋值，
- 初始化列表是对类中的各个成员变量进行初始化，初始化的位置对象不完整，所以不能使用this用于初始化列表；
- 6.对于出现单参数的构造函数需要注意，C++会默认将参数对应的类型转换为该类类型，有时候这种
隐式的转换是我们不想要的，需要使用explicit关键字来限制这种转换； - 7.构造顺序：
- 虚拟基类的构造函数（如果有多个虚拟基类，按照它们被继承的顺序构造，而不是它们在成员初始化列表中的顺序）；
- 非虚拟基类的构造函函（如果有多个非虚拟基类，按照它们被继承的顺序构造，而不是它们在成员初始化列表中的顺序）；
- 成员对象的构造函数（如果有多个成员类对象，按照它们声明的顺序调用，而不是它们在成员初始化列表中的顺序）；
- 本类构造函数。构造的过程是递归的。
1.2、拷贝构造函数（Copy Constructor）
- 1.拷贝构造函数实际上是构造函数的重载，具有一般构造函数的所有特性，用此类已有的对象创建一个新的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中。用类的一个已知的对象去初始化该类的另一个对象时，会自动调用对象的拷贝构造函数；
- 2.函数名与类名相同，第一个参数是对某个同类对象的引用，且没有其他参数或其他参数都有默认值，返回值是类对象的引用，通过返回引用值可以实现连续构造，即类似A(B©)这样；
- 3.如果没有显式定义，编译器会自动生成一个默认的拷贝构造函数，默认的拷贝构造函数会依次拷贝类的数据成员完成初始化；
- 4.浅拷贝和深拷贝：编译器创建的默认拷贝构造函数只会执行"浅拷贝"，也就是通过赋值完成，如果该类的数据成员中有指针成员，也只是地址的拷贝，会使得新的对象与拷贝对象该指针成员指向的地址相同，delete该指针时则会导致两次重复delete而出错，如果指针成员是new出来就是“深拷贝”。
1.3、析构函数（Destructor）
- 1.析构函数作用是做一些清理工作，delete一个对象或对象生命周期结束时，会自动调用对象的析构函数；
- 2.函数名在类名前加上字符~，没有参数（可以有void类型的参数），也没有返回值，可以为虚函数（通过基类的指针去析构子类对象时候），不能重载，故析构函数只有一个；
- 3.如果没有显式定义，编译器会自动生成一个默认的析构函数，默认的析构函什么都不会做；
- 4.析构顺序：和构造函数顺序相反。析构的过程也是递归的。
1.4、重载赋值运算符函数（Copy Assignment operator）
- 1.它是两个已有对象，一个给另一个赋值的过程。当两个对象之间进行赋值时，会自动调用重载赋值运算符函数，它不同于拷贝构造函数，拷贝构造函数是用已有对象给新生成的对象赋初值的过程；
- 2.赋值运算符重载函数参数中const和&没有强制要求，返回值是类对象的引用，通过返回引用值可以实现连续赋值，即类似a=b=c这样，返回值类型也不是强制的，可以返回void，使用时就不能连续赋值；
- 3.赋值运算符重载函只能定义为类的成员函数，不能是静态成员函数，也不能是友元函数，赋值运算符重载函数不能被继承，要避免自赋值；
- 4.如果没有显式定义，编译器会自动生成一个默认的赋值运算符重载函数，默认的赋值运算符重载函数实现将数据成员逐一赋值的一种浅拷贝，会导致指针悬挂问题。
1.5、重载取址运算符（const）函数
- 1.重载取址运算符函数没有参数；
- 2.如果没有显式定义，编译器会自动生成默认的重载取址运算符函数，函数内部直接return this，一般使用默认即可。
1.6、移动构造函数和重载移动赋值操作符函数
- 1.C++11 新增move语义：源对象资源的控制权全部交给目标对象，可以将原对象移动到新对象， 用于a初始化b后，就将a析构的情况；
- 2.移动构造函数的参数和拷贝构造函数不同，拷贝构造函数的参数是一个左值引用，但是移动构造函数的初值是一个右值引用；
- 3.临时对象即将消亡，并且它里面的资源是需要被再利用的，这个时候就可以使用移动构造。移动构造可以减少不必要的复制，带来性能上的提升。
2、类的默认函数应用实例
#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string>
class MyClass
{
public:
MyClass(const char * str = nullptr); // 默认带参构造函数 // 默认构造函数指不带参数或者所有参数都有缺省值的构造函数
~MyClass(void); // 默认析构函数
MyClass(const MyClass &); // 默认拷贝构造函数
MyClass & operator =(const MyClass &); // 默认重载赋值运算符函数
MyClass * operator &(); // 默认重载取址运算符函数
MyClass const * operator &() const; // 默认重载取址运算符const函数
MyClass(MyClass &&); // 默认移动构造函数
MyClass & operator =(MyClass &&); // 默认重载移动赋值操作符函数
private:
char *m_pData;
};
// 默认带参构造函数
MyClass::MyClass(const char * str)
{
if (!str)
{
m_pData = nullptr;
}
else
{
this->m_pData = new char[strlen(str) + 1];
strcpy(this->m_pData, str);
}
std::cout << "默认带参构造函数" << " this addr: " << this << std::endl;
}
// 默认析构函数
MyClass::~MyClass(void)
{
if (this->m_pData)
{
delete[] this->m_pData;
this->m_pData = nullptr;
}
std::cout << "默认析构函数" << " this addr: " << this << std::endl;
}
// 默认拷贝构造函数
MyClass::MyClass(const MyClass &m)
{
if (!m.m_pData)
{
this->m_pData = nullptr;
}
else
{
this->m_pData = new char[strlen(m.m_pData) + 1];
strcpy(this->m_pData, m.m_pData);
}
std::cout << "默认拷贝构造函数" << " this addr: " << this << std::endl;
}
// 默认重载赋值运算符函数
MyClass & MyClass::operator =(const MyClass &m)
{
if ( this == &m ) {
return *this;
}
delete[] this->m_pData;
if (!m.m_pData)
{
this->m_pData = nullptr;
}
else
{
this->m_pData = new char[strlen(m.m_pData) + 1];
strcpy(this->m_pData, m.m_pData);
}
std::cout << "默认重载赋值运算符函数" << " this addr: " << this << std::endl;
return *this;
}
// 默认重载取址运算符函数
MyClass * MyClass::operator &()
{
std::cout << "默认重载取址运算符函数" << " this addr: " << this << std::endl;
return this;
}
// 默认重载取址运算符const函数
MyClass const * MyClass::operator &() const
{
std::cout << "默认重载取址运算符const函数" << " this addr: " << this << std::endl;
return this;
}
// 默认移动构造函数
MyClass::MyClass(MyClass && m):
m_pData(std::move(m.m_pData))
{
std::cout << "默认移动构造函数" << std::endl;
m.m_pData = nullptr;
}
// 默认重载移动赋值操作符函数
MyClass & MyClass::operator =(MyClass && m)
{
if ( this == &m ) {
return *this;
}
this->m_pData = nullptr;
this->m_pData = std::move(m.m_pData);
m.m_pData = nullptr;
std::cout << "默认重载移动赋值操作符函数" << " this addr: " << this << std::endl;
return *this;
}
void funA(MyClass a)
{
std::cout << "调用funA函数" << " param addr: " << &a << std::endl;
}
void mytest1(void)
{
std::cout << "mytest1 >>>>" << std::endl;
MyClass myclass1; // 等价于 MyClass myclass1 = MyClass(); // 调用默认带参构造函数
myclass1 = MyClass(); // MyClass()为右值，需要右值引用 // 先调用默认带参构造函数，然后调用默认重载取址运算符函数，最后调用默认重载移动赋值操作符函数
std::cout << "<<<<< mytest1" << std::endl;
// 析构两次 1: myclass1 = MyClass()中的MyClass() 2: MyClass myclass1
}
void mytest2(void)
{
std::cout << "mytest2 >>>>" << std::endl;
MyClass myclass1; // 等价于 MyClass myclass1 = MyClass(); // 调用默认带参构造函数
MyClass myclass2(myclass1); // 调用默认拷贝构造函数
myclass2 = myclass1; // myclass2为左值，所以此操作为赋值操作，会调用默认重载取址运算符const函数，然后调用默认重载赋值运算符函数
funA(myclass1); // 参数传值会导致赋值操作，会调用默认拷贝构造函数，然后funA函数调用默认重载取址运算符函数取得参数
funA(std::move(myclass1)); // funA函数的参数现为右值，会调用默认移动构造函数，然后funA函数调用默认重载取址运算符函数取得参数
// 在移动构造函数中对于基本类型所谓移动只是把其值拷贝，对于如string这类类成员来说才会真正的所谓资源移动
std::cout << "<<<<< mytest2" << std::endl;
}
void mytest3(void)
{
std::cout << "mytest3 >>>>" << std::endl;
funA(MyClass()); // 会调用默认带参构造函数，生成该类的对象，然后funA函数调用默认重载取址运算符函数取得参数
std::cout << "<<<<< mytest3" << std::endl;
// 析构一次 1: funA(MyClass())中的MyClass()形成的对象，是在funA函数结束调用的时候，调用默认析构函数
}
void mytest(void)
{
std::cout << "<<<<<<<<<<<<<<<<<<<<<<<<<" << std::endl;
mytest1();
mytest2();
mytest3();
std::cout << "<<<<<<<<<<<<<<<<<<<<<<<<<" << std::endl;
}
int main(int argc, char * argv[], char * envp[])
{
mytest();
system("pause");
return 0;
}
输出结果：
<<<<<<<<<<<<<<<<<<<<<<<<<
mytest1 >>>>
默认带参构造函数 this addr: 0x7ffca6b2eed8
默认带参构造函数 this addr: 0x7ffca6b2eed0
默认重载取址运算符函数 this addr: 0x7ffca6b2eed0
默认重载移动赋值操作符函数 this addr: 0x7ffca6b2eed8
默认析构函数 this addr: 0x7ffca6b2eed0
<<<<< mytest1
默认析构函数 this addr: 0x7ffca6b2eed8
mytest2 >>>>
默认带参构造函数 this addr: 0x7ffca6b2eed8
默认拷贝构造函数 this addr: 0x7ffca6b2eed0
默认重载取址运算符const函数 this addr: 0x7ffca6b2eed8
默认重载赋值运算符函数 this addr: 0x7ffca6b2eed0
默认拷贝构造函数 this addr: 0x7ffca6b2eeb8
调用funA函数 param addr: 默认重载取址运算符函数 this addr: 0x7ffca6b2eeb8
0x7ffca6b2eeb8
默认析构函数 this addr: 0x7ffca6b2eeb8
默认移动构造函数
调用funA函数 param addr: 默认重载取址运算符函数 this addr: 0x7ffca6b2eeb0
0x7ffca6b2eeb0
默认析构函数 this addr: 0x7ffca6b2eeb0
<<<<< mytest2
默认析构函数 this addr: 0x7ffca6b2eed0
默认析构函数 this addr: 0x7ffca6b2eed8
mytest3 >>>>
默认带参构造函数 this addr: 0x7ffca6b2eed8
调用funA函数 param addr: 默认重载取址运算符函数 this addr: 0x7ffca6b2eed8
0x7ffca6b2eed8
默认析构函数 this addr: 0x7ffca6b2eed8
<<<<< mytest3
<<<<<<<<<<<<<<<<<<<<<<<<<
参考
1、https://www.cnblogs.com/lsgxeva/p/7668200.html
2、https://www.cnblogs.com/yuwanxian/p/10924835.html
扫一扫
483
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
