《C++ 类与对象避坑指南上：默认成员函数 /this 指针常见误区拆解（附日期类小项目）》

用户11862565

发布于 2025-10-13 15:30:13

1600

代码可运行

运行总次数：0

代码可运行

前言

在 C++ 的学习旅程中，“类与对象” 是跨向面向对象编程的第一道门槛，也是理解后续继承、多态等特性的基石。不同于 C 语言的面向过程思想，C++ 通过 “类” 将数据与操作数据的方法封装为一个整体，而 “对象” 则是类的具体实例 —— 这一设计让代码更贴合现实逻辑，也更易维护。但对初学者而言，类域的作用、默认成员函数的 “隐形工作”（比如为什么实例化对象时会自动调用构造函数？析构函数何时需要手动实现？）、this 指针的底层关联等问题，往往容易混淆。本文正是针对这些核心痛点，从类的基础定义出发，逐步拆解对象实例化、关键机制（如 this 指针）、默认成员函数等知识点，最后通过一个可落地的日期类案例，将理论与实践结合，帮助读者从 “知道” 到 “理解”，真正建立面向对象的编程思维

一、类的定义

1.类定义格式

• class为定义类的关键字，Stack为类的名字 （类名就是类型）， { } 中为类的主体，注意类定义结束时后⾯分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的⽅法或者成员函数。

这里sturct从C语言的结构体升级成为类，那么class和struct的区别在于class不加访问限定符修饰的成员变量/成员函数是私有的，struct不加修饰是公有的。

#include<iostream>

class Stack
{
    //在C语言中函数和结构体分离，在C++中变为成员函数
   void Push(int x)
   {
   		......
   }
   void Pop()
   {
	   .......
   }
   int Top()
   {
 	  .......
   }
   
   int*a;
   int top;
   int capacity;
};


int  main()
{
      Stack st;
      //不能访问成员函数，因为成员变量默认为私有
      //st.Pop();
      //st.Push(1);
      
      return 0;
}

• 为了区分成员变量，⼀般习惯上成员变量会加⼀个特殊标识，如成员变量前⾯或者后⾯加_ 或者 m开头，注意C++中这个并不是强制的，只是⼀些惯例，具体看公司的要求。

class Data
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;

	}
private:

	// 为了区分成员变量，⼀般习惯上成员变量 
    // 会加⼀个特殊标识，如_ 或者 m开头 
	int _year; // year_ m_year
	int _month;
	int _day;
};

int main()
{

	Data d;
	d.Init(2025, 8, 1);

	return 0;
}

• C++中struct也可以定义类，C++兼容C中struct的用法，同时struct升级成了类，明显的变化是struct中可以定义函数，⼀般情况下我们还是推荐⽤class定义类。（在C++中还是支持C语言的struct用法）

struct Data
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;

	}
private:

	// 为了区分成员变量，⼀般习惯上成员变量 
    // 会加⼀个特殊标识，如_ 或者 m开头 
	int _year; // year_ m_year
	int _month;
	int _day;
};

• 定义在类⾯的成员函数默认为inline

当成员函数的定义位于类内部时（无论声明和定义是否分离，但都在类域内），该函数默认是内联（inline）的

如果成员函数的声明在类内，但定义在类外（即不在同一个类域中），那么：

此时函数默认不是内联的
若要使其成为内联函数，必须在类外定义时显式添加inline关键字

2.访问限定符

• C++⼀种实现封装的⽅式，⽤类将对象的属性与⽅法结合在⼀块，让对象更加完善，通过访问权限选择性的将其接提供给外部的用户使用

• public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访问，现阶段认为protected和private是⼀样的，以后继承章节才能体现出他们的区别。

• 访问权限作⽤域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为⽌，如果后⾯没有访问限定符，作⽤域就到 } 即类结束。

#include<iostream>
using namespace std;

//注意访问限定符不是只可以出现一次，可以出现多次
class stack
{
	void Push(int x)
	{

	}//没给访问限定符，在class中默认私有
public:
	void Pop()
	{

	}
	int top()
	{

	}
	//从public到下一个访问限定符之前都属于public
private:
	int* a;
	int top;
	int capacity;
};

• class定义成员没有被访问限定符修饰时默认为private，struct默认为public

• ⼀般成员变量都会被限制为private/protected，需要给别人使用的成员函数会放为public

3.类域

• 类定义了⼀个新的作⽤域，类的所有成员都在类的作⽤域中，在类体外定义成员时，需要使⽤：:作⽤域操作符指明成员属于哪个类域。

• 类域影响的是编译的查找规则，下⾯程序中Init如果不指定类域Stack，那么编译器就把Init当成全局函数，那么编译时，找不到array等成员的声明/定义在哪⾥，就会报错。指定类域Stack，就是知道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找

#include<iostream>
using namespace std;
class Stack
{
public:

 	// 成员函数 
 	void Init(int n = 4);
 	
private:
	 // 成员变量 
	 int* array;
	 size_t capacity;
 	size_t top;
};

	// 声明和定义分离，需要指定类域 
	void Stack::Init(int n)
{
	 array = (int*)malloc(sizeof(int) * n);
 	if (nullptr == array)
 	{
	 perror("malloc申请空间失败");
	 return;
	 }
 	capacity = n;
	 top = 0;
}
int main()
{
	 Stack st;
 	st.Init();
 	return 0;
}

二、实例化

1.实例化的概念

• ⽤类类型在物理内存中创建对象的过程，称为类实例化出对象。

• 类是对象进⾏⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，⽤类实例化出对象时，才会分配空间。

• ⼀个类可以实例化出多个对象，实例化出的对象占⽤实际的物理空间，存储类成员变量。打个⽐⽅：类实例化出对象就像现实中使⽤建筑设计图建造出房⼦，类就像是设计图，设计图规划了有多少个房间，房间⼤⼩功能等，但是并没有实体的建筑存在，也不能住⼈，⽤设计图修建出房⼦，房⼦才能住⼈。同样类就像设计图⼀样，不能存储数据，实例化出的对象分配物理内存存储数据。

#include<iostream>
using namespace std;
   class Date
{
  public:
        void Init(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和d2 
	 Date d1;
 	Date d2;
 	
	  d1.Init(2024, 3, 31);
	 d1.Print();
	 d2.Init(2024, 7, 5);
	 d2.Print();
	 
	 return 0;
}

2.对象大小

分析⼀下类对象中哪些成员呢？类实例化出的每个对象，都有独⽴的数据空间，所以对象中肯定包含成员变量

那么成员函数是否包含呢？

⾸先函数被编译后是⼀段指令，对象中没办法存储，这些指令存储在⼀个单独的区域(代码段)，那么对象中⾮要存储的话，只能是成员函数的指针。

再分析⼀下，对象中是否有存储指针的必要呢，Date实例化d1和d2两个对象，d1和d2都有各⾃独⽴的成员变量_year/_month/_day存储各⾃的数据，但是d1和d2的成员函数Init/Print指针却是⼀样的，存储在对象中就浪费了。如果⽤Date实例化100个对象，那么成员函数指针就重复存储100次，太浪费了。

这⾥需要再额外哆嗦⼀下，其实函数指针是不需要存储的，函数指针是⼀个地址，调⽤函数被编译成汇编指令[call 地址]，其实编译器在编译链接时，就要找到函数的地址，不是在运⾏时找，只有动态多态是在运⾏时找，就需要存储函数地址，这个我以后会讲解

内存对齐：(面试经常有) • 第⼀个成员在与结构体偏移量为0的地址处。

• 其他成员变量要对⻬到某个数字（对齐数）的整数倍的地址处。

• 注意：对齐数 = 编译器默认的⼀个对齐数与该成员大小的较小值。

• VS中默认的对齐数为8

• 结构体总大小为：最大对齐数（所有变量类型最⼤者与默认对齐参数取最小）的整数倍

• 如果嵌套了结构体的情况，嵌套的结构体对⻬到⾃⼰的最⼤对⻬数的整数倍处，结构体的整体⼤小就是所有最⼤对⻬数（含嵌套结构体的对⻬数）的整数倍

计算下面代码中A/B/C实例化的对象是多大？

计算下面代码中A实例化的对象是多大？

//A对象是8字节
class A
{
public:
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch;
	int _i;
};

因此A对象的对齐数是8个字节，我们发现如果内存对齐会浪费三个空间，在右边图中不是更好吗？在这种情况下，CPU读取数据_i的时候需要读取2次，我们第一次读取地址是0-3，第二次是4-7，再拼在一起 （CPU读出数据时从固定的整数倍位置读取固定大小的字节）

因此我得出为什么需要内存对齐：减少访问次数，提高效率，具体看C语言知识

B的大小是多大？，成员函数不存放在对象里面，那么大小是多大？是0？0的意思是不开空间，那么对象是怎么定义出来的？

对象实例化出来就必须占⽤实际的物理空间

下⾯的程序运⾏后，我们看到没有成员变量的B和C类对象的⼤⼩是1，为什么没有成员变量还要给1个字节呢？因为如果⼀个字节都不给，怎么表⽰对象存在过呢！所以这⾥给1字节，纯粹是为了占位标识对象存在

class B
{
public:
	void Print()
	{
		//
	}
};

//C的大小是多大？
class C
{

};

int main()
{
	B b;
	//因为b的地址不为空，所以是开辟了空间
	cout << &b << endl;
	cout << sizeof(b) << endl;//通过控制台打印我们发现B的对象的大小是1，那么为啥没有成员变量还需要给一个字节？
	//因为如果连一个字节都不给怎么表示对象是存在的！所以这里给一个字节，纯粹是为了占位标识对象存在
}



class A
{
public:
	void Print()
	{
		cout << this << endl;
		cout << "A::Print()" << endl;
	}
private:
	int _a;

};

int main()
{
	A* p = nullptr;
	           //mov      ecx   p
	p->Print();// call     地址不在对象里面
	return 0;
	///p->_a = 1;
}

上⾯我们分析了对象中只存储成员变量，C++规定类实例化的对象也要符合内存对齐的规则

三、this指针

在实例化后的几个对象我们知道了成员函数的地址都是一样的，函数体没有关于对象的区分，那么我们在main函数中调用时怎么知道该函数是访问哪个对象？

在C++中给了一个隐含的this指针解决了这里的问题

• 编译器编译后，类的成员函数默认都会在形参第⼀个位置，增加⼀个当前类类型的指针，叫做this指针。⽐如Date类的Init的真实原型为， void Init(Date* const this, int year, int month, int day)，因此在调用时是隐藏了& d1/d2

• 类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this->_year = year;

• C++规定不能在实参和形参的位置显⽰的写this指针(编译时编译器会处理)，但是可以在函数体内显⽰使⽤this指针。

总结：this指针不能被修改（this++不可以，因为是被const修饰了），但是this指向的内容可以被修改，在上面代码中this指向的是Date，可以被修改*

传统认为this指针存储在内存中的栈区，也可能存储在寄存器中

下面我们来看两个有趣的题目

题目1：

答案是正常运行，因为p虽然是空指针，但是成员函数的地址却并没有存在类中，因此不造成空指针解引用

题目2：

答案是运行崩溃，在main函数中p——>Print()并没有对空指针解引用，但是在Print函数里访问_a是通过this来访问，-a需要存到对象里，需要this指针访问，但是this指向p为空，即空指针解引用

四、封装

⾯向对象三⼤特性：封装、继承、多态，下⾯的对⽐我们可以初步了解⼀下封装。通过下⾯两份代码对⽐，我们发现C++实现Stack形态上还是发⽣了挺多的变化，底层和逻辑上没啥变化。

• C++中数据和函数都放到了类⾥⾯，通过访问限定符进⾏了限制，不能再随意通过对象直接修改数据，这是C++封装的⼀种体现，这个是最重要的变化。这⾥的封装的本质是⼀种更严格规范的管理，避免出现乱访问修改的问题。当然封装不仅仅是这样的，我们后⾯还需要不断的去学习。

• C++中有⼀些相对⽅便的语法，⽐如Init给的缺省参数会⽅便很多，成员函数每次不需要传对象地址，因为this指针隐含的传递了，⽅便了很多，使⽤类型不再需要typedef⽤类名就很⽅便

• 在我们这个C++⼊⻔阶段实现的Stack看起来变了很多，但是实质上变化不⼤。等着我们后⾯看STL中的⽤适配器实现的Stack，⼤家再感受C++的魅⼒

C语言实现

C++实现

五、类的默认成员函数

1.默认成员函数的定义及分类

默认成员函数就是用户没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。⼀个类，我们不写的情况下编译器会默认⽣成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解⼀下即可。其次就是C++11以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后⾯再去了解。默认成员函数很重要，也⽐较复杂，我们要从两个⽅⾯去学习：

• 第⼀：我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。

• 第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？

2.构造函数

1.定义

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数⾃动调⽤的特点就完美的替代的了Init。

2.构造函数的特点

函数名与类名相同。
无返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
对象实例化时系统会⾃动调⽤对应的构造函数。
构造函数可以重载。
如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显式定义编译器将不再⽣成。
⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函数。但是这三个函数有且只有⼀个存在，不能同时存在。⽆参构造函数和全缺省构造函数虽然构成函数重载，但是调⽤时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认⽣成那个叫默认构造，实际上⽆参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调⽤的构造就叫默认构造。
我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤初始化列表才能解决，初始化列表，我们下个章节再细细讲解。

#include<iostream>
using namespace std;
class Date
{
public:
	// 1.⽆参构造函数 
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数 
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 3.全缺省构造函数 
	/*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()
{
	// 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉 
	// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤ 
	Date d1; // 调⽤默认构造函数 ,调用无参构造不能加括号，因为加括号不确定是函数申明还是对象
	Date d2(2025, 1, 1); // 调⽤带参的构造函数 
	// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法 
	// 区分这⾥是函数声明还是实例化对象 
	// warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?) 
	Date d3();
	d1.Print();
	d2.Print();
	return 0;
}

说明：C++把类型分成内置类型(基本类型)和⾃定义类型。内置类型就是语⾔提供的原⽣数据类型，如：int/char/double/指针等，⾃定义类型就是我们使⽤class/struct等关键字⾃⼰定义的类型。

总结：大多数情况下，构造函数都需要我们自己去实现，少数情况下类MyQueue且Stack有默认构造时，MyQueue自动生成的就可以使用

3.析构函数

1.定义

析构函数与构造函数功能相反，析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对象中资源的清理释放⼯作。析构函数的功能类⽐我们之前Stack实现的Destroy功能，⽽像Date没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的

2.析构函数的特点：

析构函数名是在类名前加上字符 ~。
⽆参数⽆返回值。(这⾥跟构造类似，也不需要加void)
⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成默认的析构函数。
对象⽣命周期结束时，系统会⾃动调⽤析构函数。
跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会调⽤他的析构函数。
还需要注意的是我们显⽰写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类型成员⽆论什么情况都会⾃动调⽤析构函数。
如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源申请时，⼀定要⾃⼰写析构，否则会造成资源泄漏，如Stack。
⼀个局部域的多个对象，C++规定后定义的先析构

4.拷贝构造

1.定义

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

2.拷贝构造函数的特点

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

这里C++规定，传值传参要调用拷贝构造，因此如果不加引用会导致无穷递归

C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成。
若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉ / 浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造。
像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，在Stack中会导致st1和st2里面的_a指针指向同一块资源，会被析构两次，导致程序崩溃，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就需要显⽰写拷⻉构造，否则就不需要

#include<iostream>
using namespace std;
class Date
{
public:
 	Date(int year = 1, int month = 1, int day = 1)
 {
	 _year = year;
	 _month = month;
 	_day = day;
 }
 // 编译报错：error C2652: “Date”: ⾮法的复制构造函数: 第⼀个参数不应是“Date” 
 //Date(Date d)
 Date(const Date& d)
 {
	 _year = d._year;
	 _month = d._month;
	 _day = d._day;
 }
 Date(Date* d)
 {
	 _year = d->_year;
	 _month = d->_month;
	 _day = d->_day;
 }
 void Print()
 {
 cout << _year << "-" << _month << "-" << _day << endl;
 }
 
private:

 int _year;
 int _month;
 int _day;
};
void Func1(Date d)
{
 	cout << &d << endl;
 	d.Print();
}
// Date Func2()
Date& Func2()
{
	 Date tmp(2024, 7, 5);
	 
	 tmp.Print();
 
 	return tmp;
}

int main()
{


		 Date d1(2024, 7, 5);
 	// C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥传值传参要调⽤拷⻉构造 
 // 所以这⾥的d1传值传参给d要调⽤拷⻉构造完成拷⻉，传引⽤传参可以减少这⾥的拷⻉ 
	 Func1(d1);
	 cout << &d1 << endl;

 // 这⾥可以完成拷⻉，但是不是拷⻉构造，只是⼀个普通的构造 
 //拷贝构造函数的核心特征是 “用同类对象本身初始化新对象”，而指针参数传递的是对象的地址，并非对象本身，因此不满足拷贝构造的定义
 Date d2(&d1);
 d1.Print();
 d2.Print();
 //这样写才是拷⻉构造，通过同类型的对象初始化构造，⽽不是指针 
 Date d3(d1);
 d2.Print();
 // 也可以这样写，这⾥也是拷⻉构造 
 Date d4 = d1;
 d2.Print();
 
 // Func2返回了⼀个局部对象tmp的引⽤作为返回值 
 // Func2函数结束，tmp对象就销毁了，相当于了⼀个野引⽤ 
 Date ret = Func2();
 ret.Print();
 
 return 0;
}

MyQueue和两Stack代码

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	Stack(const Stack& st)
	{
		// 需要对_a指向资源创建同样⼤的资源再拷⻉值 
		
			 _a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}
	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;

};
// 两个Stack实现队列 
class MyQueue
{
public:
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉ 
	// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃 
	Stack st2 = st1;
	MyQueue mq1;
	// MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst 
	// 的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题 
	MyQueue mq2 = mq1;
	return 0;
}

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

#include<iostream>
Stack & func2()
{
     //这里必须是全局变量，不加static为局部变量会形成野引用
	 static Stack st;

     return st;
}

int main()
{
    
    Stack ret=func2();
     
    return 0;


}

5.赋值运算符重载

1.运算符重载

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

• 运算符重载是具有特殊名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。

• 重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。

• 如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数⽐运算对象少⼀个。

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

• 不能通过连接语法中没有的符号来创建新的操作符：⽐如operator@。

[• * ] [ : : ] (sizeof) [? : ] [.]注意以上5个运算符不能重载。(选择题⾥⾯常考，⼤家要记⼀下）,我们这里来看下.*在什么情况下会有，如下代码：

#include<iostream>
using namespace std;

class A
{
public:
	void func()
	{
		cout << "A::func()" << endl;
	}

};


typedef  void(A::* PE)();//成员函数指针类型

int main()
{
	//void (A:: * PE)()=nullptr;
	PE pe=nullptr;
	//C++规定成员函数要加&才能取到函数指针
	pe = &A::func;

	A aa;
	(aa.*pe)();

}

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

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

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

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

class Data
{
public:
	
	Data(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;

	}
	bool operator==( Data d2)
	{
		//在类外面不可以访问私有成员
		return _year == d2._year
			&& _month == d2._month
			&& _day == d2._day;
	}
private:

	 //为了区分成员变量，⼀般习惯上成员变量 
    // 会加⼀个特殊标识，如_ 或者 m开头 
	int _year; // year_ m_year
	int _month;
	int _day;


};

bool operator<(Data d1, Data d2)
{

}


int main()
{

	Data x1(2025, 8, 1);


	Data x2(2025, 8, 10);


	//operator==(x1, x2);
	//可以上述这么写，也可以按下面这样写
	cout<<(x1 == x2)<<endl;
	x1.operator==(x2);
//	x1==x2;
	
	return 0;
}

2.赋值运算符重载

赋值运算符重载是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷贝赋值，这⾥要注意跟拷⻉构造区分，拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象，下面我们通过代码来仔细区分下两者

int main()
{
Date d1(2025,8,15);
Date d2(2025,8,16);

   //赋值重载拷贝
   d1=d2;

  // 拷贝构造
  Date d3(d2);
  Date d4=d2;

return 0;
}

特点：

赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成const当前类类型引⽤，否则会传值传参会有拷⻉
有返回值，且建议写成当前类类型引⽤，引⽤返回可以提⾼效率，有返回值⽬的是为了⽀持连续赋值场景。

//d3=d1;
//这里将返回值改成引用，是为了防止调用拷贝构造，生成拷贝
//Date operator=(const Date & d)
Date& operator=(const Date & d)
{
     _year=d.year;
     _month=d.month;
     _day=d.day;

   //连续赋值,将d3赋值给this，但是this是指针（是d3的地址），需要解引用，*this就是d3
     return *this;
}

没有显式实现时，编译器会⾃动⽣成⼀个默认赋值运算符重载，默认赋值运算符重载⾏为跟默认拷⻉构造函数类似，对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义、类型成员变量会调⽤他的赋值重载函数
像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的赋值运算符重载就可以完成需要的拷⻉，所以不需要我们显⽰实现赋值运算符重载。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的赋值运算符重载完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的赋值运算符重载会调⽤Stack的赋值运算符重载，也不需要我们显⽰实现MyQueue的赋值运算符重载。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就需要显⽰写赋值运算符重载，否则就不需要

6.取地址运算符重载

1.const成员函数

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

• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this

在这里，d1报错是因为d1需要传的是const Date类型，而形参是Dateconst this类型，权限放大

这里就是权限可以缩小和平移

总结：当然不是所有的成员函数都适合添加const，只有不修改成员变量的可以加const，加完const后，我们发现有很多好处，很爽，在调用时可以使用const修饰，也可以是普通调用，因为权限可以缩小，并且可以检查我们是否在写代码时，“==”写成“=”，这种常见的错误。

成员函数如构造函数就不可以添加const，因为初始化需要修改成员变量

2.取地址运算符的重载

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

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

	const Date* operator&()const
	{
		return this;
		// return nullptr;
	}
private:
	int _year; // 年 
	int _month; // ⽉ 
	int _day; // ⽇ 
};

六、手动实现日期项目

1.日期项目实现源码

总结

本文从类的基础定义入手，顺着 “类与对象的关联” 这条主线，拆解了对象实例化的本质、this 指针的隐形逻辑，也重点梳理了默认成员函数（构造、析构、拷贝构造、赋值重载）的关键规则 —— 这些函数看似 “隐形”，却默默支撑着对象的创建、初始化、资源释放等核心操作，尤其要注意 “浅拷贝与深拷贝” 的坑，像 Stack 这类含资源的类必须手动实现深拷贝。

最后通过日期类的实战，也能感受到：类与对象的核心是 “封装”—— 把数据和操作数据的方法打包，既规范了代码逻辑，又让调用更直观。这些基础既是跨越面向对象门槛的关键，也是后续学继承、多态的根基，吃透了它们，C++ 的面向对象之路才算真正迈开步

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-08-23，如有侵权请联系 cloudcommunity@tencent.com 删除

对象