C++之类与对象（1）

目次

媒介
1.类的定义
1.1类定义的格式
1.2访问限定符
1.3类域
1.3.1类定义一个作用域
1.3.2类成员在类的作用域中
1.3.3在类体外定义成员
2.实例化
2.1实例化概念
2.2对象巨细
3.this指针
4.选择题补充练习
结束语

---

媒介

   Hello，友友们，好久不见啦，前面将C++的根本知识相识了一下，本日将学习C++的另一知识，类与对象的学习，学习起来稍有难度哦！！！
  1.类的定义

类（Class）
   类是一个抽象的概念，它定义了一组具有雷同属性（attribute）和方法（method）的对象的模板。类为创建对象提供了蓝图。在类中，你可以定义以下内容：
  

• 属性（Attributes）：变量，用于存储数据。属性可以是类的属性（全部对象共享）或实例属性（每个对象有自己的副本）。
  
• 方法（Methods）：函数，用于定义可执行的操纵。方法通常与类的属性交互。
  

  1.1类定义的格式

      • class为定义类的关键字，Stack为类的名字，{}中为类的主体，留意类定义结束时背面分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法大概成员函数。       • 为了区分成员变量，一般风俗上成员变量会加一个特别标识，如成员变量前面大概背面加_ 大概 m开头，留意C++中这个并不是逼迫的，只是一些惯例。      

1. #include <iostream>
2. using namespace std;
3. class Date{
4. public:
5.         void print(int year, int month, int day) {
6.                 _year = year;
7.                 _month = month;
8.                 _day = day;
9.                 cout << _year << " " << _month << " " << _day << endl;
10.                 //cout << year << " " << month << " " << day << endl;
11.         }
12. private:
13.         // 为了区分成员变量，⼀般习惯上成员变量
14. // 会加⼀个特殊标识，如_ 或者 m开头
15.         int _year; // year_ m_year
16.         int _month;
17.         int _day;
19. };
20. int main() {
21.         Date date;
22.         date.print(2024, 7, 18);
23.         return 0;
24. }

复制代码

  

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

1. #include<iostream>
2. using namespace std;
3. // C++升级struct升级成了类
4. // 1、类⾥⾯可以定义函数
5. // 2、struct名称就可以代表类型
6. // C++兼容C中struct的⽤法
7. typedef struct ListNodeC
8. {
9.         struct ListNodeC* next;
10.         int val;
11. }LTNode;
12. // 不再需要typedef，ListNodeCPP就可以代表类型
13. struct ListNodeCPP
14. {
15.         void Init(int x)
16.         {
17.                 next = nullptr;
18.                 val = x;
19.         }
20.         ListNodeCPP* next;
21.         int val;
22. };
23. int main() {
24.         return 0;
25. }

复制代码

   • 定义在类面的成员函数默以为inline。   1.2访问限定符

            • C++一种实现封装的方式，用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户利用。             • public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访          问，protected和private是一样的，以后继承章节才气表现出他们的区别。             • 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止，如果背面没有访问限定符，作用域就到 }即类结束。             • class定义成员没有被访问限定符修饰时默以为private，struct默以为public。             • 一般成员变量都会被限制为private/protected，需要给别人利用的成员函数会放为public。           1.3类域

       在C++中，每个类定义了自己的作用域。这意味着类的成员（包括数据成员和成员函数）都存在于类的作用域内。当你想要在类的外部引用类的成员时，你需要利用类的作用域剖析运算符 `::` 来指明特定的成员属于哪个类。
 
   1.3.1类定义一个作用域
   当你定义一个类时，你就创建了一个新的作用域。在这个作用域内，你可以定义变量（数据成员）和函数（成员函数）。
   1.3.2类成员在类的作用域中
   全部在类定义内部声明的成员都属于该类的作用域。例如：
  

1. class MyClass {
2. public:
3.     void myFunction();
4.     int myValue;
5. };

复制代码

  
在这里，myFunction 和 myValue都是在 MyClass 的作用域中。
   1.3.3在类体外定义成员
   当需要在类的外部定义成员函数时，需要利用类名和作用域剖析运算符 `::` 来指定该函数属于哪个类的作用域。
  

1. class MyClass {
2. public:
3.     void myFunction();  // 成员函数声明
4.     int myValue;        // 数据成员声明
5. };
6. // 在类体外定义成员函数
7. void MyClass::myFunction() {
8.     // 函数实现
9.     myValue = 10;  // 直接使用类成员
10. }

复制代码

  在上面的例子中，myFunction 的定义在类 MyClass 的外部。为了指明 myFunction是 MyClass 的成员，我们利用了 MyClass::。
   
  

1. MyClass obj;
2. obj.myFunction();  // 调用成员函数
3. int value = obj.myValue;  // 访问数据成员

复制代码

  2.实例化

   2.1实例化概念

       • 用类类型在物理内存中创建对象的过程，称为类实例化出对象。             • 类是对象进行一种抽象描述，是一个模型一样的东西，限定了类有哪些成员变量，这些成员变量    只是声明，没有分配空间，用类实例化出对象时，才会分配空间。             • 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。打个比方：类实例化出对象就像实际中利用建筑设计图制作出房子，类就像是设计图，设计图规划了有多少个房间，房间巨细功能等，但是并没有实体的建筑存在，也不能住人，用设计图修建出房子，房子才气住人。同样类就像设计图一样，不能存储数据，实例化出的对象分配物理内存存储数据。      

1. #include<iostream>
2. using namespace std;
3. class Date
4. {
5. public:
6.         void Init(int year, int month, int day)
7.         {
8.                 _year = year;
9.                 _month = month;
10.                 _day = day;
11.         }
12.         void Print()
13.         {
14.                 cout << _year << "/" << _month << "/" << _day << endl;
15.         }
16. private:
17.         // 这⾥只是声明，没有开空间
18.         int _year;
19.         int _month;
20.         int _day;
21. };
22. int main()
23. {
24.         // Date类实例化出对象d1和d2
25.         Date d1;
26.         Date d2;
27.         d1.Init(2024, 7, 18);
28.         d1.Print();
29.         d2.Init(2024, 7, 19);
30.         d2.Print();
31.         return 0;

复制代码

2.2对象巨细

   分析一下类对象中哪些成员呢？类实例化出的每个对象，都有独立的数据空间，所以对象中肯定包罗 成员变量，那么成员函数是否包罗呢？起首函数被编译后是⼀段指令，对象中没办法存储，这些指令 存储在⼀个单独的区域(代码段)，那么对象中非要存储的话，只能是成员函数的指针。再分析⼀下，对象中是否有存储指针的须要呢，Date实例化d1和d2两个对象，d1和d2都有各自独立的成员变量 _year/_month/_day存储各自的数据，但是d1和d2的成员函数Init/Print指针却是一样的，存储在象 中就浪费了。如果用Date实例化100个对象，那么成员函数指针就重复存储100次，太浪费了。实在函数指针是不需要存储的，函数指针是一个地址，调用函数被编译成汇编指    令[call 地址]， 实在编译器在编译链接时，就要找到函数的地址，不是在运行时找，只有动态多态是在运行时找，就需要存储函数地址，这个以后会讲解。      

         上面分析了对象中只存储成员变量，C++规定类实例化的对象也要符合内存对齐的规则。       与结构体内存对齐计算一样。      
以下是C++中内存对齐的一些根本规则：             1. 默认对齐方式：每个数据类型的自然对齐方式通常是该类型的巨细。例如，`int` 类型通常在4字节边界上对齐，`double` 类型通常在8字节边界上对齐。             2. 结构体和类的对齐：结构体和类的成员按照其类型的自然对齐方式对齐。结构体或类的团体巨细也必须符合其最大成员类型的对齐要求。             3. 成员对齐：结构体或类的成员按照声明次序进行排列，每个成员按其类型的对齐方式放置。             4. 填充（Padding）：为了满足对齐要求，编译器可能会在成员之间插入填充字节。             5. #pragma pack：可以通过`#pragma pack`指令来改变或设置编译器的默认对齐方式。            

       下面是一个例子，展示了一个结构体和一个类的对齐情况：      

1. struct MyStruct {
2.     char a;    // 1 byte
3.     int b;     // 4 bytes
4.     char c;    // 1 byte
5. };
7. class MyClass {
8. public:
9.     char a;    // 1 byte
10.     int b;     // 4 bytes
11.     char c;    // 1 byte
12. };
14. // 假设默认对齐方式为4字节

复制代码

  
在这个例子中，`MyStruct`和`MyClass`的对齐方式是一样的。成员`a`和`c`之间会有3个填充字节，以确保`b`在4字节边界上对齐。因此，`MyStruct`和`MyClass`的巨细将是12字节，而不是简单的7字节（1+4+1+3填充字节）。
       总之，无论是结构体还是类，它们的对象在内存中的结构都遵循雷同的对齐规则。在C++中，`struct`和`class`关键字在内存结构方面几乎没有区别，主要区别在于成员的默认访问权限（`struct`的成员默以为`public`，而`class`的成员默以为`private`）。
 
           

1. #include<iostream>
2. using namespace std;
3. // 计算⼀下A/B/C实例化的对象是多⼤？
4. class A
5. {
6. public:
7.         void Print()
8.         {
9.                 cout << _ch << endl;
10.         }
11. private:
12.         char _ch;
13.         int _i;
14. };
15. class B
16. {
17. public:
18.         void Print()
19.         {
20.                 //...
21.         }
22. };
23. class C
24. {};
25. int main()
26. {
27.         A a;
28.         B b;
29.         C c;
30.         cout << sizeof(a) << endl;
31.     cout << sizeof(b) << endl;
32.         cout << sizeof(c) << endl;
33.         return 0;
34. }

复制代码

        

               上述步调中没有成员变量的B和C类对象的巨细是1，为什么没有成员变量还要给1个 字节呢？    由于如果一个字节都不给，怎么表示对象存在过呢！所以这里给1字节，纯粹是为了占位标识对象存在。            3.this指针

            • 在上述代码中Date类中有 Init 与 Print 两个成员函数，函数体中没有关于差别对象的区分，那当d1调用Init和 Print函数时，该函数是怎样知道应该访问的是d1对象还是d2对象呢？那么这里就要看到C++给了一个隐含的this指针办理这里的题目                 • 编译器编译后，类的成员函数默认都会在形参第一个位置，增加一个当前类类型的指针，叫做this 指针。比如Date类的Init的真实原型为， void Init(Date* const this, int year, int month, int day)                 • 类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this-             >_year = year;                 •     C++规定不能在实参和形参的位置显示的写this指针(编译时编译器会处理)，但是可以在函数体内显示利用this指针。             

1. class Date
2. {
3. public:
4.         //void Init(Date*const this,int year, int month, int day)
5.         void Init(int year, int month, int day)
6.         {
7.                 this->_year = year;
8.                 this->_month = month;
9.                 this->_day = day;
10.         }
11.         //void Print(Date*const this)
12.         void Print()
13.         {
14.                 cout <<this-> _year << "/" << this->_month << "/" <<this-> _day << endl;
15.         }
16. private:
17.         // 这⾥只是声明，没有开空间
18.         int _year;
19.         int _month;
20.         int _day;
21. };

复制代码

    实际上建议不加this，这里只是相识一下。
                 

           
4.选择题补充练习

   1.下面步调编译运行结果是（C）    A、编译报错 B、运行崩溃 C、正常运行       #include<iostream>       using namespace std;       class A {       public:       void Print(){       cout << "A:rint()" << endl;       }       private:       int _a;       };       int main() {       A* p = nullptr;       p->rint();       return 0;       }         2.下面步调编译运行结果是（B）       A、编译报错 B、运行崩溃 C、正常运行           #include<iostream>          using namespace std;          class A {          public:          void Print()          {          cout << "A:rint()" << endl;          cout << _a << endl;          }          private:          int _a;          };          int main()          {          A* p = nullptr;          p->rint();          return 0;          }       虽然这个步调可能会在一些编译器上成功编译（取决于编译器的设置和版本），但是当实验运行时，它会崩溃。这是由于你试图通过一个空指针p调用成员函数Print，并且在Print函数内部，你实验访问私有成员变量_a。
在C++中，实验解引用空指针是未定义行为，这意味着步调可能会以任何方式失败。通常情况下，这会导致步调崩溃，由于操纵系统会检测到无效的内存访问并停止步调。
   3. this指针存在内存哪个区的 (A)    A. 栈 B.堆 C.静态区 D.常量区 E.对象内里      在C++中，每当成员函数被调用时，this指针作为隐含的参数传递给函数。这个指针指向调用该函数的对象，其值是对象在内存中的地址。由于this指针是在函数调用时创建的，并且随着函数调用的结束而销毁，因此它通常存储在栈上。  
结束语

   本节内容就到此结束啦，谢谢各位友友的阅读，支持小编的点个赞吧，欢迎大家在评论区留言讨论！！！
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。