C++ 类与对象：解锁面向对象编程的核心密码（中）

系列文章目录

《C/C++》

---

文章目录

• 系列文章目录
• 前言
• 正文
• • 类的默认成员函数
  • • 1.构造函数
    • • 1.1特点
    • 2.析构函数
    • • 2.1特点
    • 3.拷贝构造
    • • 3.1特点
    • 4.赋值运算符重载
    • • 4.1运算符重载
      • 4.2赋值运算符重载
      • • 4.2.1特点
    • 5.取地址运算符的重载
    • • 5.1const成员函数
      • 5.2取地址运算符的重载
  • 总结

---

前言

C++作为一门面向对象的编程语言，面向对象有三大特性：封装，继承，多态，类就可以很好地体现出封装的特点，这篇文章，我将梳理讲解，我学习到的类和对象知识

---

正文

类的默认成员函数

在类中，我们没有显示去写，但是编译器会自动生成的函数，我们称之为默认成员函数 ，⼀个类，我们不写的情况下编译器会默认⽣成以下6个 默认成员函数

我们主要从以下两个点去学习:

• 我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求
• 编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？

1.构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，⽽是对象实例化时初始化对象，它会在对象实例化的时候自动调用

1.1特点

①函数名 与类名 相同

②**⽆返回值** (返回值啥都不需要给，也不需要写void）

③对象实例化时系统会**⾃动调⽤** 对应的构造函数

④构造函数可以重载

⑤如果类中没有显式定义构造函数，则C++编译器会**⾃动⽣成** ⼀个⽆参的默认构造函数，⼀旦用户显式定义编译器将不再⽣成

#include <iostream>
using namespace std;
class Data 
{

public:
	//不传参的默认构造
	Data()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	//传参的默认构造
	Data(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()
{
	//调用无参构造
	Data d1;
	//不能写成：Data d1();会被当成函数声明
	d1.print();
	//传参构造
	Data d2(2025, 2, 3);
	d2.print();
	return 0;
}

可以看到，自动去调用了对应的构造函数

⑥⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函数，这三个函数有且只有⼀个存在 ，总结⼀下就是不传实参就可以调⽤的构造就叫默认构造

⑦我们不写，编译器默认⽣成的构造 ，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器

#include <iostream>
using namespace std;
class Data 
{
public:
	void print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;

};
int main()
{
	Data d1;
	d1.print();
	return 0;
}

可以看到，这次我们让编译器自己生成的构造函数，它默认的初始化就是这样的，看上去和没初始化一样，但实际是初始化过了的

⑧对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数 初始

化，如果这个成员变量，没有默认构造函数，那么就会报错

2.析构函数

析构函数与构造函数功能相反 ,析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对象中资源的清理释放⼯作

2.1特点

看了构造函数之后，析构函数的特点也挺好理解了

①析构函数名是在类名前加上字符 ~

②⽆参数⽆返回值

③⼀个类只能有⼀个析构函数，若未显式定义，系统会⾃动⽣成默认的析构函数

④对象⽣命周期结束时，系统会⾃动调⽤析构函数

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
class Data 
{
public:
	~Data()
	{
		cout << "data()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;

};
int main()
{
	Data d1;
	return 0;
}

可以看到生命周期结束之后会自动调用~Data

但其实我们的日期类没有向内存动态申请资源，也就没有必要析构

⑤跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理 ，⾃定类型成员会调⽤他的析构函数

⑥我们显示写析构函数，对于**⾃定义类型** 成员也会调⽤ 他的析构，也就是说**⾃定义类型成员⽆论什么情况都会⾃动调⽤析构函数**

⑦如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源申请时，⼀定要⾃⼰写析构 ，否则会造成资源泄漏

⑧⼀个局部域的多个对象，C++规定后定义的先析构

#include <iostream>
using namespace std;
class Data 
{
public:
	~Data()
	{
		cout << "data()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Data d1;
	Data d2;
	return 0;
}

通过this指针可以看到，我们会先析构后定义的d2，再析构先定义的d1

---

3.拷贝构造

如果⼀个构造函数的第⼀个参数是**⾃⾝类类型** 的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数

Data(const Data& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

这就是我们的拷贝构造

有了拷贝构造之后，我们可以用一个类去初始化一个相同的类，如这样：

Data d1(2025, 1, 1);
Data d2(d1);

之所以加上const，是因为我们不需要修改其内容，还可以避免const对象继续拷贝构造时，出现权限放大的情况

const Data d3;
Data d4(d3);

3.1特点

①拷⻉构造函数是构造函数的⼀个重载

②拷⻉构造函数的第⼀个参数必须是当前类类型对象的引⽤，使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发⽆穷递归调⽤,拷⻉构造函数也可以多个参数，但是第⼀个参数 必须是类类型对象的引⽤，后⾯的参数必须有缺省值

为什么要传引用？什么是无穷递归？

我们来看这样一个函数，以日期类为参数的Func函数

可以发现我们在进行传值传参的时候，不是直接传给Func了，而是先调用了拷贝构造，把形参拷贝给给实参，然后再进入函数体

所以如果我们的拷贝构造使用传值传参，就会出现每次传值过来，都会再次调用拷贝构造，无穷递归

③ C++规定**⾃定义类型** 对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成

④ 若未显式定义拷⻉构造，编译器会⽣成***⾃动⽣成拷⻉构造函数*** ，⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造

⑤ 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造;像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉),像MyQueue这样的类型内部主要是 ⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显示实现MyQueue的拷⻉构造

(这⾥还有⼀个⼩技巧，如果⼀个类显示实现了析构并释放资源，那么他就需要显⽰写拷⻉构造，否则就不需要)

⑥传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样,传引⽤返回可以减少拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回

我们的拷贝构造，还可以写成这样：

Data d2 = d1;

我们想象一下我们一些函数，在返回一些值的时候这样写也就可以理解了

---

4.赋值运算符重载

4.1运算符重载

当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义，C++规定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有 对应的运算符重载，则会编译报错

那我们怎么对运算符进行重载呢？

• 运算符重载是具有特殊名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体
• 重载运算符函数的参数个数和该运算符作⽤的运算对象数量**⼀样多** ,⼀元运算符有⼀个参数，⼆元运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数

我们可以按照上述要求，写一个日期类==的重载

bool operator==(Data x1, Data x2)
{
	return x1._year == x2._year
		&& x1._month == x2._month
		&& x1._day == x2._day;
}

重载完之后，我们可以进行d1==d2的比较，它本质上是调用如下函数

operator==(d1, d2);

我们的函数定义在类外，无法访问日期类中私有的成员

这里我们一般有三种解决方法，一种是把这个函数变成类的友元，一种是在类中设置一个获取私有成员的函数，C++一般会采用最后一种，就是把这个函数放到类域中，变成类的成员函数

如果写成成员函数，它的第一个参数就会是一个隐含的this指针，所以我们的重载函数就需要这样写

bool operator==(Data d)
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致

当然这里，为了避免权限问题，和拷贝问题，我们真正应该写成这样

bool operator==(const Data& d)
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

此时我们==比较，本质上也是调用这个函数

	d1.operator==(d2);

还有几个注意的点：

• 不能通过连接语法中没有的符号来创建新的操作符：⽐如
  @ .* :: sizeof ?: . 注意以上5个运算符不能重载

• 重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int operator+(int x, int y)

• ⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，⽐如Date类重载operator-就有意义，但是重载operator*就没有意义

• 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分；C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分

这两者的区别在于返回值不同，前置++返回++之后的值，后置++返回++之前的值

Data& operator++()//前置++
{
	this->_day += 1;
	return *this;
}

Data operator++(int)//后置++
{
	Data tmp(*this);
	this->_day += 1;
	return tmp;
}

这里的前置++,返回的this指针指向的内容，出了函数之后还存在，就可以使用引用返回，而后置++要先拷贝构造一份，然后再+，返回构造的临时变量，不能引用返回

后置++会多两次拷贝，效率有所下降，所以以后尽量使用前置++

• 重载>>和<<
  

我们的<<和>>本质是都是双目运算符，比如我们cout<<1;它的右操作数是我们的内置类型int的1，它的左操作数是cout，cout是ostream类型的

所以我们重载<<就需要写成这样

void operator<<(ostream& out)
{
	out << _year << "/" << _month << "/" << _day << endl;
}

因为内置类型我们的库中已经帮我们重载好了，所以我们直接用就可以

但是这样写还有一个问题，我们进行<<输出类的时候，由于this指针默认占据第一个参数位置，所以我们只能写成这样

d1<<cout;

所以我们只能把<<重载成全局函数

void operator<<(ostream& out,const Data d)
{
	out << d._year << "/" << d._month << "/" << d._day << endl;
}

但是我们需要访问私有成员，这时候就需要进行友元的声明，在类中加入

friend void operator<<(ostream& out,const Data d);//友元声明

这个函数就可以在类外访问类中的私有成员了

为了支持连续的输出，我们的返回值也要是一个ostream类型的

ostream& operator<<(ostream& out,const Data d)
{
	out << d._year << "/" << d._month << "/" << d._day << endl;
	return out;
}

注意我们的友元声明也要改一下

friend ostream& operator<<(ostream& out,const Data d);//友元声明

同理，我们的>>,cin是istream类型的，它的重载我们就可以这样写

istream& operator>>(istream& in, Data d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

同样的也需要进行友元声明

friend istream& operator>>(istream& out, Data d);//友元声明

总结一下：

重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调⽤时就变成了 对象<<cout，不符合使⽤习惯和可读性，重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象

4.2赋值运算符重载

赋值运算符重载是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷⻉赋值，这⾥要注意跟拷⻉构造区分，拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象

Data d1(2025, 8, 1);
Data d2(2025, 10, 1);

Data d3(d1);
Data d4 = d1;

d2 = d1;

d3和d4，都是拷贝构造，最下面一个才是赋值运算符重载

4.2.1特点

①赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成const 当前类类型引⽤，否则会传值传参会有拷⻉

②有返回值，且建议写成当前类类型引⽤，引⽤返回可以提⾼效率，有返回值⽬的是为了⽀持连续赋值场景

Data& operator=(Data d)
{
	_year = d._year;
	 _month = d._month;
	 _day = d._day;
	 return *this;
}

这里返回的this指针指向的值，出了函数之后还在，所以可以使用引用返回

③没有显式实现时，编译器会⾃动⽣成⼀个默认赋值运算符重载，默认赋值运算符重载⾏为跟默认拷⻉构造函数类似，对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的赋值重载函数

④像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的赋值运算符重载就可以完成需要的拷⻉，所以不需要我们显示实现赋值运算符重载；像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的赋值运算符重载完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉对指向的资源也进⾏拷⻉)；像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的赋值运算符重载会调⽤Stack的赋值运算符重载，也不需要我们显示实现MyQueue的赋值运算符重载

(这⾥还有⼀个⼩技巧，如果⼀个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要)

---

5.取地址运算符的重载

5.1const成员函数

• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯

当我们去定义一个const对象的时候，再去调用我们的成员函数

const Data d1(2025, 8, 1);
d1.print();

就会报错，根本原因是，我们在调用成员函数的时候，会把对象传递给this指针，而我们的this指针的类型是Data* const ，但是我们的对象类型确实const Data，这里就涉及到权限的放大了

这时候我们就只能这样定义成员函数

void print()const
{
	cout << _year << "/" << _month << "/" << _day << endl;
}

print隐含的this指针由 Date* const this 变为 constDate* const this

什么时候加上const，我们的总结一下最佳实践

5.2取地址运算符的重载

取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动⽣成的就可以够我们⽤了，不需要去显⽰实现，除⾮⼀些很特殊的场景，⽐如我们不想让别⼈取到当前类对象的地址，就可以⾃⼰实现⼀份，胡乱返回⼀个地址

Date* operator&()
 {
	return this;
 // return nullptr;
 }

 const Date* operator&()const
 {
	return this;
// return nullptr;
}

---

总结

以上就是我们类和对象（中）的内容了，我们对于类中几个比较重要的默认成员函数进行了讲解，如果有什么问题，欢迎评论交流，感谢大家的支持