【C++修炼之路第二章】类和对象上

时差freebright

于 2024-07-14 12:01:28 发布

阅读量386

点赞数 12

文章标签： c++ 开发语言类和对象 visual studio git

本文链接：https://blog.csdn.net/2301_79499548/article/details/140412147

版权

1.面向过程和面向对象初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

比如洗衣服的过程：C语言就是需要关注过程

C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成

2.类的引入

举例对比C语言和CPP的链表节点结构体的写法

// C语言的写法
struct ListNode_C
{
	struct ListNode_C* next; // 变量类型：struct ListNode_C*
	int val;
};
// C++的写法
struct ListNode_CPP
{
	ListNode_CPP* next;// 变量类型：直接写类的名字就好：ListNode_CPP*
	int val;
};

类中的成员函数（不用写某些参数）可以直接使用类中的成员变量，不像 C语言的函数（一个函数要接收多个参数）

// C++的类
struct Stack 
{
	// 成员函数
	// 这类里面，定义的东西可以直接访问：对数组直接进行初始化
	void Init(int n = 3)
	{
		array = (int*)malloc(sizeof(int) * n);
		if (array = NULL) {
			perror("malloc fail !");
			return;
		}
		capacity = n;
		top = 0;
	}
	
	// 成员变量
	int* array;
	size_t capacity;
	size_t top;
};


int main()
{
	struct Stack st1; // C语言的结构体用法（C++兼容C）
	Stack st2; // 类的名称可以直接用
	return 0;
}

上面结构体的定义，在C++中更喜欢用class来代替。
直接就把 struct 换成 class，其他的不用变，类的作用与含义不会变

因为 struct 就是C++为了兼容C语言所规定的语法


class Stack
{
	// 成员函数
	void Init(int n = 3)
	{
		array = (int*)malloc(sizeof(int) * n);
		if (array = NULL) {
			perror("malloc fail !");
			return;
		}
		capacity = n;
		top = 0;
	}
	
	void Push(int x = 0)
	{
		// ......
	}
	// 成员变量
	int* array;
	size_t capacity;
	size_t top;
};

3.类 class 的定义

class className
{
 // 类体：由成员函数和成员变量组成
 
};  // 一定要注意后面的分号：这里和 struct 是一致的

class 为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。

类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类的函数称为类的方法或者 成员函数。

3.1 类的两种定义方式：

3.1.1 声明和定义不分离

声明和定义全部放在类体中

需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理（什么是内联函数？后续章节会讲解）

3.1.2 声明和定义分离

类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

我们更推荐声明和定义分离

4. 类的访问限定符及封装

这里报错：不可访问

上面那个报错实际上是因为在类的外面，不能直接访问类里面的东西

这就引出：访问限定的概念

4.1 访问限定符

4.1.1 C++实现封装的方式：

设计一个类：用类将对象的属性与方法结合在一块，让对象更加完善，
访问权限的设置：通过访问权限选择性的将其接口提供给外部的用户使用。

（即一个类中，你可以设置哪些东西可以给外界使用，哪些东西不可以给外界使用）

4.1.2 访问限定符的分类

4.1.3 访问限定符说明

1、public 修饰的成员在类外可以直接被访问

2、protected 和 private 修饰的成员在类外不能直接被访问 (此处protected和private是类似的)

那如何将私有的变成公有，改变访问限定？：使用访问限定符 public

3、class 的默认访问权限为 private（在类外不能直接访问），struct 默认为 public (因为struct要兼容C，C里面没有访问限定的定义，干脆直接“开放成公有制”)

这段代码：在类的外面访问类，可以发现，class 形式的类报错（不可访问），struct 可以访问

具体代码如下：

class Stack_1 // class 形式的类
{
	void Init1()
	{
		// ....
	}
};

struct Stack_2   // 结构体 struct形式的类
{
	void Init2()
	{
		// ....
	}
};

int main()
{
	// class 形式的类
	Stack_1 st1;
	st1.Init1(); // 报错

	// 结构体 struct形式的类
	struct Stack_2 st2;
	st2.Init2(); // 不报错

	return 0;
}

4.1.4 访问权限作用域大小

（1）从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

示例如下：从一个 public 开始到下一个 public 框定的范围 就是访问权限作用域

这样可以发现，class 的类可以直接在类的外面访问函数Init ，因为这个函数属于 public 的公有访问权限作用域

（2）如果后面没有访问限定符，作用域就到 } 即类结束。

（3）通常情况下，（这样比较规范但非必须）在类中，把成员函数设置成公有：public，将成员变量设置为私有：private

为什么一般是将成员函数设置成公有，将成员变量设置为私有？

答：使外界只能使用公开的函数（已设计好的），“强制”你使用规范的行为

举个例子：像我们这个栈的类，有个 top 变量，代表栈顶：a[top-1] 这个就是栈顶元素，但是总有人会搞出数组越界的操作：a[top]

这个操作的本质是直接使用到了 top 这个成员变量，所以我们将 top 这类的成员变量设置成私有的，就是不想让你随便的操作到成员变量，而只能通过设计的成员函数来执行一些功能

你想获取到栈顶元素，就只能通过成员函数Top()，不能直接使用成员变量 top：a[top-1] ，在达成目的的同时，也不会出现 a[top] 这类的错误操作

class Stack // class 形式的类
{
public:  
	int Top(){
		return a[top - 1];
	}
private:   
	int* a;
	int top;
};


int main()
{
	// class 形式的类
	Stack st;
	int tmp = st.Top();
	cout << tmp << '\n';

	return 0;
}

通过这个类的封装可以反映出 C++ 使得代码相较于 C语言更加规范化，减少了许多非规范化的行为程序的产生

规范化使得程序设计有次序的进行

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

就是在语义上限制你的行为

4.2【面试题】C++中 struct 和 class 的区别是什么？

解答：

C++需要兼容C语言，所以 C++ 中 struct 可以当成结构体使用。

另外 C++ 中 struct 还可以用来定义类。和 class 定义类是一样的，区别是 struct 定义的类默认访问权限是 public，class 定义的类默认访问权限是 private。

注意：在继承和模板参数列表位置，struct和 class 也有区别，后续给大家介绍。

5. 成员变量的书写规范

平时我们看到 C++ 类的源码可以发现：类里面的成员变量都清一色的在名字前面加一个下划线

原因：

举个例子演示，便于解释原因

运行下面这段代码：我们想要初始化类里面的日期成员变量为 2024/5/1，但是运行之后可以发现成员变量 year / month / day (不是指Init函数的)这三个变量根本就没有改变，初始化失败

本意是想要初始化成员变量 year / month / day ，但是函数里面 year = year; 这样表示自己赋值给自己，而不是使用传递过来的参数 (int year, int month, int day)，为了方便识别以及不用修改 传参（这样的可读性好），我们通常就会在成员变量前面加一个下划线

class Time  // 日期类
 {
 public:
     void Init(int year, int month, int day)
     {
         year = year;
         month = month;
         day = day;
     }
 private:
     int year;
     int month;
     int day;
 };
 
 
 int main()
 {
     Time t;
     t.Init(2024, 5, 1);
 
     return 0;
 }

修改后：不是一定要求在前面加一个下划线，也可以在后面加，写可以写成 m_year （m 代表 member）

主要是为了区分而已

 class Time  // 日期类
 {
 public:
     void Init(int year, int month, int day)
     {
         _year = year;
         _month = month;
         _day = day;
     }
 private:
     int _year;
     int _month;
     int _day;
 };

注意：也可以使用 this指针（本文的后面章节有讲解）

成员变量可以写成同名的，但使用时需要使用 this 指针

class Time  // 日期类
 {
 public:
     void Init(int year, int month, int day)
     {
         this->year = year;
         this->month = month;
         this->day = day;
     }
 private:
     int year;
     int month;
     int day;
 };

6. 类的作用域

先说一个 C++ 的常识，花括号括起来的就算做一个域

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

之前讲过的命名空间是用于名字隔离

而类的作用域也有名字隔离的作用：

例如：下面演示的栈和队列两个类，都有初始化函数 Init() ，重名但不报错，就是因为类域进行了名字隔离

class Stack // 栈 的类
{
public:
	void Init()
	{
		// ....
	}
};

class Queue // 队列 的类
{
public:
	void Init()
	{
		// ....
	}
};

因此，想要使用指定一个类的成员函数，需要向命名空间一样，要指定使用

Stack::Init / Queue::Push 像这种指定写法

同时这里也演示了：声明和定义分离的方法

class Stack // 栈 的类
{
public:
	void Init(); // 定义
};

class Queue // 队列 的类
{
public:
	void Push(); // 定义
};

// Stack:: 指定 Init这个函数属于 Stack 这个类
void Stack::Init()  // 具体实现
{
	// ..... 
}
// Queue:: 指定 Init这个函数属于 Queue 这个类
void Queue::Push()  // 具体实现
{
	// .....
}

7. 【面试题】谈一谈在面向对象中，什么是封装呢？

面向对象的三大特性：封装、继承、多态。（这个是三大特性，不是只有这三个）

在类和对象阶段，主要是研究类的封装特性，那什么是封装呢？

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。封装本质上是一种管理，让用户更方便使用类。

比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

又比如：洗衣机，我们只用知道怎么使用洗衣机就好，不用知道内部洗衣机怎么运行的

核心：在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

8. 类的实例化（类是房子图纸，实例化对象是建造的房子）

用类类型创建对象的过程，称为类的实例化

1、类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。

2、一对多的关系：一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量（一个类可以有多个对象，这么说类的确是海王（doge））

3、通俗的比方：类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

9. 类对象模型（关于计算类的大小）

9.1 为什么可以计算类的大小？

上面将类比作房屋的图纸，我们在没有实际建造房子的前提下，可不可以知道总共需要即建造多大的房子？

是可以的

图纸设计房子的时候，已经标注好房子的占地面积等等

因此同理，类的大小也可以计算，对象的大小也可以算

9.2 观察下面代码的结果：发现类的成员函数不包括在类的大小中

这段代码的结果：

class Time  // 日期类
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};



int main()
{
	Time t;

	cout << "类Time 的大小：	" << sizeof(Time) << '\n';
	cout << "Time的对象 t 的大小：" << sizeof(t) << '\n';
	return 0;
}

可以发现类的大小和该类的对象大小相等

又根据内存对齐规则（不了解的可以先自学，就是结构体内存对齐，本篇文章后面也有讲到），计算这三个成员变量 _year / _month / _day 的总大小刚好是 12

也就说明计算一个类的大小时，并没有包括成员函数的大小

实际上，一个类的成员函数是公共使用的，不算进一个类的大小中

原因：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。

9.3 以日期类举例：演示并解释为什么成员函数不包括在类的大小中

class Time  // 日期类
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Time t1;   t1.Init(2024, 1, 1);
	Time t2;   t2.Init(1999, 8, 1);  

	return 0;
}

成员变量可以重复保存，因为在不同对象中，成员变量的值可以不同，存在差异性

 // 成员变量的值可以不同
 Time t1;   t1.Init(2024, 1, 1);
 Time t2;   t2.Init(1999, 8, 1);

但是成员函数都是使用这个函数的同一个逻辑流程，没有差异性

 void Init(int year, int month, int day)
 {
     _year = year;
     _month = month;
     _day = day;
 }

因此，成员函数通常是放在一个公共区域（公共代码区），给这个类的不同对象调用使用，而一个对象只保存这个类的成员变量就好

9.4 【思考题】比较这三种类型的类的大小：思考空类的大小是多少

// 一、类中既有成员变量，又有成员函数
class A1 {
public:
	void f1() {}
private:
	int _a;
};

// 二、类中仅有成员函数
class A2 {
public:
	void f2() {}
};

// 三、类中什么都没有---空类
class A3
{};


int main()
{
	 
	cout << "一、" << sizeof(A1) << '\n';
	cout << "二、" << sizeof(A2) << '\n';
	cout << "三、" << sizeof(A3) << '\n';

	return 0;
}

运行结果：

非空类：该类中”成员变量”之和

空类：一个字节（上面的第二和第三种都是空类，第二种的函数不包括在一个对象的大小中，所以是空的）

为什么空类大小不是 0 ？

先问个问题，当你定义了一个空类的对象，若这个空类的大小为 0，那你这个对象到底算不算定义出来了？（定义出来的空间为 0 ，开了个空气？如定义吗？doge ）

要明白，定义是需要开空间的，不开空间怎么算作定义呢

因此，空类就使用一个字节，标识对象被定义出来，但这一个字不存储有效数据

9.5 得出结论

综上所述，可以得出结论

结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐

注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

（C++空类大小不为 0 ，不同编译器设置不一样，VS 和 devc++ 设置为 1 ）

10. 【拓展】结构体内存对齐规则

1、第一个成员在与结构体偏移量为0的地址处。

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

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

VS中默认的对齐数为8

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

4、如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

【面试题】

（1）结构体怎么对齐？为什么要进行内存对齐？

为什么说，不进行内存对齐，可能会执行两次内存访问？

（2）如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5即任意字节对齐？

可以通过 #pragma 这个预处理指令，来设置对齐数，一般设计默认对齐数为 偶数！！！

#pragma pack(1) // 设置默认对⻬数为1
#pragma pack() // 取消设置的对⻬数，还原为默认

如何取消对齐？

答：换种角度思考，取消了对齐数，本质是老实的计算变量的大小后相加，也就是对齐数设置成 1

修改了默认对齐数位 1 后，下面代码的结果即为 6（char+char+int = 6）

 #pragma pack(1)
 class A
 {
 private:
     char _a;
     char _b;
     int _c;
 };
 int main()
 {
     cout << sizeof(A) << '\n'; 
     return 0;
 }

（3）什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景

什么大端小端:

大端(存储)模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中;

小端(存储)模式，是指数据的低位保存在内存的低地址中，而数据的高位，保存在内存的高地址中。

数据的大小端存储 是由 计算机硬件决定的，不是编译器

如 十进制数字：135 1 为高位，5 为低位

十六进制序列 ： 0x 11 22 33 44 11 为高位， 44 为低位

大端存储：如下图（小端存储就反着来）

11. this 指针

11.1 this指针的引出

定义一个日期类 Date

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << '\n';
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	d1.Print();
	d2.Print();
	return 0;
}

运行上面的代码，可得结果

疑问来了：

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

解决办法：

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的（透明的意思是用户看不见），即用户不需要来传递，编译器自动完成。

代码演示

下面代码中，注释的代码，是编译器底层执行的程序（用户表面看不见）

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// void Print(Date* this)   // 编译器底层执行的程序：用 this 指针 接收 对象的地址
	void Print()
	{
		//  编译器底层执行的程序：对 this 指针指向的对象的成员变量进行操作
		// cout << this->_year << "-" << this->_month << "-" << this->_day << '\n';
		cout << _year << "-" << _month << "-" << _day << '\n';
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);

	// 编译器底层执行的程序：把 对象 的指针传过去
	// d1.Print(&d1);  
	d1.Print();
	// d2.Print(&d2);
	d2.Print();

	return 0;
}

11.2 this指针的特性

this 指针是隐含的：this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

（1）实参和形参的位置不能直接写，编译器自己会写

自己写就是错的

d1.Print(&d1);   // 错误的
d1.Print();  // 正确的
 
// 成员函数处：形参处不用你写
void Print(Date* this)   // 错的
void Print() // 对的

（2）但是在类里面可以用 this指针

这两种写法都是正确的

 void Print() 
 {
     //  编译器底层执行的程序：对 this 指针指向的对象的成员变量进行操作
     cout << this->_year << "-" << this->_month << "-" << this->_day << '\n';
     cout << _year << "-" << _month << "-" << _day << '\n';
 }

（3） this指针的类型：类类型* const，表示在成员函数中，不能给this指针赋值（this 被 const 修饰，使其不能被修改）

 void Print(Date* const this)  // 编译器内部的写法 this 是 *const 类型
 {
     this = nullptr; // 这里会报错：成员函数内部不能修改 this 指针
     cout << _year << "-" << _month << "-" << _day << '\n';
 }

12. 三道大厂面试题：考察对 this 指针的理解

（1）关于this指针为空指针题一

// 1.下面程序编译运行结果是？  A、编译报错  B、运行崩溃  C、正常运行
 class A 
 {
 public:
     void Print()
     {
         cout << "Print()" << endl;
     }
 private:
     int _a; 
 };
 int main()
 {
     A* p = nullptr;
     p->Print();
     return 0;
 }

本题的思路：

首先，访问空指针（类似解引用）会报运行错误，不会报编译错误，所以先排除 A

访问空指针（类似解引用）才可以获取到该指针所指向的空间内容，同时要调用使用一个函数，在编译链接阶段，就需要获取到这个函数的地址（底层来看）

我们需不需要在指针 p 所指向的对象中，获取Print函数的地址？即需不需要访问指针p ？

答：不需要

因为在前面这一节【类对象模型（关于计算类的大小）】讲解过，成员函数都放在公共代码区域，而不是在对象中，因此我们不需要在指针 p 所指向的对象中找 Print函数，也就不需要访问指针p

因此答案选 C

我们调用 Print 函数时，会将对象指针 p 传过去作为 this 指针，我们仅仅是传递这个指针，没有进行访问，

到 Print 函数处，也没有访问这个指针，那怎样算作在成员函数处访问呢？看下一道例题

（2）关于this指针为空指针题二

本段程序和上面一题很相似，注意辨别

// 2.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
 class A
 {
 public:
     void PrintA()
     {
         cout << _a << endl;
     }
 private:
     int _a;
 };
 int main()
 {
     A* p = nullptr;
     p->PrintA();
     return 0;
 }

本段程序会运行崩溃，选 C

报错：涉及空指针的访问

本题思路：

根据上一道例题的思路，在 main 函数中传递空指针过去作为 this 指针是没有错的（因为不涉及指针的访问）

又因为【1、this指针的指出的代码演示】这一节中提到：底层会给成员函数加上一个 this 指针用于接收对象的地址

void Print(Date* this)   // 编译器底层执行的程序：用 this 指针 接收 对象的地址

同时在函数中，会加上 this-> 表示访问这个 this指针所指空间中的成员

//  编译器底层执行的程序：对 this 指针指向的对象的成员变量进行操作
 cout << this->_year; // 编译器底层加上 this->
 cout << _year;  // 你自己写的


因此本题中：

 cout << _a << endl;
 cout << this->_a << endl; // 底层加上 this->

这里就涉及了 this 指针的访问！！！！（警觉了）

由此，我们传过去的 this指针是空指针，导致产生空指针访问的问题，运行崩溃

（3）this指针存在哪里？

先列举几个存储区：栈、堆、静态区、常量区、对象里面

首先排除 “对象里面” ：在之前【类对象模型（关于计算类的大小）】这一节中，得出结论：对象的大小就是成员变量内存对齐后的大小，因此不包括 this指针

最后答案是：栈

因为 this指针算作形参，形参一般存储于栈中

另外，this指针也可能存储在 ecx寄存器中

例如 VS 中，会将对象 d1 的指针放到 ecx寄存器中（x86 环境下，即 64 位）（注意：x64 即 32位环境下，是 rcs寄存器，这个和ecx寄存器类似）

源码：可以自己将下面代码转为反汇编，即可得到上面的汇编代码

class Date
 {
 public:
     void Init(int year, int month, int day)
     {
         _year = year;
         _month = month;
         _day = day;
     }
 
     void Print()  
     {
         cout << _year << "-" << _month << "-" << _day << '\n';
     }
 private:
     int _year; // 年
     int _month; // 月
     int _day; // 日
 };
 int main()
 {
     Date d1;
     d1.Init(2022, 1, 11);
     d1.Print(); 
 
     return 0;
 }