2024年最全【C++】类和对象（中(2)，2024阿里手淘C C++面试题目-CSDN博客

本文链接：https://blog.csdn.net/2401_84976207/article/details/138908881

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

{
public:

private:
int _year;
int _month;
int _day;

A _a;

};

int main()
{
//对象实例化的时候，自动调用
Date d1;
return 0;
}


可以看见，确实是调用了A\_aa的默认构造函数，并打印出来  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/1c844bf60d1846e9a994151311ed2128.png)


C++11 中针对**内置类型成员不初始化**的缺陷，又打了补丁，即：内置类型成员变量在类中**声明时**可以给默认值

class Date
{
private:
int _year =1;//注意这里不是初始化，是给缺省值因为这里是声明
int _month =1;
int _day =1;
A _a;
};


⚡ 任何一个类的**默认构造函数**（不用参数就可以调用），有三个 —— **无参**构造函数、**全缺省**构造函数、**我们没写**编译器**自动生成**的构造函数。并且默认构造函数只能有一个（语法上他们可以同时存在，但是如果有对象定义去调用就会报错）


1. 我们不写，**编译器自动生成**的那个
2. 我们自己写，**全缺省构造函数**
3. 我们自己写，**无参构造函数**



> 
> 特点：**不传参数就可以调用**
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/de16e6ae064440a1bc5d45642184241c.png)


因为构造函数就三种，这里是我们自己写的构造函数，还主动带了一个参数，既**不符合**`无参`、`全缺省`，更加不符合编译器`自动生成`的那构造函数，所以这就**没有默认构造函数**可调了，就报错咯。


### 三. 析构函数


#### 🌍析构函数概念


析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而**对象在销毁时会自动调用析构函数，完成对象中资源的清理工作**（相当于打扫卫生的）


![在这里插入图片描述](https://img-blog.csdnimg.cn/1a05f4d7cd724545b35f06d8106279d7.png)


#### 🌍析构函数特征


**析构函数**是特殊的成员函数


🍉**特征**如下：


1. 析构函数名是在**类名前**加上字符 `~`。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若`未显式定义`，系统会自动生成默认的析构函数。注意：析构函数不能重载
4. **对象生命周期结束**时，C++编译系统系统**自动调用**析构函数

class Date
{
public:
Date(int year = 2002, int month = 2, int day = 19)
{
_year = year;
_month = month;
_day = day;
}

~Date()
{
    //int \_year....栈上开辟的空间，出栈了自然销毁了，不需要析构
	cout << "~Date()" << endl;
}

private:
int _year;
int _month;
int _day;
};

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


我们调试发现：`Date()`日期类也没有资源需要清理，不是所有的类都要析构函数，在这里不实现析构都可以


那么谁的析构函数是有价值的呢？ —— 栈

typedef int DataType;
class Stack
{
public:
//构造函数
Stack(int capacity = 4)
{
cout << “Stack(int capacity = 4)” << endl;
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror(“malloc申请空间失败!!!”);
return;
}

	_size = 0;
	_capacity = capacity;
}

void Push(DataType data)
{
	// CheckCapacity();
	_array[_size] = data;
	_size++;
}
//析构函数
~Stack()
{
	free(_array);//下面三步做不做都可以
	_capacity = _size = 0;//生命周期到了，都还给系统了，\_array为野指针，自然不能访问size等
	_array = nullptr;
}

private:
DataType* _array;
int _capacity;
int _size;
};

int main()
{
Stack st1;
return 0;
}


这样就保证了，栈定义出来，就一定被初始化了；出作用域，在堆上申请的空间一定被回收了。就此代替了Init和Destroy


⚡如果我们不写，编译器自动生成的析构函数，会做一些什么呢？


1. 对**内置类型**的成员变量**不做处理**  
 ❌因为指针不一定是malloc出来的，可能是new、fopen出来的，不能直接`free`
2. 对于**自定义类型**的成员变量会**回去调它的析构函数**

typedef int DataType;
class Stack
{
public:
Stack(int capacity = 4)
{
cout << “Stack(int capacity = 4)” << endl;
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror(“malloc申请空间失败!!!”);
return;
}

	_size = 0;
	_capacity = capacity;
}

void Push(DataType data)
{
	// CheckCapacity();
	_array[_size] = data;
	_size++;
}

~Stack()
{
	cout << "~Stack()->" << _array << endl;//为了看到是否真正调用了析构
	free(_array);
	_capacity = _size = 0;
	_array = nullptr;
}

private:
DataType* _array;
int _capacity;
int _size;
};

class MyQueue
{
// 我们不需要写，构造函数和析构函数
// 默认生成的很有用
// 对于自定义类型，会自动调用它的默认构造函数和析构函数
private:
int _size = 0;
Stack _st1;
Stack _st2;
};

int main()
{
Stack st;
MyQueue q;

return 0;

}


发现果然正确！MyQueue 中的`Stack`自动调用默认的析构  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/60ef0e3eaea844faa57ad639f734f71e.png)


### 四. 小总结


看完可能觉得有点晕，在这里总结一下吧


#### 🌊构造函数


![在这里插入图片描述](https://img-blog.csdnimg.cn/2cf3f5bf8fe54d33814a66e763faa76e.png)


#### 🌊析构函数


![在这里插入图片描述](https://img-blog.csdnimg.cn/d6a7ccafc34c4db1ae26f76b15cccaa8.png)


### 五. 拷贝构造函数


那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/25875f1ad37d4dca994d36b6aab1ef08.png)


#### 🎉概念


拷贝构造函数：只有**单个形参**，该形参是对本类**类型对象的引用**(一般常用`const`修饰)，在用**已存在的类类型对象创建新对象时由编译器自动调用**


#### 🎉特征


**拷贝构造函数**也是特殊的成员函数


**🍅特征**如下：


1. 拷贝构造函数是构造函数的一个**重载**形式。
2. 拷贝构造函数的**参数只有一个**且必须**是类类型的引用**`Date(const Date& d)`，使用**传值**方式会引发**无穷递归调用**

class Date
{
public:
//拷贝构造
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}

//构造函数
Date(int year = 0, int month = 1, int day = 1)
{
	_year = year;
	_month = month;
	_day = day;
}

private:
int _year;
int _month;
int _day;
};

int main()
{
Date d1(2002, 3, 7);
Date d2(d1); //好比 Date d3 = d1;
return 0;
}


这里`const Date&`常引用，最明显的原因是**防止误写**，导致d1被修改，但是我们不希望修改，使用加const


假如我们使用传值传参 ——


![在这里插入图片描述](https://img-blog.csdnimg.cn/1d3b95290950492db2043d5d5d9b22cc.png)![在这里插入图片描述](https://img-blog.csdnimg.cn/16982e80568f42adb29518a9e66f277c.png)


这里会有疑问，**为什么传值传参是拷贝构造？**  
 传值传参，就是把实参的值拷贝赋给形参，用同类型的来初始化你，其实就是一个拷贝构造


![在这里插入图片描述](https://img-blog.csdnimg.cn/ebe9a5f7d4a84c338881089a236e5ed8.png)


但是引用传参，`d`就是d1的一个别名，不会进入死循环


![在这里插入图片描述](https://img-blog.csdnimg.cn/e09efeaf48144ee0889ed0b07a69b11c.png)  
 ps：指针也能实现，不过用起来很别扭，我们就不讲了


🧐若未显式定义，编译器会**自动生成**默认的拷贝构造函数。


1. 对**内置类型**，会完成**字节序拷贝**（浅拷贝）
2. 对**自定义类型成员**，会去调用它的拷贝构造


我们接下来验证一下：


编译器生成的默认构造函数，对于**内置类型成员**，确实完成了字节序的拷贝。也就是说像日期类这样的我们完全可以不写，默认生成的够用


![在这里插入图片描述](https://img-blog.csdnimg.cn/58f80d05b443462eac956c8a0afc5e65.png)


那么我们看看栈？ 继续不写拷贝构造，让编译器自动生成

class Stack
{
public:
//构造函数
Stack(int capacity = 4)
{
_array = (int*)malloc(sizeof(int)* capacity);
if (_array == nullptr)
{
cout << “malloc failed” << endl;
exit(-1);
}
_top = 0;
_capacity = capacity;
}

//析构函数
~Stack()
{
	free(_array);
	_array = nullptr;
	_top = _capacity = 0;
}

private:
int* _array;
int _top;
int _capacity;
};

int main()
{
Stack st1(10);
Stack st2(st1);
}


发现崩溃了❌  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/4063ac32f05745058dbc9ffb2881c035.png)


这是因为——


![在这里插入图片描述](https://img-blog.csdnimg.cn/3c9fe29528904f62b9372959cff7a0d2.png)


🍉这种叫做**浅拷贝**  
 1、一个对象修改会影响另一个对象  
 2、 会析构两次，程序崩溃


像这种类，就不能用默认的了，要我们自己实现深拷贝 —— 后面专门讲解


对于自定义类型变量，确实会调用它的拷贝构造函数，我们可以验证 ——

class A
{
public:
A(const A& a)
{
cout << “A(const A&)” << endl;
}
};

class Date
{
public:
//构造函数
Date(int year = 0, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}

private:
int _year;
int _month;
int _day;

A _a;

};

int main()
{
Date d1(2002, 3, 7);
Date d2(d1);
return 0;
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/a65cd0afe5264d3ba4d81bb1f90951dd.png)


### 六. 赋值运算符重载


我们知道内置类型可以直接使用运算符运算，但在默认情况下，C++是不支持**自定义类型**对象**使用运算符**，因为编译器也不知道运算规则


比如日期类：

Date d(2022, 10, 8);
Date d(2022, 10, 26);


我想比较任意两个日期大小`d1 < d2`，想计算还有多少天国庆`d2 - d1`，都是没办法直接用运算符计算的。


为此，我们引入了运算符重载。


#### 💦运算符重载


C++为了增强**代码的可读性**引入了**运算符重载**，运算符重载是具有特殊函数名的函数


函数原型如下：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/5ebba55083ec4fab809b055288eb1780.png)


注：


* 不能通过连接其他符号来创建新的操作符：比如operator@
* 重载操作符必须有一个类类型参数
* 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
* 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
* `.*`（很少见）、 `::` 、`sizeof`、 `? :`（三目） 、`.` 注意以上5个运算符不能重载，这个经常在笔试选择题中出现


于是我们就实现了这样一个比较日期类大小的逻辑 ——


注：传参可以传值，但是在C++中建议**传引用**，这样可以减少拷贝提高效率（减少拷贝构造的消耗）。并且如果我们无需改变操作数，就用常引用`const Date&`，（防止我们在修改形参同时把实参也改了，同时const引用接收对象，权限缩小或者不变）


![在这里插入图片描述](https://img-blog.csdnimg.cn/9691848e5c854346af5ff06611bbc80d.png)


因为我的成员变量是`private`私有的，在类外不能访问，所以都出错了，那我们暂且先把访问修饰限定去掉


接下来有两个问题 ——


🔮1、`d1==d2`是怎么样调用这个函数的？


🔮2、成员变量私有在类外面访问不了，如何解决？


##### 🧐问题1：如何调用



> 
> `d1==d2`是怎么样调用这个函数的？
> 
> 
> 


经过调试，确实是调用了，实际上编译器会把`d1 == d2`转化为`operator==(d1, d2)`


但一般不会这样去显示写，但是这样就违背了我们**增强可读性的初衷**了，不然还不如直接写一个函数呢？


![在这里插入图片描述](https://img-blog.csdnimg.cn/dcd3f76f17bf450696765eb2e14eb502.png)


##### 🧐问题2



> 
> 成员变量私有在类外面访问不了，如何解决？
> 
> 
> 


我们为了让程序运行简单粗暴去掉了访问修饰限定符private，这实际上破坏了封装性。


我们也可以在类中写上诸如`int GetYear() {}`这样的函数，这不破坏封装性，但还是有些麻烦，也不常用

int GetYear()
{
return _year;
}


那我们把它放进类里面—— 又出现问题了


![在这里插入图片描述](https://img-blog.csdnimg.cn/2e9323dbfbc94a378a1402ec7fb7a520.png)


这是因为成员函数默认多了一个`this`指针

class Date
{
public:
Date(int year = 0, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
bool operator==( const Date& x)
{
return _year == x._year
&& _month == x._month
&& _day == x._day;
}

//private:
int _year;
int _month;
int _day;
};

int main()
{
Date d1(2022, 10, 8);
Date d2(2022, 10, 26);

cout << (d1 == d2) << endl;
cout << d1.operator==(d2)<< endl; //编译器处理-> d1.operator==(&d1,d2)
return 0;

}


当`d1 == d2`；我们这样调用它时，实际上会被编译器处理成`d1.operator==(d2)`；


![在这里插入图片描述](https://img-blog.csdnimg.cn/560b0f0ab40746f4a2ba1d3ebf83dded.png)


所以我们推荐这样写

cout << d1.operator==(d2)<< endl；


#### 💦赋值运算符重载


##### 🎨 赋值重载的概念


有了上面拷贝构造的基础，接下来的理解就轻松很多了


我们介绍了**拷贝构造**函数 —— 它是用一个**已经存在的对象**，**拷贝初始化**一个**即将创建**的对象

//拷贝构造
Date d1(2022, 10, 9);
Date d2(d1);


接下来介绍的是赋值重载—— 它是**两个已经存在的对象**，之间进行拷贝赋值

//赋值重载
Date d1(2022, 10, 9);
Date d3(2022, 10, 26);
d1 = d3;


提问：这个是赋值重载还是拷贝构造？

Date d1(2002, 3, 7);
Date d2 = d1;


根据定义出发 ：只要一个存在的对象，这是拷贝构造


##### 🎨赋值重载的实现细节


🔥**1 .赋值运算符重载格式**


* 参数类型：`const T&`，**传引用**可以**提高传参效率**
* 返回值类型：`T&`，返回引用可以**提高返回的效率**（不用生成临时拷贝），有返回值目的是为了支持**连续赋值**
* 检测是否自己给自己赋值（判断）
* 返回`*this` ：要复合**连续赋值**的含义

class Date
{
public:
//构造会频繁的调用，所以直接放在类里面定义作为inline
Date(int year = 2022, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

根据定义出发：只要一个存在的对象，这是拷贝构造

🎨赋值重载的实现细节

🔥1 .赋值运算符重载格式

参数类型：const T&，传引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率（不用生成临时拷贝），有返回值目的是为了支持连续赋值
检测是否自己给自己赋值（判断）
返回*this ：要复合连续赋值的含义

class Date
{
public:
	//构造会频繁的调用，所以直接放在类里面定义作为inline
	Date(int year = 2022, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;


[外链图片转存中...(img-gDdQyd28-1715756251364)]
[外链图片转存中...(img-3Wn7O7ZS-1715756251365)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**