C++|【C++】类和对象(一)


文章目录

      • 一、初步认识面向过程和面向对象
      • 二、类的引入
        • C 和 C++ 中「 struct 」的区别
      • 三、类的定义
      • 四、类的访问限定符及封装
        • 4.1 类的访问限定符
        • 4.2 类的封装
      • 五、类的作用域
      • 六、类的实例化
        • 6.1 类成员的声明与定义(要搞清楚)
      • 七、类对象模型
        • 7.1 类对象的存储方式
        • 7.2 计算类对象的大小
        • 7.3 结构体内存对齐规则
      • 八、this 指针
        • 8.1 this 的引出
        • 8.2 this 指针的特性

一、初步认识面向过程和面向对象
面向对象:OO, Object - Oriented
面向过程:PO, Procedure - Oriented
C语言是「面向过程」的,关注的是「过程」,分析出求解问题的步骤,通过函数调用逐步解决问题。
C++是「基于面向对象」的,关注的是「对象」,将一件事情拆分成不同的对象,靠对象之间的交互完成。
注意:C++不是纯面向对象语言,C++既有面向过程(因为兼容C语言),也有面向对象,可以混合编程。
比如:
炒一盘菜:
面向过程关注的是过程,即炒菜的每个步骤(切菜、开火、放油、加佐料,炒…)。
面向对象关注的是对象,则会创建一个厨师类,然后在类中添加炒菜的方法,然后实例化厨师对象,调用炒菜方法。
二、类的引入
C 和 C++ 中「 struct 」的区别 区别一:
/**************************************************************/ // c struct ListNode { int val; struct ListNode* next; // c语言中必须要写struct }; typedef struct ListNode // typedef { int val; struct ListNode* next; // 即使用了typedef,如果在结构体内,也必须要写struct }; // 解析: // C语言中struct是结构体 // 而 struct ListNode 这个整体是结构体名,必须要写全,不能省略struct // typedef struct ListNode 在结构体结束的位置才会生效,所以在结构体内必须写全/**************************************************************/ // cpp struct ListNode { int val; ListNode* next; // cpp中可以不写struct }; // 解析: // C++中struct不仅仅是结构体,struct已经升级成类了 // 而 ListNode 就是类名,ListNode* next 中的 ListNode 就是类名 // 所以我们可以不用写struct,当然也可以写上,因为cpp兼容c

【C++|【C++】类和对象(一)】区别二:
C语言中:数据和方法分离,结构体内只能定义变量。
C++中:数据和方法是封装在一起的,结构体内既可以定义变量,也可以定义函数。
/**************************************************************/ // c struct Student { char _name[10]; // 数据 int _age; }; // 方法(必须传结构体指针) void SetStudentInfo(struct Student* ps, const char* name, int age) { strcpy(ps->_name, name); ps->_age = age; }int main() { Student s; s.SetStudentInfo(&s, "winter", 20); }/**************************************************************/ // cpp struct Student { // 方法 void SetInfo(const char* name, int age) // 思考:为什么cpp中不用传结构体指针了呢? { strcpy(_name, name); _age = age; } char _name[10]; // 数据 int _age; }; int main() { Student s; s.SetInfo("winter", 20); }

上面结构体的定义,在 C++ 中更喜欢用 class 来代替。
三、类的定义
class为定义类的关键字,ClassName 为类的名字,{} 中为类的主体,注意类定义结束时后面分号。
class className { // ... };

类中的元素称为类的成员:
  • 类中的数据,称为 类的属性 或 成员变量;
  • 类中的函数,称为 类的方法 或 成员函数。
类的两种定义方式:
  • 声明和定义全部放在类体中,需要注意:成员函数如果在类中定义,编译器可能会将其当成内联函数处理。
    C++|【C++】类和对象(一)
    文章图片
  • 声明放在 .h 文件中,定义放在 .cpp 文件中。
    C++|【C++】类和对象(一)
    文章图片
总结:
一般情况下,短的成员函数,声明和定义都放在类体中;长的函数,声明和定义分离,这样也能够更清楚的看到类的结构。
四、类的访问限定符及封装
4.1 类的访问限定符 访问限定符分为三种:
  • public(公有)
  • protected(保护)
  • private(私有)
访问限定符说明:
  1. public 修饰的成员在「类外」可以直接被访问
  2. protectedprivate 修饰的成员在「类外」不能直接被访问
    (注:此处 protectedprivate 是类似的,继承时才能够更好的体现它们的区别)
  3. 访问权限作用域从该访问限定符出现的位置开始,直到下一个访问限定符出现时为止
  4. C++中的 class 的默认访问权限为 private,struct 的默认访问权限为 public(因为 struct 要兼容C)
    class A // 默认访问权限是private { // ... }; struct A// 默认访问权限是public { // ... };

  5. 所以:类中的成员,我想让你在类外面访问的,设置成公有;我不想让你在类外面访问,设置成私有。
注意:
访问限定符只在编译时有用,当数据映射到内存后,没有任何访问限定符上的区别
【面试题】C++中 struct 和 class 的区别是什么?
解答:C++需要兼容C语言,所以 C++ 中 struct 可以当成结构体去使用。另外 C++ 中 struct 还可以用来定义类。和 class 是定义类是一样的,唯一的区别是: struct 的成员默认访问权限是 public,class 是的成员默认访问权限是 private。
4.2 类的封装 【面试题】 面向对象的三大特性:封装、继承、多态。
在类和对象阶段,我们只研究类的封装特性,那什么是封装呢?
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行
交互。
C++实现封装的方式:
用类将对象的属性与方法结合在一块,让对象更加完善,通过访问权限,有选择性的将其接口提供给外部的用户使用。
类的定义和设计就体现了封装的思想:
  • C语言中,没有封装,数据和方法分离,比较自由,任何人都可以随便访问数据和方法。
  • C++中,有封装,数据和方法都放到类里面,同时想给你访问的,定义成公有;不想给你访问的,定义成私有。
封装本质上是一种管理:
我们如何管理兵马俑呢?C语言相当于什么都不管,不设防护栏,万一访问的人素质差,兵马俑就被随意破坏了。而 C++ 就相当于建了一座房子把兵马俑给封装起来。但不是封的死死的,不让别人看。可以参观的部分,设置售票通道,可以买票突破封装,并在合理的监管机制下进去参观。
类也是一样,我们把类中的数据和方法都封装到一下,不想给别人看到的,我们使用 protected / private 把成员封装起来。开放一些公有的成员函数对成员合理的访问。所以封装本质是一种管理。
封装能够更好的规范代码。小伙子不要不讲码德呀!
五、类的作用域
花括号 {} 括起来的都是一个域。
类定义了一个新的作用域,类的所有成员都在类的作用域中。
如果在类体外定义成员,需要使用 :: 作用域解析符指明成员属于哪个类域。
class Person { public: void PrintInfo(); private: char _name[20]; int _age; }; // 这里需要指定PrintInfo是属于Person这个类域 void Person::PrintInfo() { cout << _name << " " << _age << endl; }

六、类的实例化
用类类型创建对象的过程,称为类的实例化:
  1. 类只是一个模型一样的东西,限定了类有哪些成员,定义出一个类并没有分配实际的内存空间来存储它。
  2. 一个类可以实例化出多个对象,实例化出的对象占用实际的物理空间,存储类成员变量。
  3. 举个例子:现实中使用建筑设计图建造出房子,类就像是设计图,并没有实体的建筑存在。根据图纸建造出的房子,才能住人。同样,类也只是一个设计图,实例化出的对象才能实际存储数据,占用物理空间。
? C++|【C++】类和对象(一)
文章图片

6.1 类成员的声明与定义(要搞清楚) 注意:
  • 成员变量的定义是指:给变量分配了空间,跟是否初始化没有关系。
  • 成员变量是存在对象中的,对象实例化时,才是它们定义的地方。
class Person { public: void PrintInfo(); // 对于成员函数,这是声明private: char _name[20]; // 对于成员变量,这是声明(告诉你变量的类型、名称,但是没有开空间) int _age; }; void Person::PrintInfo() // 对于成员函数,这是定义(实现) { cout << _name << " " << _age << endl; }

七、类对象模型
7.1 类对象的存储方式 每个对象中成员变量是不同的,但是调用同一份函数,如果把成员变量和成员函数都存储在对象中,当一个类创建多个对象时,每个对象中都会多一份代码,相同代码保存多次,浪费空间。那么如何解决呢?
只保存成员变量,成员函数存放在公共的代码段。
C++|【C++】类和对象(一)
文章图片
总结:
  • 实例化了一个对象后,系统会为该对象的数据成员分配存储空间,以存放该对象的各个数据成员(注意:分配的存储空间不包括成员函数的空间)
  • 同一个类的不同对象其数据成员的值是不同的,而成员函数代码是相同的,所以存放对象时只需要存储自己的数据成员,而同一个类的各个对象的成员函数可以共用一份(单独存放在对象之外的另一段存储空间中)
7.2 计算类对象的大小 ① 计算一个类对象的大小
类对象大小:类对象中只存储了成员变量,所以只计算成员变量的大小(需要进行内存对齐)
示例:
class A { public: void func1() { cout << "func1" << endl; } void func2() { cout << "func2" << endl; } void func3() { cout << "func3" << endl; }private: int _a; int _b; }; int main() { A a; cout << sizeof(a) << endl; // 输出:8 return 0; }

② 计算一个类的大小
注意:算一个类型的大小,本质是算这个类型定义出的一个对象的大小,因为类型本身是不占空间的。
总结:
  1. 一个类的大小,实际就是该类中 ” 成员变量 ” 之和(需要进行内存对齐)
  2. 注意空类的大小,空类比较特殊,编译器给了空类 1 个字节来唯一标识这个类。
  3. 如果一个类没有成员变量,是一个空类,那么它的对象需要给 1 字节进行占位,表示其对象存在,这 1 字节不存储有效数据。
  4. 那么空类有意义吗? – 有的,比如后面要学习的仿函数。
示例:
// 类中既有成员变量,又有成员函数 class A { public: void func() {}private: int _a; }; // 类中仅有成员函数 class B { public: void func() {} }; // 空类 class C {}; int main() { cout << sizeof(A) << endl; // 输出:4 cout << sizeof(B) << endl; // 输出:1 cout << sizeof(C) << endl; // 输出:1 return 0; }

7.3 结构体内存对齐规则 结构体的对齐规则:
  1. 第一个成员变量在与结构体变量偏移量为 0 的地址处。
  2. 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
    • 对齐数 =「编译器默认的一个对齐数」与「该成员大小」中的较小值。
    • VS中默认对齐数为「8」,Linux中没有对齐数。
  3. 结构体总大小为:最大对齐数(「所有成员变量中对齐数的最大者」与「默认对齐数」取最小)的整数倍。
  4. 如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。
面试题:
  • 结构体怎么对齐? 为什么要进行内存对齐?
    大部分的参考资料是这样说的:
    1. 平台原因(移植原因): 不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据,否则抛出硬件异常。(那我们就要将数据对齐到能够访问的这些地址处)
    2. 性能原因:数据结构(尤其是栈)应该尽可能地在自然边界上对齐。 原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。
  • 如何让结构体按照指定的对齐参数进行对齐?
  • 什么是大小端?如何测试某台机器是大端还是小端,有没有遇到过要考虑大小端的场景?
八、this 指针
8.1 this 的引出 拿日期类举例:
class Date { public: void Display() { cout << _year << "-" << _month << "-" << _day << endl; } void SetDate(int year, int month, int day) { _year = year; _month = month; _day = day; }private: int _year; // 年 int _month; // 月 int _day; // 日 }; int main() { Date d1; // 实例化对象d1 Date d2; // 实例化对象d2 d1.SetDate(2021, 10, 8); d2.SetDate(2022, 10, 8); d1.Display(); d2.Display(); return 0; }

对于上述类,思考这样的一个问题:
Date 类中有 SetDate 与 Display 两个成员函数,函数体中没有关于不同对象的区分,那当 d1 调用 SetDate 函数时,该函数是如何知道应该设置 d1 对象,而不是设置 d2 对象呢?
成员函数怎么辨别当前调用自己的是哪个对象呢?—— 隐含的 this 常量指针(它指向了调用自己的对象)
C++中通过引入 this 指针解决该问题,即:C++编译器给每个 “ 非静态的成员函数 “ 增加了一个隐含的「常量指针」参数,让该指针指向调用本函数的对象,在函数体中对所有成员变量的操作,都是通过该指针去访问。只不过所有的操作对用户是透明的,即用户不需要来传递,编译器自动完成。
C++|【C++】类和对象(一)
文章图片
现在再来看刚才写的日期类:
成员函数隐含的 this 指针指向哪个对象,在成员函数中就可以通过 this 指针来访问哪个对象中的数据。
class Date { public: // 编译器会解释为:void Display(Date* const this) void Display() { cout << this->_year << "-" << this->_month << "-" << this->_day << endl; } // 编译器会解释为:void SetDate(Date* const this, int year, int month, int day) void SetDate(int year, int month, int day) { this->_year = year; this->_month = month; this->_day = day; // 成员函数内,可以显示的在成员前加上 this-> // 我们不加的话,默认也会在成员前加上 this->this->Display(); // 成员函数中还可以调成员函数,因为有 this 指针 }private: int _year; // 年 int _month; // 月 int _day; // 日 }; int main() { Date d1; Date d2; d1.SetDate(2021, 10, 8); // 编译器会解释为:d1.SetDate(&d1, 2021, 10, 8); d2.SetDate(2022, 10, 8); // 编译器会解释为:d2.SetDate(&d2, 2022, 10, 8); d1.Display(); // 编译器会解释为:d1.Display(&d1); d2.Display(); // 编译器会解释为:d2.Display(&d2); return 0; }

最后再回想一下 C 语言中,方法是怎么辨别当前调用自己的是哪个对象呢,其实原理和C++是一样的。
看完下面这段 C 语言代码,你就能够更好的理解 this 指针了。
在C语言中,数据和方法分离,方法必须要传结构体指针,指向调用该方法的结构体对象,这样才能在方法中访问这个对象中的数据。
// c struct Student { char _name[10]; // 数据 int _age; }; // 思考:为什么这里必须传结构体指针呢? void SetStudentInfo(struct Student* ps, const char* name, int age) { strcpy(ps->_name, name); // p类比cpp的this-> ps->_age = age; }int main() { Student s; s.SetStudentInfo(&s, "winter", 20); }

8.2 this 指针的特性
  1. this 指针的类型:类类型* const this,是一个常量指针,所以 this 指针的指向是不能更改的。
  2. 只能在 “ 非静态的成员函数 ” 的内部使用,静态成员函数是没有 this 指针的。
  3. this 指针本质上其实是一个成员函数的形参,是对象调用成员函数时,将对象地址作为实参传递给 this 形参。所以对象中不存储 this 指针。
  4. this 指针是成员函数第一个隐含的指针形参(VS中一般由编译器通过 ecx 寄存器自动传递),不需要用户传递。
面试题
① this 指针是存在哪里的?(栈 / 堆 / 静态区 / 常量区)
常犯的错误:this 指针是存在对象里面的。
this 指针是形参,形参和函数中的局部变量都是存在函数栈帧里面的,所以 this 指针可以认为是存在栈中的。
注:VS下为了提高效率,this 指针是通过寄存器 ecx 传递的,如图:
C++|【C++】类和对象(一)
文章图片
拓展:去 Linux 中验证 gcc 下,this 指针是存在哪里的?
② this 指针可以为空吗?
请看下面这两道题:
  1. 下面程序的运行结果是什么? A. 编不译通过;B. 运行崩溃;C. 正常运行
    class A { public: void Show() { cout << "Show()" << endl; }private: int _a; }; int main() { A* p = nullptr; p->Show(); }

    答案解析:正常运行
    成员函数的地址不存在对象中,存在公共代码段,那么这里调用成员函数,会去 call 函数的地址,不会去访问 p 指向的空间,也就不存在空指针解引用了。这里是把 p 传递给 Show 函数隐含的 this 指针形参,而 Show 函数中也没有对 this 指针解引用,所以正常运行。
    补充:
    A a; A* p = &a; // p指向对象ap->_a; // 这里是在p指向的空间上(即对象a的空间)访问(对象a的)成员_a,是一个解引用行为 p->Show(); // 这里只是把p(对象a的地址)传递给Show函数隐含的this指针形参,没有解引用

  1. 下面程序的运行结果是什么? A. 编不译通过;B. 运行崩溃;C. 正常运行
    class A { public: void PrintA() { cout << _a << endl; }private: int _a; }; int main() { A* p = nullptr; p->PrintA(); }

    答案解析:运行崩溃
    因为函数中的 this->_a,要访问对象的成员变量 _a,需要对 this 指针解引用,才能访问到对象中的数据,而传入的对象地址是 nullptr,所以 this 指针也是 nullptr,所以崩溃了。

    推荐阅读