• C++类和对象(上篇）—初识类与对象【重点掌握】

    目录

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

    2、类的引入

    3、类的定义

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

    访问限定符

    封装 

    5、类的作用域

    6、类的实例化 

    7、类对象的存储方式

    8、this指针

    this指针的引出

    this指针的特性 

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

    • C语言是面向过程的，关注的是过程，分析出求解问题的步骤，然后通过函数调用来逐步解决问题。
    • C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

    举个例子：

    假如我们写一个外卖系统，面向过程关注的是上架商品、点外卖、通知商家、分配骑手、派送、点评等具体操作过程。而面向对象则关注的就是商家、用户、骑手。

    2、类的引入

    最初C++被称为“C with Classes”(包含类的C语言)，是C语言的继承，进一步扩展和完善C语言。最开始大佬们是用struct来引入类的。

    比如我们在C语言中用结构体来定义一个学生（C语言在结构体中只能定义变量）

    1. struct Student
    2. {
    3. 	char _name[20];
    4. 	char _gender[3];
    5. 	int _age;
    6. };

    用C语言的方式结构体只能定义变量，C++是兼容C语言的，在C++中，结构体不仅可以定义变量，也可以定义函数。

    1. struct Student
    2. {
    3. 	void Init(const char* name, const char* gender, int age)
    4. 	{
    5. 		strcpy(_name, name);
    6. 		strcpy(_gender, gender);
    7. 		_age = age;
    8. 	}
    9. 	void Print()
    10. 	{
    11. 		cout << _name << " " << _gender << " " << _age << endl;
    12. 	}
    13.  
    14. 	char _name[20];
    15. 	char _gender[3];
    16. 	int _age;
    17. };

    C++对struct进行升级，把struct升级成了类，有如下标志：

    • 结构体名称可以做类型
    • 里面可以定义函数

    代码演示：

    1. struct ListNode
    2. {
    3. 	int val;
    4. 	//C语言定义next只能这样定义
    5. 	struct ListNode* next;
    6. 	//C++可以这样定义
    7. 	ListNode* next;
    8. 	//C++里面可以定义函数，C只能定义成员
    9. 	void Print()
    10. 	{
    11. 		//.......
    12. 	}
    13. };
    14.  
    15. int main()
    16. {
    17. 	//C语言不typedef只能这样定义
    18. 	struct Student s1;
    19. 	//C++可以这样定义
    20. 	Student s2;
    21. 	return 0;
    22. }

    C++里面可以访问其成员也可以访问其函数

    1. struct Student
    2. {
    3. 	void Init(const char* name, const char* gender, int age)
    4. 	{
    5. 		strcpy(_name, name);
    6. 		strcpy(_gender, gender);
    7. 		_age = age;
    8. 	}
    9. 	void Print()
    10. 	{
    11. 		cout << _name << " " << _gender << " " << _age << endl;
    12. 	}
    13.  
    14. 	char _name[20];
    15. 	char _gender[3];
    16. 	int _age;
    17. };
    18.  
    19.  
    20. int main()
    21. {
    22. 	Student s1;
    23. 	s1.Init("张三", "男", 18);
    24. 	s1.Print();
    25. 	return 0;
    26. }

    ⚠：注意 

    C++类中的成员变量可以定义在类的任意位置，不会像C语言那样收到约束，因为C++这里把struct升级成了类，类是一个整体，它会在这个整体中寻找。

    虽然C++把struct升级成了类，不过C++还是喜欢用class来代替struct以此来定义类。

    我们看下面代码：

    1. int main()
    2. {
    3. 	Student s1;
    4. 	
    5. 	return 0;
    6. }

    我们把Student叫做类名，在C语言中我们将s1叫做变量，而在C++中我们称之为对象。

    3、类的定义

    1. class className
    2. {
    3. 	//类体：由成员函数和成员变量组成
    4. };  //一定要注意后面的分号
    • class为定义类的关键字，className为类的名字，{}中为类的主体，注意类定义结束时后面的分号。
    • 类中的元素称为类的成员：类中的数据称为类的属性或者成员变量；类中的函数称为类的方法或者成员函数。

    类的定义有两种方式，具体内容我们下文会讲到。

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

    访问限定符

    要知道类里面的东西并不都是随便给你用，我若想把里面的东西给你用就定义成共有（public）。不想让你用就定义成私有（private）。想要保护起来就定义成保护（protect）。C++实现封装的方式：用类将对象的属性和方法结合在一起，让对象更加的完善，通过访问权限选择性的将其接口提供给外部的用户使用。

    • 访问限定符说明：
    1. public修饰的成员在类外可以直接被访问。
    2. protected和private修饰的成员在类外不能直接被访问。
    3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。
    4. 如果后面没有访问限定符，作用域就到}类结束。
    5. class的默认访问权限为private，struct为public(因为struct要兼容C)
    • ⚠：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别。

    接下来我们做具体的演示：

    • class默认是private：

    • struct默认是public：

    •  public：

    • private： 

    此时public的作用域一直到private访问限定符之前。

    • protected：

    现阶段我们认为protected和private作用相同，都是类外不能访问。具体差别我们在后面会讲到。

    •  【面试题】 

    问：C++中的struct和class有什么区别？

    答：C++需要兼容C语言，所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类。和class是定义类是一样的，区别是struct的成员默认访问方式是public，class是的成员默认访问方式是private。

    封装 

    •  【面试题】面向对象的三大特性：封装、继承、多态。

    封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象实现交互。

    我们都知道C语言的数据和方法是分离开的，我们以栈为例：

    1. //C语言的数据和方法是分离的
    2. struct Stack
    3. {
    4. 	int* _a;
    5. 	int _top;
    6. 	int _capacity;
    7. };
    8. void StackInit(struct Stack* ps)
    9. {}
    10. void StackPush(struct Stack* ps, int x)
    11. {}
    12. int StackTop(struct Stack* ps)
    13. {}
    14. int main()
    15. {
    16. 	struct Stack st;
    17. 	StackInit(&st);
    18. 	StackPush(&st, 1);
    19. 	StackPush(&st, 3);
    20. 	StackPush(&st, 5);
    21. 	return 0;
    22. }

    像C语言这样数据和方法分离开来就会存在一个大的问题：太过自由！我们没办法对其进行很好的管理，就比如我们访问栈顶的数据，如果是C语言，我们可以这样写：

    1. 	printf("%d\n", StackTop(&st));  //规范
    2. 	printf("%d\n", st._a[st._top]); //不规范

    按照实现来说这两种写法都正确，但是第一种方法相对第二种更加合理，第二种太过自由，直接去操控结构成员，这就会涉及一个问题：我的top到底是栈顶元素还是栈顶元素的下一个位置？

    如果我们初始化里的top给的是0，那么st.top就是栈顶元素的下一个位置，这样就会发生越界访问。如果是-1，那么就刚好是栈顶元素。此时就很有可能发生误用。如果我们直接调用StackTop函数就不会出现上述问题。因为我在之前已经处理好了，返回的值必定是栈顶元素。

    • 由此可见，C语言在这一方面太过自由，接下来我们看看C++是如何进行解决。

    这里就用到了封装。C++设计出了类，类里除了可以定义成员变量，还可以定义函数。所以我们就可以把上述栈的初始化、插入、取栈顶元素全部放入类里面，这也就实现了数据和方法封装到一起。

    1. //1、数据和方法封装到一起，类里面
    2. //2、想给你自由访问的设计成公有，不想给你访问的设计成私有
    3. class Stack
    4. {
    5. public:
    6. 	void Init()
    7. 	{}
    8. 	void Push(int x)
    9. 	{}
    10. 	int Top(struct Stack* ps)
    11. 	{}
    12. private:
    13. 	int* _a;
    14. 	int _top;
    15. 	int _capacity;
    16. };

    用C++就完美的避免了C语言过于自由的弊端，我们把成员变量设置成私有，就不能再像C语言那样直接访问成员变量，而只能用成员函数。

    1. int main()
    2. {
    3. 	Stack st;
    4. 	st.Init();
    5. 	st.Push(1);
    6. 	st.Push(2);
    7. 	st.Push(3);
    8. 	st.Push(4);
    9. 	cout << st._a[st._top] << endl; //err
    10. 	return 0;
    11. }

    C++的封装本质上就是一种更严格的管理。 

    5、类的作用域

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

    如下我们定义两个类（栈和队列）

    1. //栈
    2. class Stack
    3. {
    4. public:
    5. 	void Push(int x)
    6. 	{}
    7. };
    8.  
    9. //队列
    10. class Queue
    11. {
    12. 	void Push(int x)
    13. 	{}
    14. };

    在这两个类中，我都定义了一个Push函数，此时编译器不会报错，这两个Push函数也不会构成函数重载，因为Stack和Queue属于两个不同的作用域。

    我们在Stack.h文件里声明如下内容：

    现在我们想在Stack.cpp文件里进行定义，我们就要指定作用域，否则会报错：

    讲到这里，我们就可以引出类的定义方式:

    •  方式1：声明和定义全部放入类体中

    ⚠： 成员函数如果在类中定义，编译器可能会将其当成内联函数进行处理。因此，一般情况下：短小函数可以直接在类里面定义，长一点的声明和定义分离。

    • 方式2：声明放在.h文件中，类的定义放在.cpp文件中

    此方式就是我们上面所展示的Stack.h和Stack.cpp。

    6、类的实例化 

    ⭐：类成员变量仅仅只是声明，不是定义！！！因为在内存中并没有开辟空间。

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

    • 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
    • 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
    • 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

    7、类对象的存储方式

    • 猜测1：对象中包含类的各个成员

    缺陷： 每个对象中的成员变量是不同的，但是调用的却是同一份函数，如果按照此种方式进行存储，当一个类创建多个对象时，每个对象都保存一份代码，相同的函数保存多次，浪费空间，显然这种猜想不可取。

    • 猜测2：只保存成员变量，成员函数存放在公共代码段

    类对象的存储方式采用的是第二种方式。

    既然采用的是第二种方式，那么两个不同的对象在调用成员函数时调用的应该是同一个函数，下面我们来看看反汇编来验证这一结论：

    通过反汇编得知，调用两次相同的Init()函数call的地址都是一样的，所以就没有必要把函数在对象里面存一份，因为调用的都是同一个函数，如果我每一个函数都存一个函数指针就浪费了。相反成员变量必须得各自存一份，因为各个成员变量的值是不一样的，我函数是一样的可以不存，但是成员变量就不能不存了，所以我们就可以把函数放到公共代码区里了。也就是说我调用函数是在这个公共代码段里调用的。综上类大小的计算不考虑成员函数。

    • 清楚了类的存储方式后，我们来看几道题：
    1. // 类中既有成员变量，又有成员函数
    2. class A1 {
    3. public:
    4. 	void f1() {}
    5. private:
    6. 	int _a;
    7. 	char _ch;
    8. };
    9. // 类中仅有成员函数
    10. class A2 {
    11. public:
    12. 	void f2() {}
    13. };
    14. // 类中什么都没有---空类
    15. class A3
    16. {};
    17. int main()
    18. {
    19. 	A1 a1;
    20. 	A2 a2;
    21. 	A3 a3;
    22. 	cout << sizeof(a1) << endl; // 8
    23. 	cout << sizeof(a2) << endl; // 1
    24. 	cout << sizeof(a3) << endl; // 1
    25. 	return 0;
    26. }
    • sizeof(a1)：  8      sizeof(a2)：  1      sizeof(a3)：  1  

    ⚠：当类里面没有成员函数时，至少会给它开辟一个字节大小的空间，这1个字节不是为了存储有效数据，而是为了占位，表示对象存在过。

    结论：

    • 没有成员变量的类对象，编译器会给它们分配1字节占位，表示对象存在过。
    • 一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

    补充：结构体内存对齐规则

    • 第一个成员在与结构体偏移量为0的地址处。
    • 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的对齐数为8。
    • 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
    • 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
    • 【面试题】
    1. 结构体怎么对齐？ 为什么要进行内存对齐。
    2. 如何让结构体按照指定的对齐参数进行对齐。
    3. 什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景

    8、this指针

    this指针的引出

    在之后的学习中，我们会一直用到日期类

    1. class Date
    2. {
    3. public:
    4. 	void Print()
    5. 	{
    6. 		cout << _year << "-" << _month << "-" << _day << endl;
    7. 	}
    8. 	void Init(int year, int month, int day)
    9. 	{
    10. 		_year = year;
    11. 		_month = month;
    12. 		_day = day;
    13. 	}
    14. private:
    15. 	int _year;  //年
    16. 	int _month; //月
    17. 	int _day;   //日
    18. };
    19.  
    20. int main()
    21. {
    22. 	Date d1;
    23. 	Date d2;
    24. 	d1.Init(2022, 5, 20);
    25. 	d2.Init(2022, 5, 21);
    26. 	d1.Print();
    27. 	d2.Print();
    28. 	return 0;
    29. }

    在上述定义的日期类中，我们定义了d1和d2两个对象，并且初始化后将其打印。首先我们确定的是d1和d2调用的Print是同一个函数。

    • 但是现在有一个问题，我们可以看到Print函数里面并没有参数，那它怎么知道我第一次调用的是5月20日的那个，而第二个Print函数调用的是5月21号的那个呢？调用的Print函数都是在公共代码段里找到，我们怎么进行区分呢？？
    • 上述问题就涉及到了C++的隐含this指针。this指针是一个隐含的形参。这也就意味着我Print函数和Init函数其实是被编译器处理过的，并且实参也会传地址。
    1. class Date
    2. {
    3. public:
    4. 	//Print处理前
    5. 	void Print()
    6. 	{
    7. 		cout << _year << "-" << _month << "-" << _day << endl;
    8. 	}
    9. 	//Print处理后
    10. 	void Print(Date* const this) //被const修饰，指针不能被修改，指针指向的内容可以修改
    11. 	{
    12. 		cout << this->_year << "-" <<this->_month << "-" << this->_day << endl;
    13. 	}
    14. 	//Init处理前
    15. 	void Init(int year, int month, int day)
    16. 	{
    17. 		_year = year;
    18. 		_month = month;
    19. 		_day = day;
    20. 	}
    21. 	//Init处理后
    22. 	void Init(Date* const this, int year, int month, int day)
    23. 	{
    24. 		this->_year = year;
    25. 		this->_month = month;
    26. 		this->_day = day;
    27. 	}
    28. private:
    29. 	int _year;  //年
    30. 	int _month; //月
    31. 	int _day;   //日
    32. };
    33.  
    34. int main()
    35. {
    36. 	Date d1;
    37. 	Date d2;
    38. 	//编译器处理后
    39. 	d1.Init(2022, 5, 20);
    40. 	d2.Init(2022, 5, 21);
    41. 	//编译器处理前
    42. 	d1.Init(&d1, 2022, 5, 20);
    43. 	d2.Init(&d2, 2022, 5, 21);
    44.  
    45. 	//编译器处理后
    46. 	d1.Print();
    47. 	d2.Print();
    48. 	//编译器处理前
    49. 	d1.Print(&d1);
    50. 	d2.Print(&d2);
    51.  
    52. 	return 0;
    53. }

    图示演示对应关系：

    谁调用就把谁的地址传过去，此时的this就是形参，为了验证这一结论，我们通过打印地址来看看：

    1. class Date
    2. {
    3. public:
    4. 	void Print()
    5. 	{
    6. 		cout << this << endl << endl;
    7. 		cout << _year << "-" << _month << "-" << _day << endl;
    8. 	}
    9. 	void Init(int year, int month, int day)
    10. 	{
    11. 		cout << this << endl << endl;
    12. 		_year = year;
    13. 		_month = month;
    14. 		_day = day;
    15. 	}
    16. private:
    17. 	int _year;  //年
    18. 	int _month; //月
    19. 	int _day;   //日
    20. };
    21.  
    22. int main()
    23. {
    24. 	Date d1;
    25. 	Date d2;
    26. 	cout << "d1:" << &d1 << endl;
    27. 	cout << "d2:" << &d2 << endl << endl;
    28.  
    29. 	d1.Init(2022, 5, 20);
    30. 	d2.Init(2022, 5, 21);
    31.  
    32. 	d1.Print();
    33. 	d2.Print();
    34. 	return 0;
    35. }

    ⚠：实参和形参不能显示的写出来，就比如this和&对象都不能直接在实参和形参的位置写出来，编译器会自动帮我们处理。但是我们可以在函数里面显示出this指针，当然也可以不写。 

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

    this指针的特性 

    1. this指针的类型：类的类型* +const+this
    2. 只能在"成员函数"的内部使用
    3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
    4. this指针是成员函数第一个隐含的指针形参，一般情况下由编译器通过ecx寄存器自动传递，不需要用户传递

    之前都是创建对象，那如果我创建一个对象的指针呢？

    这里很明显看出左边是取对象地址作为实参传递过去，而右边是直接传指针p作为实参传过去。

    • 【面试题】 

    1、下面程序编译运行结果是？

      A、编译错误          B、运行崩溃           C、正常运行

    1. class A
    2. {
    3. public:
    4. 	void Show()
    5. 	{
    6. 		cout << "Show()" << endl;
    7. 	}
    8. private:
    9. 	int _a;
    10. };
    11. int main()
    12. {
    13. 	A* p = nullptr;
    14. 	p->Show();
    15. }
    • 答案：C
    • 解析：首先我们需要明确的是空指针的解引用是不会报编译错误的，我们先排除A。可能会有人觉得这里的p为空指针，空指针解引用肯定会报运行错误，别急，我们把私有的成员变量放出来，再解引用对比看看：

    其实第39行才是真正的解引用 ，第38行不是解引用。我们都知道对象里面只有成员变量，我访问成员变量就是到指针指向的空间去访问_a,但是指针指向的空间是空指针，当然就会报错。而Show函数并不在对象里面，它在公共代码段本身并不属于对象。它就和普通的函数调用一样，去找到函数的地址即可，即call地址，并且把p作为实参传到形参this指针里面，同时这也就间接证明了this指针可以为空。所以这段程序运行正常。

    2、下面程序编译运行结果是？

      A、编译错误          B、运行崩溃           C、正常运行

    1. class A
    2. {
    3. public:
    4. 	void PrintA()
    5. 	{
    6. 		cout << _a << endl;
    7. 	}
    8. private:
    9. 	int _a;
    10. };
    11. int main()
    12. {
    13. 	A* p = nullptr;
    14. 	p->PrintA();
    15. }
    • 答案：B
    • 解析：此题就会出现运行崩溃了。首先，我调用PrintA函数，实参p传到形参this指针，此时编译器对_a进行访问，此时就是空指针的解引用，当然会运行崩溃。

    3、this指针存在哪里？

     A、栈       B、堆         C、静态区      D、常量区

    • 答案：A
    • 解析：this指针是把对象的地址传递过去，它是一个形参，参数的传递是在函数的栈帧，也就是说this指针存在栈里，当然有些编译器会使用寄存器优化。

    4、this指针可以为空吗？

    • 答案：可以
  • 相关阅读:
    解决使用 Eruda 绑定 dom 未在指定位置显示问题
    关于羊了个羊，我真的是娘了个娘。
    动态天气预报：Living Weather HD for Mac
    java冒泡排序
    速锐得适配进口福特烈马BRONCO车载 CAN总线应用随动转向大灯改装
    算法入门02旋转数组的最小数字
    使用navicat连接openGauss数据库
    前端自动化测试 —— Jest 测试框架应用
    Django文件上传
    Springcloud（一）：springcloud使用nacos作为注册中心和配置中心
  • 原文地址：https://blog.csdn.net/weixin_60718941/article/details/127630794