本文详细介绍了C++中的6个默认成员函数，包括构造函数（无参/有参，重载），析构函数（自动调用），拷贝构造函数（浅拷贝），以及赋值重载函数（特别是赋值运算符重载）。讨论了它们的特性、使用示例和注意事项。
在C++中，有6个默认的成员函数，这六个默认成员函数是不管你写不写，编译器都会自动生成的。这6大默认生成的成员函数能够帮助我们实现一些基本操作。
具体的6大默认成员函数构成如下：
其中，最后两种默认成员函数实现的很少，故本篇博客不过多介绍。
1. 构造函数
我们先来介绍一下构造函数。构造函数是特殊的成员函数，虽然构造函数的名字叫构造，但是实际上他的主要任务并不是开空间创建一个对象，而是初始化对象。
1.2 构造函数的特性
- 函数名和类名相同
- 无返回值
- 对象实例化的时候会自动调用构造函数
- 构造函数可以重载
- 如果没写编译器会自动生成
- 对于自定义类型的对象，构造函数初始化的时候会去调用自定义类型的构造函数
- 默认构造的构造函数只有一个如果写了编译器将不再生成
具体演示示例如下：
#include <iostream>
using namespace std;
class Date
{
public:
//无参构造函数
Date()
{
cout << "Date()" << endl;
}
//有参构造函数
Date(int year, int month, int day)
{
cout << "Date(int year, int month, int day)" << endl;
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2(2024,3,18);
return 0;
}
上面就是一个简单的日期类的构造函数的实现。
运行结果如下：
以上的代码只是让我们了解到了前四种特性。第五种特性我们应该如何证明呢？
具体示例如下：
#include <iostream>
using namespace std;
class Date
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
d1.Print();
return 0;
}
运行结果如下：
我们发现，就算我们没有写构造函数去初始化对象，但是编译器还是给我们生成了一个默认构造函数，不过编译器生成的这个默认生成的构造函数并没有对我们的对象进行初始化操作。
接下来是第6种特性的证明：
#include <iostream>
using namespace std;
class A
{
public:
A()
{
cout << "A()" << endl;
aa = 0;
}
private:
int aa;
};
class Date
{
public:
Date()
{
cout << "Date()" << endl;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
A aa;
};
int main()
{
Date d1;
return 0;
}
运行结果如下：
这就是第6种特性的验证方法。接下来我们来验证一下第7种特性：
#include <iostream>
using namespace std;
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
return 0;
}
我们发现，编译器直接给我们报了一个错误叫做Date类不存在默认构造函数。可是我们明明已经写了一个构造函数啊，编译器为什么还报错？这是怎么回事呢？其实，这是因为我们写的构造函数和我们初始化对象的时候的构造函数不匹配。我们写的这个构造函数是有参的构造，但是我们实际上初始化对象的时候需要的构造函数是一个无参的构造。那么我们应该如何解决这个问题呢？
这个问题有三种解决方案。
第一种方法是我们可以再写一个无参的构造函数构成函数重载。
第二种方法是我们将我们实例化的时候的对象改成有参的。
第三种方法也是我们最推荐的写法就是写一个缺省参数。具体示例如下：
#include <iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
d1.Print();
return 0;
}
运行结果如下：
以上就是我们对构造函数的7种特性的介绍。
其实，构造函数中还有一种特殊的语法。这个语法叫做初始化列表。
1.3 初始化列表
这个初始化列表是为了解决构造函数中不好解决的一个问题而新创建的一个语法。
那么构造函数中有哪些问题是无法解决的呢？
- 不使用初始化列表的构造函数无法初始化引用成员变量
- 不使用初始化列表的构造函数无法初始化const成员变量
- 不使用初始化列表的构造函数无法初始化自定义类型成员（且该类没有默认构造函数时）
具体示例如下：
#include <iostream>
using namespace std;
class A
{
public:
A(int a)
: _a(a)
{}
private:
int _a;
};
class B
{
public:
B(int a, int ref, int n)
{
_a = a;
_ref = ref;
_n = n;
}
private:
A _a;
int& _ref;
const int _n;
};
int main()
{
B b(10, 20, 30);
return 0;
}
我们发现，如果不使用初始化列表的话，编译器会给我们报两个错误。但是实际上，这里有三个错误，还有一个错误是ref造成了野引用，只是编译器没有检查出来而已。这三个错误也很好理解
- 类A必须调用自己的默认构造函数才可以进行初始化操作，但是我们在函数内部只能用赋值操作。
- ref是一个引用，我们必须让它指向一个我们已经开辟好的空间。
- const修饰的成员变量是不可以修改的，但是我们在构造函数内部要对const修饰的成员变量只能使用赋值操作，但是这样子就造成了我们的const修饰的成员变量被修改了。
由于这些原因，C++中提供了一种初始化列表的语法来规避这些报错。
1.3.1初始化列表的语法
初始化列表的语法比较简单，先写出构造函数名，再在下一行以冒号开头，初始化语句由之前的赋值运算符变成小括号，一条初始化语句和另一条初始化语句之间以逗号隔开，最后在初始化列表的最后加上一个括号就行了。
具体示例如下：
#include <iostream>
using namespace std;
class A
{
public:
A(int a)
: _a(a)
{}
private:
int _a;
};
class B
{
public:
B(int a, int& ref, int n)
: _a(a)
, _ref(ref)
, _n(n)
{}
private:
A _a;
int& _ref;
const int _n;
};
int main()
{
int a = 0;
B b(10, a, 30);
return 0;
}
这个时候我们的编译器就不会继续报错了。
（Tips：构造函数会优先初始化初始化列表中的对象，如果都在初始化列表，则会按照对象的创建时间来选择哪个对象优先初始化）
以上就是对于构造函数的全部介绍。
2. 析构函数
接下来我们来介绍一下类和对象中的析构函数，析构函数其实就算和构造函数相类似的一个函数。但是他们的主要作用是相反的，构造函数的主要作用是初始化对象，但是析构函数的主要作用是销毁对象。类似于我们之前在数据结构当中学习到的destroy函数。
2.1 析构函数的特性
析构函数有以下特性：
- 析构函数名是在类名前加上字符~
- 无参数无返回值类型
- 一个类只能有一个析构函数，若未显式定义，系统会自动默认生成的析构函数
- 对象生命周期结束时，C++编译系统会自动调用析构函数
- 析构函数不能函数重载
- 编译器自动生成的析构函数对于内置类型不会进行任何操作，但是对于自定义类型的对象回去调用它的析构函数
- 如果类中没有申请资源的时候，析构函数可以不写，直接使用系统默认生成的析构函数，但是有资源申请的时候析构函数必须写，不然会造成资源泄漏
具体示例如下：
#include <iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
~Date()
{
_year = 1;
_month = 1;
_day = 1;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
return 0;
}
上面就是一个日期类的析构函数，但是由于我们在实现日期类的时候并没有向系统申请资源，所以这个析构函数写不写都行。
以下是第6条特性的证明：
#include <iostream>
using namespace std;
class A
{
public:
A()
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
};
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
~Date()
{
cout << "~Date()" << endl;
_year = 1;
_month = 1;
_day = 1;
}
private:
int _year;
int _month;
int _day;
A _aa;
};
int main()
{
Date d1;
return 0;
}
（Tips：析构函数的调用顺序是从main函数的最后一条语句往第一条语句上调用的）
以上就是对类和对象中的析构函数的全部介绍。
3. 拷贝构造函数
接下来，我们来介绍以下类和对象中的拷贝构造函数的相关内容。
3.1 拷贝构造函数的概念
拷贝构造函数是只有单个形参，该形参是对本类类型对象的引用（一般用const修饰），在用已存在的类类型对象创建新对象时由编译器自动调用。
3.2 拷贝构造函数的特征
拷贝构造函数是特殊的成员函数，其特征如下：
- 拷贝构造函数是构造函数的一种重载形式
- 拷贝构造函数的参数只有一个而且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用
- 若未显式定义，编译器会默认生成一个拷贝构造函数，默认生成的拷贝构造函数对象按内存存储按字节序完成拷贝
- 编译器自动生成的拷贝构造函数是浅拷贝，不是深拷贝，部分情况需要自己显示实现
- 拷贝构造函数的调用类型
5.1 使用已存在对象创建新对象
5.2 函数参数类型为类类型对象
5.3 函数返回类型为类类型对象
具体示例如下：
#include <iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
~Date()
{
_year = 1;
_month = 1;
_day = 1;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024,3,18);
Date d2(d1);
d2.Print();
return 0;
}
运行结果如下：
上面是我们显式定义的拷贝构造函数，接下来我们试试看编译器自动生成的拷贝构造会帮我们拷贝什么东西。
具体实例如下：
#include <iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
~Date()
{
_year = 1;
_month = 1;
_day = 1;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024,3,18);
Date d2(d1);
d2.Print();
return 0;
}
运行结果如下：
我们发现，编译器自动生成的拷贝构造帮我们把年月日都拷贝过去了，但是这是不是意味着我们不用写拷贝构造了呢？其实并不是。
请看以下示例：
#include <iostream>
using namespace std;
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 10)
{
_array = (DataType*)malloc(capacity * sizeof(DataType));
if (nullptr == _array)
{
perror("malloc申请空间失败");
return;
}
_size = 0;
_capacity = capacity;
}
void Push(const DataType& data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
~Stack()
{
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
size_t _size;
size_t _capacity;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
s1.Push(3);
s1.Push(4);
Stack s2(s1);
return 0;
}
程序运行结果如下：
我们发现，这个程序居然崩溃了。这是为什么呢？因为编译器自动生成的拷贝构造函数只是一个值拷贝，而且是按着内存存储按字节序完成拷贝的，这也就意味着等到拷贝s2的时候，s2的地址就是s1最后一个元素的地址了，这就导致了s2和s1存在内存冲突的问题，程序就崩溃了。
以上就是对于类和对象中的拷贝构造函数的全部介绍。
4. 赋值重载函数
4.1运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
- 不能通过连接其他符号来创建新的操作符：比如operator@
- 重载操作符必须有一个类类型参数
- 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
- 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐
藏的this - .* :: sizeof ?: . 注意以上5个运算符不能重载
具体使用示例请看 4.2 赋值运算符重载
4.２ 赋值运算符重载
具体示例如下：
#include <iostream>
using namespace std;
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
~Date()
{
_year = 1;
_month = 1;
_day = 1;
}
bool operator==(const Date& d)
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024,3,18);
Date d2(d1);
//d2.Print();
bool tmp = (d1 == d2);
cout << tmp << endl;
return 0;
}
运行结果如下：
以上就是本篇博客的所有内容，感谢大家的观看。
有关日期类的实现已经上传到gitee上了，需要的小伙伴自取日期类的实现
1295
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
