C++：类和对象（从底层编译开始）详解[前篇]

目录
一.inline内联的详细介绍
（1）为什么在调用内联函数时不需要建立栈帧：
（2）为什么inline声明和定义分离到两个文件会产生链接错误，链接是什么，为什么没有函数地址：
二.类，实例化和this指针
1.类的介绍（class）：
2.实例化：
（1）实例化的概念：
（2）实例化的空间分配：
3.this指针：
4.关于空指针访问成员变量的留意点：
三.类的默认成员函数
1.构造函数：
2.析构函数：
3.拷贝构造函数：
4.运算符重载:
四.日期类实现

一.inline内联的详细介绍

为了更清楚的明确类的定义与底层运行逻辑，我先从inline内联开始讲起：
   • ⽤inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，就可以进步服从 //（1）为什么不需要建立栈帧
  • inline对于编译器⽽⾔只是⼀个建议，也就是说，你加了inline编译器也可以选择在调⽤的地方不展开，不同编译器关于inline什么情况展开各不相同，由于C++标准没有规定，inline实用于频繁调⽤的短⼩函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略(由于内联的展开在需要频繁调用短小函数的代码里，可以大限度上减少函数调用指令（call）的利用，而在其他函数体自己较大的情况下，inline不展开的调用指令的方法可能会显得更为轻便) 
  • C语言实现宏函数也会在预处置惩罚时替换展开，但是宏函数实现很复杂很轻易出错的，且不⽅便调 试，C++设计了inline⽬的就是替代C的宏函数
  • vs编译器debug版本下⾯默认是不展开inline的，这样方便调试
  • inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。由于inline被展开，就没有函数地址，链接时会出现报错//（2）为什么会产生链接错误，链接是什么，为什么没有函数地址
  （内联的利用示例）

1. #include <iostream>
3. // 显式声明为内联函数
4. inline int add(int a, int b) {
5.     return a + b;
6. }
8. int main() {
9.     std::cout << add(3, 5) << std::endl; // 编译器可能将 add(3,5) 展开为 `3 + 5`
10.     return 0;
11. }

复制代码

上述的阐述乍看总有种似懂非懂的感觉，但一旦深入想想就另有好些东西不明不白，下面我将对这段话中可能会产生的疑问做出一一解答：
   （1）为什么在调用内联函数时不需要建立栈帧：

  
  (a).在理解这个题目之前，我们需要先搞明确函数的栈帧是怎么一回事：
         简而言之栈帧是程序执行过程中用于生存函数调用状态的暂时数据结构，它在函数调用时被创建，返回时销毁。每个栈帧对应一次函数调用，记载了函数的执行上下文信息
  以下这张图片就展示了函数Add在调用时所创建的栈帧，而其中的push等相关汇编命令我也附在下面：
          

  (b).再让我们区别以下函数的栈帧与团体代码的编译和链接的关系：
  
  

  据上述代码编译的过程而言，函数栈帧的创建属于程序运行时的动态数据结构，虽与编译链接过程的静态代码无关，但编译与链接仍旧会在其运行时对其产生影响：如编译阶段为栈帧的创建和销毁天生正确的指令，以及链接阶段确定函数的位置以及符号引用，因此，一样平常情况下较小的函数被inline展开时，其函数名并不会进入符号表，而是直接在调用处替换代码（发生在预处置惩罚中，编译之前），天然也就跟栈帧的创建销毁没啥关系了
    （2）为什么inline声明和定义分离到两个文件会产生链接错误，链接是什么，为什么没有函数地址：

    
  inline之以是不建议声明定义分离，是由于当我们假设在head.h头文件里定义了内联函数add（自定义函数名）然后分别在a.cpp里定义add函数然后在b.cpp里调用add函数然后运行，那么在对程序进行编译时，会发现对于add函数头文件里只有声明而没有定义，因此编译器会假设add为一个外部函数（这里雷同于一样平常函数的跨文件调用），但与一样平常函数调用不同的是，一样平常函数在假设外部函数时会同时在符号表天生一个对函数的引用（包罗了未剖析的地址），然后再在链接过程中通过对各文件的链接重新补全符号表里未剖析的地址，从而实现函数声明定义的分开，但inline函数却不一样，它同样会在符号表里天生一个未剖析的地址，但由于inline函数的性质就是对函数体代码的团体替换从而实现对指令代码的节约利用，而且需要明确的内联点才可以进行替换，因此这样导致了其无法在链接时找到对应的内联点进而不能像一样平常函数那样在链接过程中补全对应的符号表里未剖析的地址（内联需要替换的代码都找不到更别说地址了），从而发生链接的报错
  
二.类，实例化和this指针

1.类的介绍（class）：

   其中有两点需要特别留意：
  （a） 类中的成员函数默以为内联
  （b）关于访问限定符：
  如下代码：public和private是访问限定符，在public背面的成员函数和成员变量可以直接在类的外部利用，private背面的成员函数和成员变量不能被直接利用。       
          通常我们把成员函数定义为public，把成员变量定义为private

1. #include<iostream>
2. using namespace std;
3. class TEST
4. {
5. public:
6.         //成员函数
7.         void test()
8.         {
9.                 return;
10.         }
11. private:
12.         //成员变量
13.         int _a;
14.         int _b;
15. };
16. //以上class为类的关键字，TEST为类的名字，{}中的为类的主体
18. //但同样的，C++由于相当于C的pro max版，同时也可以兼容C中的struct结构：
19. typedef struct ListNodeC
20. {
21.         struct ListNodeC* next;
22.         int val;
23. }LTNode;
25. int main()
26. {
27.         return 0;
28. }

复制代码

关于类域：

1. #include<iostream>
2. using namespace std;
4. class TEST
5. {
6. public:
7.         //成员函数声明
8.         int test(int a, int b);
10. private:
11.         //成员变量
12.         int _a;
13.         int _b;
14. };
15. //类定义了一个新的作用域，类的所有成员函数都在类的作用域中。在类体外定义成员时，需要使用类域名：：来访问成员
16. //如果不指定类域的话，在定义函数时，程序在全局域找不到函数的声明就会报错。编译器不会主动去类域中寻找函数定义
17. int TEST::test(int a, int b)
18. {
19.         return a + b;
20. }
21. int main()
22. {
23.         TEST A;
25.         int c = 10; int d = 20;
26.         cout << A.test(c, d) << endl;
27.         return 0;
28. }

复制代码

2.实例化：

（1）实例化的概念：

（2）实例化的空间分配：

    对象的大小只包罗成员变量的大小，成员函数不占内存空间
  
  打个比方，如今实例化出了两个类，分别为A，B但A和B的成员变量和地址是不同的，但如果访问这两个类的成员函数，他们都会链接到一个地址（只读存储区，静态存储），以是说我们sizeof（类对象）只用统计成员变量占用的空间
   成员变量占用的空间也符合内存对齐规则：
  关于这个对齐实在有点比较轻易遗忘，因此我再简述一下：
  1. 基本概念
 对齐：数据范例的起始地址必须是该范例大小的整数倍
 例如： int （4字节）的地址必须是  0x4, 0x8, 0xC... 
 未对齐：数据起始地址不满意对齐规则，可能导致性能降落或硬件错误（如 ARM 架构）
2. 内存对齐规则
 a. 天然对齐
 规则：每个数据范例的地址必须是其自身大小的整数倍
 示例：

1. struct AlignedStruct {
2.     char a;        // 1字节 → 地址 0x0
3.     int b;        // 4字节 → 地址 0x4（填充3字节）
4.     double c;     // 8字节 → 地址 0x8（填充7字节）
5. };

复制代码

b. 结构体对齐
成员顺序：成员按声明顺序排列，每个成员按天然对齐对齐
  举例：

1. ​
2. struct CompactStruct {
3.     int a;       // 0x0
4.     char b;      // 0x4（填充3字节）
5.     short c;     // 0x8
6. }; // 总大小：12字节（而非 16字节）
8. ​

复制代码

  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指针
   别的需要留意一点，this指针实在存放在栈区，而不是对象内里

1. #include<iostream>
2. using namespace std;
3. class Date
4. {
5. public:
6.         // void Init(Date* const this, int year, int month, int day)
7.         void Init(int year, int month, int day)
8.         {
9.                 // this->_year = year;
10.                 _year = year;
11.                 this->_month = month;
12.                 this->_day = day;
13.         }
14.         void Print()
15.                  {
16.                 cout << _year << "/" << _month << "/" << _day << endl;
17.         }
18. private:
19.         // 这⾥只是声明，没有开空间
20.         int _year;
21.         int _month;
22.         int _day;
23. };
25. int main()
26. {
27.         Date A;
28.        
29.         return 0;
30. }
33. //成员函数在传参时都有一个类的指针类型的this指针，这个this指针编译器不会显示出来，但实际上他是存在的，看上边这串代码，如果再函数调用赋值的时候，可以手动把this指针加上去，这样其实并不会报错。这就说明这个this指针是真实存在的

复制代码

4.关于空指针访问成员变量的留意点：

   先看一下下面这两个代码：
  

         这两串代码运行的结果并不相同，已知第一个是正常运行，第二个是运行崩溃，起首我们应该知道不管是C语言中照旧C++中，解引用空指针并不会编译报错，只会运行崩溃
  其次再来分析问什么第二个是运行崩溃
          起首成员函数不会占用物理内存，只有成员变量会，实例出nullptr说明没开空间，但仔细看第一个程序是不需要访问成员变量的，以是不开空间也没有报错，而第二个程序访问了开空间的成员变量：_a，以是运行崩溃了
  
三.类的默认成员函数

   默认成员函数就是⽤⼾没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数：
  

  接下来我会对其中的几个做出详细介绍：
  1.构造函数：

          构造函数也是一种成员函数，但他和我们写的普通构造函数不同的是，他是在我们实例化类的对象是默认调用的，也就是说，实例化对象是他自己会去主动调用这个构造函数，其本质是要替代我们从前Stack和Date类中写的Init函数的功能，构造函数⾃动调⽤的 特点就完美的替代的了Init
  接下来说说它的基本特点：
  函数名和类名相同；
  没有返回值：

1. #include<iostream>
2. using namespace std;
3. class DATE
4. {
5. public:
6.         DATE(int year = 2000, int mouth = 11, int day = 1)
7.         {
8.                 _year = year;
9.                 _mouth = mouth;
10.                 _day = day;
11.         }
12. private:
13.         //成员函数
14.         //private成员函数不能直接访问，可以通过成员函数访问
15.         int _year;
16.         int _mouth;
17.         int _day;
18. };
19. int main()
20. {
21.     DATE d1;
22.     return 0;
23. }
25. //上面这串代码中定义了一个日期类，并实例化出一个对象d1，调试可以看到，实例化d1自动调用了DATE这个构造函数，给d1的三个成员变量进行了赋值
27. //构造函数也有很多种，第一种无参构造函数。第二种是全缺省构造函数，第三种就是不写构造时编译器默认的构造函数（接下来我会具体说说这三种函数），如果我们在实例化的时候只写这个对象就像上面这串代码这样：DATE d1; 这样调用的构造函数叫默认构造

复制代码

       

1. //无参构造函数
2. DATE()
3. {
4.         _year = 1;
5.         _mouth = 1;
6.         _day = 1;
7. }
9. //全缺省构造函数
10. DATE(int year = 2000, int mouth = 11, int day = 1)
11. {
12.         _year = year;
13.         _mouth = mouth;
14.         _day = day;
15. }
17. // 带参构造函数
18. Date(int year, int month, int day)
19. {
20.         _year = year;
21.         _month = month;
22.         _day = day;
23. }

复制代码

       除了以上几点另有一点需要额外留意：如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦用户显式定义编译器将不再⽣成，也就是说我们不写，编译器默认⽣成的构造，对内置范例成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。对于⾃定义范例成员变量，要求调⽤这个成员变量的默认构造函数初始化，  如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤初始化列表才气解决，初始化列表的题目，本文先放一下，下一篇文章再作详细介绍
         读到这里，会发现一个题目就是既然系统会自动天生默认构造函数，那为什么我们还需要自己去写构造函数？举个例子：
  当类需要动态分配内存（如 new  或 malloc ）时，默认构造函数无法自动释放资源，必须手动管理:

1. class Buffer {
2. public:
3.     int* data; // 动态内存
5.     // 自定义构造函数：初始化 data
6.     Buffer(int size) : data(new int[size]) {
7.         std::cout << "Buffer initialized with size " << size << std::endl;
8.     }
10.     // 析构函数：释放资源
11.     ~Buffer() {
12.         delete[] data;
13.         std::cout << "Buffer destroyed" << std::endl;
14.     }
15. };
17. int main() {
18.     Buffer buf(1024); // 调用自定义构造函数
19.     return 0;
20. }

复制代码

默认构造函数不会初始化 data ，导致未定义举动（如悬空指针）,自定义构造函数确保 data 正确分配内存
  
  2.析构函数：

          析构函数可以在类对象销毁时自动调用，释放我们的内存空间。就比如之前实现的栈这个数据结构，我们需要把我们malloc出来的空间都free掉，那么这个时候如果是利用c++内里的类来完成的话，在我们的栈销毁时（该对象生命周期结束时）就可以自动调用析构函数，释放内存

2. ~Stack()
3. {
4.         cout << "~Stack()" << endl;
5.         free(_a);
6.         _a = nullptr;
7.         _top = _capacity = 0;
8. }

复制代码

析构的特点也很显着：
  1. 析构函数名是在类名前加上字符~
  2.不需要写返回值
  3.和构造函数一样，我们不写编译器⾃动⽣成的析构函数对内置范例成员不做处置惩罚，⾃定范例成员会调⽤他的析构函数
  4.一个类只有一个析构且当类成员不需要释放空间时，不需要自己写析构函数

1. #include<iostream>
2. using namespace std;
3. typedef int STDataType;
4. class Stack
5. {
6. public:
7.         Stack(int n = 4)
8.         {
9.                 _a = (STDataType*)malloc(sizeof(STDataType) * n);
10.                 if (nullptr == _a)
11.                 {
12.                         perror("malloc申请空间失败");
13.                         return;
14.                 }
15.                 _capacity = n;
16.                 _top = 0;
17.         }
18.         ~Stack()
19.         {
20.                 cout << "~Stack()" << endl;
21.                 free(_a);
22.                 _a = nullptr;
23.                 _top = _capacity = 0;
24.         }
25. private:
26.         STDataType* _a;
27.         size_t _capacity;
28.         size_t _top;
29. };

复制代码

3.拷贝构造函数：

   如果⼀个构造函数的第⼀个参数是⾃⾝类范例的引⽤，且任何额外的参数都有默认值，则此构造函数 也叫做拷贝构造函数，也就是说拷贝构造是⼀个特殊的构造函数

1. #include<iostream>
2. using namespace std;
4. class DATE
5. {
6. public:
7.         DATE(int year, int mouth, int day)
8.         {
9.                 _year = year;
10.                 _mouth = mouth;
11.                 _day = day;
12.         }
13.         void Print()
14.         {
15.                 cout << _year << "年" << _mouth << "月" << _day << "日" << endl;
16.         }
17. private:
18.         //成员函数
19.         //private成员函数不能直接访问，可以通过成员函数访问
20.         int _year;
21.         int _mouth;
22.         int _day;
23. };
24. int main()
25. {
26.         DATE d1(10,10,10);
27.         DATE d2(d1);//调用拷贝构造
28.         d1.Print();
29.         d2.Print();
30.         return 0;
31. }
32. //注意，第一个参数必须是引用。否则编译器会报错。为什么会报错呢？理解一下，如果说我们传入的第一个参数没有引用，那么这个形参是得拷贝一份我们的实参，怎么拷贝呢？他还是得调用我们的拷贝构造函数去拷贝，那这就形成了闭环，而这样无限拷贝下去编译器是不允许的
34. //对于没有主动写拷贝构造的类，编译器也会默认生成一个拷贝构造，对于内置类型进行浅拷贝，也就是只拷贝值，对于自定义类型成员会调用他的拷贝构造。

复制代码

但另有几点需要留意：
  1.像Date这样的类成员变量全是内置范例且没有指向什么资源，编译器⾃动⽣成的拷⻉构作育可以完 成需要的拷⻉，以是不需要我们显⽰实现拷⻉构造，但像Stack这样的类，固然也都是内置范例，但 是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，以是需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)，像MyQueue这样的范例内部重要是⾃定义范例 Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现 MyQueue的拷⻉构造（前提是Stack这个类有析构）
  2.传值返回会产⽣⼀个暂时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤ 引⽤返回是有题目的，这时的引⽤相称于⼀个野引⽤，雷同⼀个野指针⼀样。传引⽤返回可以减少拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才气⽤引⽤返回
  4.运算符重载:

   运算符重载简而言之就是赋予我们常见的运算符以新的定义与利用场景，比如+号原来只可以用于数字之间的运算，但颠末运算符重载之后，使其可以进行日期之间的计算，诸如此类：

1. bool operator==(DATE x)
2. {
3.         return _year == x._year && _mouth == x._mouth && _day == x._day;
4. }

复制代码

以下是几个留意点：
  1.不能对c++没有的符号进行重载
  2、以下五个运算符不能进行重载：
  .*      ::      sizeof       ? :       .
  3.运算符重载的参数列表至少要含有一个自定义范例，不能通过运算符重载改变内置范例对象的含义，如： int operator+(int x, int y)
  4.重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。 C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，方便区分
  四.日期类实现

1. //Date.h
2. #pragma once
3. #pragma once
4. #include<iostream>
5. #include<assert.h>
6. using namespace std;
7. class DATE
8. {
9. public:
10.         DATE(int year = 2000, int mouth = 11, int day = 1)
11.         {
12.                 _year = year;
13.                 _mouth = mouth;
14.                 _day = day;
15.         }
16.         //短小多次调用函数使用inline
17.         //clase默认inline
18.         int GetMouthDay(int year, int mouth)
19.         {
20.                 assert(mouth > 0 && mouth < 13);
21.                 static int mouthDayArray[13] = { -1,31,28,31,30,31,30,31,31,30,31,30,31 };//多次访问直接定义静态数组
23.                 if (mouth == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))//让容易不通过的条件放前面
24.                 {
25.                         return 29;
26.                 }
27.                 else return mouthDayArray[mouth];
28.         }
29.         DATE& operator+=(int day);//声明运算符重载
30.         DATE& operator+(int day);
31.         void Print()
32.         {
33.                 cout << _year << "年" << _mouth << "月" << _day << "日" << endl;
34.         }
35.         //日期比较
36.         bool operator>(DATE x)
37.         {
38.                 if (_year > x._year) return true;
39.                 else if (_year < x._year) return false;
41.                 if (_mouth > x._mouth) return true;
42.                 else if (_mouth < x._mouth) return false;
44.                 if (_day > x._day) return true;
45.                 else return false;
46.         }
47.         bool operator==(DATE x)
48.         {
49.                 return _year == x._year && _mouth == x._mouth && _day == x._day;
50.         }
51.         bool operator < (DATE x)
52.         {
53.                 return !(*this > x) && !(*this == x);
54.         }
55.         bool operator!=(DATE& d2)
56.         {
57.                 return !(*this == d2);
58.         }
59.         DATE operator++(int)
60.         {
61.                 //后置加加返回原值
62.                 //注意这个临时变量出了这个函数就销毁了所以不能引用返回
63.                 DATE tmp(*this);
64.                 _day++;
65.                 if (_day > GetMouthDay(_year, _mouth))
66.                 {
67.                         _day = 1; _mouth++;
68.                 }
69.                 if (_mouth > 12)
70.                 {
71.                         _year++;
72.                         _mouth = 1;
73.                 }
74.                 return tmp;
75.         }
76.         //两日期相减
77.         int operator-(DATE& d1);
78. private:
79.         //成员函数
80.         //private成员函数不能直接访问，可以通过成员函数访问
81.         int _year;
82.         int _mouth;
83.         int _day;
84. };

复制代码

1. //text.cpp
3. #include"DATE.h"
5. DATE& DATE::operator+=(int day)//表明所属类
6. {
7.         //由于更改了自身所以重载的是+=
8.         //引用返回可以避免拷贝，节省开销
9.         //不能返回空值，不然无法解决这种问题（a+=10）+=10
10.         //对于这种情况如果传dATE返回的话也无法改变原值，不符合预期。
11.         _day += day;
13.         while (_day > GetMouthDay(_year, _mouth))
14.         {
15.                 _day -= GetMouthDay(_year, _mouth);
16.                 ++_mouth;
17.                 if (_mouth == 13)
18.                 {
19.                         _year++;
20.                         _mouth = 1;
21.                 }
22.         }
23.         return *this;
24. }
25. DATE& DATE::operator+(int day)
26. {
27.         //DATE tmp(*this);//拷贝
28.         //默认构造函数
29.         DATE tmp = *this;///同样也是调用默认构造函数
30.         tmp += day;
32.         return tmp;
33. }
34. int DATE::operator-(DATE& d1)
35. {
36.         int cnt = 0;
37.         int flag = 1;
38.         DATE max = *this;
39.         DATE min = d1;
40.         if (max < min)
41.         {
42.                 flag = -1;
43.                 max = d1;
44.                 min = *this;
45.         }
46.         while (max != min)
47.         {
48.                 cnt++;
49.                 min++;
50.         }
51.         return cnt * flag;
52. }

复制代码

以上就是关于日期类相关的函数代码了
欧克，时间也不晚了，就到这里吧
全文终


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