唯有奋力奔跑，才能方得始终。

一、struct ==> class(类 = 方法/成员函数 + 属性/成员变量)

a. 在C语言阶段我们就已经认识到了结构体，它可以帮助我们实现多种数据结构，功能强大不言而喻。在C++中为了更好的封装，以及更好的将现实生活抽象化为计算机世界，采用面向对象的思想帮助程序猿能够对用户需求进行抽象思维化，不得不需要类class的出现。

1.自定义类型 struct 和 class 的区别

C语言中的struct只能定义变量，但C++中的struct不仅可以定义变量也可以定义函数，他和class关键字的作用是相同的，都可以定义类，当然这是C++为了兼容C语言对struct做出的改变，所以struct所定义的类的成员默认是公有的，就是无论谁都可以使用，因为在C语言中我们是可以直接获取到结构体里面的所有数据的。

而class定义的类的成员默认是私有的，类内不被限制，类外不可以直接获取到类中的变量，也就是类中的数据,这也正是面向对象语言的一大特性，封装，你只能通过类中的函数来访问数据，不可以直接访问到类里面的数据。

//class Stack
struct Stack
{
  //类体，由成员函数和成员变量组成
  void Init(int N = 4)
  {
    top = 0;
    capacity = 0;// 访问限定符限制的是类外面的，类里面不会被限制
  }
  void Push(int x)
  {
  }
  int* array;
  int top;
  int capacity;//C++把类看作一个整体，编译器搜索的时候会在整个类里面去搜索。C语言为了编译的效率只会向上搜索。
};//不要丢掉分号
int main()
{
  Stack st;// 用类stack实例化出对象st
  st.top = 0;//这里的语句，在class类会被限制 struct类不会被限制
}

2.类放在内存中的什么存储区？

a. 首先大家要知道，类只是一个抽象的描述，对象才是一个具体的东西，就像int，double，char等类型，他们也只是一个描述，他们所定义出来的变量才是具体的东西，所以程序中是不存在类这样的东西的，因为它不是具体化的东西，自然类是不占用内存的。

b. 类的描述信息，程序在编译的时候只要其语义，运行时是不需要他的，因为到运行阶段的时候，代码都已经转换为二进制指令了，二进制指令命令电脑去做对象与对象之间的交互，哪还有类这样的概念。当然如果要用类中的成员函数，成员函数是在代码段的，所以光对于类来说，他仅仅是方便程序猿写程序的一个抽象化描述

c. 在C++的程序中，编译链接之后的指令，宏观角度来说，其实是对象之间利用接口进行交互以及单个对象和接口之间的交互，这种宏观的概念里面哪还有类啊，只要编译器了解类的语义之后，类就没用了，所以根本没有必要分配给它内存

3.类中函数的两种定义方式

3.1 声明和定义分离（增强代码可读性，强烈推荐）

a. 声明和定义分离的话，那函数就会被当作正常函数对待，在调用的地方建立函数栈帧，分配堆栈的空间。

b. 函数定义时的函数名前要加上类域名

//使用时，要指定类域
class Person
{
public:
  void PrintPersonInfo();
private:
  char _name[20];
  char _gender[3];
  int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
  cout << _name << " " << _gender << " " << _age << endl;
}

3.2 声明和定义一起（隐式内联函数）

内联方面的知识：

如果声明和定义都放在类里面，函数会向编译器发出内联请求，是否同意这取决于编译器，这个知识了解一下就好。

4.类中变量的声明方式

推荐加下划线的方式来声明成员变量

class Person
{
public:
  void PrintPersonInfo();
private:
  char _name[20];
  char _gender[3];
  int  _age;
};

二、类的访问限定符+封装

1.访问限定符

a. 访问限定符分为public private protected，现阶段我们只要会用public和private就可以。

b. public修饰的成员公开对外，类外可之间使用，访问限定符的作用域从其出现的位置到下一个访问限定符之间的区域，下一个可以以右括号}结束作用域。

class Person
{
public:
  void PrintPersonInfo();
private:
  char _name[20];
  char _gender[3];
  int  _age;
};

c. 访问限定符只在程序编译时有用，等到程序运行阶段，没有任何访问限定符的区别，因为都已经转换为二进制指令了。

2.封装的理解

a. 封装就是将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。说白了就是将方法的实现和属性隐藏起来，只让用户和产品进行交互，隐藏实现的种种细节，方便更好的管理。

b. C++中我们实现封装其实就是通过类和访问限定符，将对象的内部实现细节隐藏起来，通过访问限定符将某些接口放开在类外部进行使用。

3.C++对于作用域的划分

局部作用域：

函数内部的区域我们称之为局部作用域，其中的变量形参等，我们都称之为局部变量，因为他们都存在于函数栈帧里面，是一个局部的区域。

类域：

类域是为了对象的更好封装，将类外和类内划分边界，利用域作用限定符，选择性的将某些功能对外开放。

全局作用域：

全局就是指，在一个工程中的不同文件之间都可以使用你所定义的全局变量或全局函数，也就是在整个程序中都可以使用，额外补充一个点，加static修饰的全局变量或全局函数，他们由之前的外部链接属性改为内部链接属性。

namespace域：

命名空间域，这个域里面可以由程序猿来放一些可能与库中函数或关键字起冲突的东东，和类一样，我们也可以选择性的放开命名空间中的功能对外开放，通过利用三种使用命名空间域的方式。

三、实例化对象模型

1.类的实例化

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

b. 类是对对象进行描述的，它可以限定类有哪些成员，但定义出一个类是不占用实际的内存空间的。

c. 我们可以利用一个类来创建多个实例化的对象

2.实例化对象的大小计算

class A
{
public:
  void PrintA()
  // 从操作系统角度来看，不可能把所有的指令都存下来，只存函数的地址，指针大小4个字节，所以大小应该是5个字节，内存对齐就是8个字节
  {
    cout << _a << endl;
  }
private:
  int _a;
};
int main()
{
  cout << sizeof(A) << endl;
}

可能会有人认为这个类A的类型大小是8字节，因为函数地址占4个字节，int占4个字节，根据结构体内存对齐原则，就是8字节。

但其实不是这样的，我们在计算过程中其实只关注了成员变量，至于函数并没有关注，这是为什么呢？这就涉及到实例化对象模型的设计了，我们往下再看看吧。

3.类对象的存储方式

a.

为了节省实例化对象所占空间，我们将每个对象的成员函数抽离出来，放在公共代码段，这样在使用函数时，每个对象只要去公共代码段里面调用就可以了，里面放着该类所有成员函数的有效地址

b.

所以在计算类类型大小的时候，我们是不关注成员函数的，因为实例化出来的对象中根本就不存储函数地址，函数地址都被放在公共代码段了，我们可以类比C语言部分的知识，C语言在算某个类型所占字节时，是不也可以算该类型创建出来的变量所占字节，由此可见我们算类类型大小，其实就是算对象的大小。

4.空类的大小

虽然这个类是空的，但是还可以创建对象不是吗？所以编译器给空类类型一个字节的空间用于标识这种特殊的类型

class A
{
};
int main()
{
  cout << sizeof(A) << endl;
}

四、隐藏的this指针

1.非静态成员函数的this指针

a.

我们知道一个成员函数是可以被多个对象所调用的，那成员函数怎么知道它现在作用的是哪个对象呢？万一有10个对象都调用同一个函数，函数只作用于第一个对象，这可怎么办啊？无法满足我们的需求啊。

b.

所以C++编译器给每个“非静态成员函数”增加了一个隐藏的this指针来作为函数的形参， 并且规定该参数必须在函数形参的最左边位置，这个指针中存储的就是对象的地址，在函数体中所有访问对象成员变量的操作都是通过this指针来完成的，只不过这些操作对于用户是透明的，用户不需要手动传递对象地址，编译器可以自动完成。

c.

我们不可以手动去传递this指针，这是编译器的工作，我们不能去抢，但是我们可以在函数体内部使用这个this指针。

class Date
{
public:
  void Init(int year, int month, int day)
  {
    _year = year;//使用this指针访问到对象的成员变量_year
    _month = month;
    _day = day;
  }
  void Print()// 在函数体内部我们可以使用this指针。
  {
    cout << this << endl;
    cout << this->_year << "-" << this->_month << "-" << _day << endl;//我们加了this，编译器就不加了，我们不加，编译器就会加
  }
private:
  int _year;     
  int _month;    
  int _day;     
};
int main()
{
  Date d1;
  d1.Init(2022, 12, 15);
  Date d2;
  d2.Init(2022, 12, 16);
  d1.Print();//d1调用，访问的就是d1的成员
  d2.Print();//d2调用，访问的就是d2的成员
  cout << &d1 << endl;
  cout << &d2 << endl;
  return 0;
}

由结果可以看到this指针的的确确就是对象的地址。

2.为什么指针形式是xxx* const this？

a.

原因很简单，对象的地址，我们是不希望修改的，因为你一旦修改，原先地址所指向的空间内容我们就无法访问到了，所以C++规定this指针是不能被修改的，隐藏的形式就需要const来修饰指针本身。

b.

有关const和指针的三种写法：

const Date* p1;

Date const* p2;

上面这两种写法都是等价的，const放在星号的左边，修饰的就是 * p1和* p2，也就是指针指向的对象

Date* const p3;// 下面这种写法修饰的是p3，const放在*右边，修饰的是指针变量p3本身，

3.this指针存在哪里？

a.

前面说过成员函数会被转换为指令放在公共代码段，所以这时候可能会有人以为this指针存在代码段，其实this指针存在栈上，下面我们来分析一下原因

b.

代码在经过编译链接阶段后会变成二进制指令，我们平常所说的函数栈帧建立以及堆上malloc开辟空间等等，都是在程序的运行阶段开辟的，而不是编译或链接阶段，空间的开辟是需要机器一步一步识别指令，根据指令内容来进行空间的开辟，所以成员函数会被编译成二进制指令，机器看到调用函数的指令后，就开始开辟函数栈帧，在开辟的栈帧里面存放局部变量和形参等，所以this指针其实是存在栈区上的

c.

还有一个问题就是，我们上面说过，类成员函数是有可能被当作内联处理的，我们都知道内联函数他是一个特殊函数，他是不建立函数栈帧的，所以如果是这样的情况呢？this指针又该存在哪里啊？有了上面知识的讲解，就好解决这个问题了，由于内联函数不建立栈帧，在编译阶段就被展开在相应的位置了，所以在二进制指令里面就没有建立函数栈帧的指令，自然就没有形参的概念，所以这种情况，this指针根本不存在。

4.this指针可以为空吗？

下面给出了两端代码，大家可以看一下，哪个代码正常运行，哪个代码跑起来有问题。

class A
{
public:
  void Print()
  {
    cout << "Print()" << endl;
    // 不发生空对象的成员访问，对象中不存在成员函数，成员函数都被转换成二进制指令放在代码段里面了
  }
private:
  int _a;
};
int main()
{
  A* p = nullptr;
  p->Print();
  return 0;
}
class B
{
public:
  void PrintB()
  {
    cout << _a << endl;
    // 你实例化出来的对象是空的，然而你又通过指针去访问空对象中的数据，那就是典型的空指针访问，this->_a，读取访问权限冲突
  }
private:
  int _a;
};
int main()
{
  B* p = nullptr;
  p->PrintB();
  return 0;
}

我将答案写到了代码注释里面，想要解决上面的题目，其实要明白空指针的成员访问，空指针马，那就是什么都没有，它里面是空的，所以无论你是对空指针进行成员访问或是解引用，其实都会报运行错误，注意是运行错误，而不是编译错误，只有在程序跑起来时，编译器才会报运行错误，语法检查上面，编译器认为你的这两个行为是合理的。

编译阶段，语法检查不会报错

运行起来会发生错误。

五、类的六个默认成员函数

我们上面提到过类型占一个字节的空类，空类中什么都没有吗？还是他有但是我们看不到？

其实空类中是有东西的，他有编译器默认生成的6个成员函数，如果我们不主动去写默认成员函数，编译器是会自动生成他们的。

1.构造函数

对象的初始化≠对象的创建

函数名与类名相同。

无返回值。

对象实例化时编译器自动调用对应的构造函数。

构造函数可以重载。这便意味着，我们可以写出多个构造函数。

下面代码如果将注释内容放开，代码就会编译失败，因为我们显示定义了构造函数，编译器就不会生成构造函数了，但是我们显示定义的构造函数无法完成实例化对象的初始化工作，所以代码就会编译失败。

a. 补充一个概念：

默认构造函数：全缺省构造函数，无参构造函数，编译器默认生成的无参数无代码的构造函数

构造函数：这个范围较大，包括默认构造函数，以及那些无法完成对象初始化工作的构造函数。

要点：

如果没有可用的构造函数，则编译器会自动调用该类的无参构造函数，但如果我们自己显示定义了构造，且构造发挥不了作用，那么编译器就不会自动生成构造函数，此时如果还没有无参构造函数的话，则编译器就会报错没有合适的默认构造可用。

 class Date
 {
  public:
   /*
   // 如果用户显式定义了构造函数，编译器将不再生成
   Date(int year, int month, int day)
   {
   _year = year;
   _month = month;
   _day = day;
   }
   */
 void Print()
   {
   cout << _year << "-" << _month << "-" << _day << endl;
   }
  private:
   int _year;
   int _month;
   int _day;
 };
  int main()
 {
   Date d1;
   return 0;
 }

b. 编译器对于内置类型不处理，对于自定义类型会调用他的构造函数，这个构造函数既有可能是默认构造也有可能是无法完成初始化工作的构造函数。

c. 内置类型：编译器自带的类型，int/char/double/所有指针，包括类类型的指针

自定义类型：就是我们自己定义出来的类型，class/struct + Stack/Queue/Person。对于这样的类型，编译器会自动调用该类的构造函数。

d. 针对编译器不处理内置类型这样的漏洞，C++11做出了补丁，即内置类型成员变量在类中声明时可以给出默认值，但需要注意的是虽然我们肉眼可见的是定义出了一个个变量，但原则还是不能变的，类依旧是不占用内存的，给出的声明只有在实例化对象的时候，才会使用这个声明值，才会占用内存。

class Date
{
private:
   // 基本类型(内置类型)
   int _year = 1970;
   int _month = 1;
   int _day = 1;
   // 自定义类型
   Time _t;
};

2.析构函数

对象的销毁≠对象中资源的清理

析构函数名是在类名前加上字符 ~。

无参数无返回值类型。

一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。

对象生命周期结束时，也就是对象即将被销毁的时候，一般随着栈帧的销毁对象生命也会结束，这时候C++编译系统会自动调用析构函数。

a. 编译器默认生成的析构函数对于内置类型并不会处理，在对象生命结束时，操作系统会自动回收内置类型的内存，但对于自定义类型，编译器默认生成的析构函数会调用该类类型的析构函数。

b. 值得注意的是，由于编译器默认生成的默认析构不会处理内置类型，这也就为它功能的缺陷埋下了隐患，例如内置类型中声明了malloc开辟在堆上的空间呢？这种情况下继续依靠编译器默认生成的析构显然无法满足资源的清理工作，这时候就需要我们手动去将申请的空间还给操作系统。例如栈类的析构函数就需要我们自己来写，他的构造函数同样也需要我们自己来写，因为编译器提供的默认构造无法满足我们的要求。

class Stack
{
public:
  Stack(int capacity = 4)
  {
    //iostream可能间接包含C语言中的头文件
    _array = (int*)malloc(sizeof(int) * capacity);//他妈的这里开辟了一个随机数大小的空间我真服了。
    if (_array == nullptr)
    {
      perror("malloc fail");
      exit(-1);
    }
    _top = 0;
    _capacity = capacity;
  }
  ~Stack()
  {
    free(_array);
    _array = nullptr;
    _top = _capacity = 0;
  }
  void Push(int x)
  {
    _array[_top++] = x; 
  }
private://如果我们想要在调试窗口看到对象的成员变量，可以敲个this指针，这样就可以看到对象的全部成员变量
  int* _array;
  int _top;
  int _capacity;
};

3.拷贝构造（已经存在的对象初始化创建出一个对象）

a. 拷贝构造函数是构造函数的一个重载形式。

b. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
   _year = year;
   _month = month;
   _day = day;
 }
 // Date(const Date& d)   // 正确写法
    Date(const Date d)   // 错误写法：编译报错，会引发无穷递归
 {
   _year = d._year;
   _month = d._month;
   _day = d._day;
 }
private:
   int _year;
   int _month;
   int _day;
};
int main()
{
   Date d1;
   Date d2(d1);
   return 0;
}

用传值作为拷贝构造的形参会出现无穷调用的原因如下。

c. . 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝

如果我们的类是Date类，可以很容易想到，我们不用自己写出拷贝构造，因为他的内置类型都是一些int整型，但如果是Stack类，情况就不一样了，因为他的内置类型里面有指针，此时一旦发生拷贝构造，两个对象中的指针指向的就是同一块空间，那么在在两个对象生命结束时所调用的析构函数就会讲相同指针所指向的空间释放两次，第二次释放的地址就是一个无效的地址，这块地址根本没有指向一块儿有效的空间，自然程序就会出现错误。

d. 调用拷贝构造函数的场景有哪些？

1>使用已经存在的对象去拷贝创建新对象

int main()
{
  Date d1(2022, 12, 16);
  Date d3(2022, 12, 12);
  // 例如我想拷贝一份d1
  Date d2(d1);// 拷贝构造
}

2>函数参数类型为某个类的对象

3>函数返回值为某个类的对象。（这是规定，不要去考虑返回值较小寄存器带出这样的事情，只要返回就需要调用拷贝构造，和那个没关系）

e. 为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

4.赋值重载（是默认成员函数）和运算符重载（不是默认成员函数）

4.1 运算符重载（不是默认成员函数，需要自己写）

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

a. 作为类成员函数重载的时候，参数其实是要少一个的，因为左操作数所对应的参数是隐藏的this指针。如果你要写成全局的重载的话，参数和操作数个数就会相等，因为你需要将两个操作数的形参都写出来

b. .* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

//bool operator==(Date* this, const Date& d2)
bool operator==(const Date& d)//这里用传值传参不好，因为值拷贝要调用拷贝构造，而且比较里面不会改变对象，所以要用const修饰
  {
    //成员变量是私有的，我们怎么解决呢？
    //放到类里面由于this指针的存在，导致参数过多，因为这个函数只允许两个参数存在
    return d._year == _year &&
      d._month == _month &&
      d._day == _day;
  }
//上面是类域的运算符重载，下面是全局域的运算符重载。差别就是非静态成员函数有this指针
bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year &&
        d1._month == d2._month &&
        d1._day == d2._day;
}
int main()
{
  cout << (d1 == d2) << endl;// d1为左操作数，默认的运算符重载的this指向的就是d1
}

. 补充：

我们知道如果重载写成全局，那其实需要一个前提，就是成员变量需要默认为共有，因为如果是私有的话，外面是访问不到这些成员变量的，但为了封装性，我们一般又不愿意将成员变量公开，下面给出两种解决方案：

1.在类里面写一个共公有的函数，用于获取成员变量，然后在全局重载里面调用这个公有函数，以这样的方式来访问到私有的成员变量。

2.将全局重载写成友元函数，下面会讲到友元函数。

4.2 流插入（<<）和流提取（>>）运算符的重载

a. 我们最早使用的看起来较为高级的自动识别类型的输出和输入语句，其实利用的就是运算符重载，只不过系统给我们写好了这些重载函数，ostream和istream就是类，cin和cout分别为这两个类所实例化出来的对象，在使用<<流插入运算符或>>流提取运算符的时候，就会调用类中相应的operator>>函数和operator<<函数，所以自动识别类型的本质还是运算符重载。

#include <iostream>
using namespace std

由下面C++库中的istream和ostream类中的包含的函数可以看到，确实有很多类型被包含了

b. 我们可以用cin或cout输出内置类型，但对于自定义类型，系统是无法支持的，所以这时候就需要我们自己重载自定义类型的流插入和流提取。

需要注意的是，我们是想调用对象cout/cin的重载函数，按照我们的使用习惯cout<<d1这样来看，如果写到类里面的话，势必cout会作为this指针，这显然就发生了错误，因为cout和this指针的所属类是不同的，this指针所指向的类是我们自己实现的，而cout对应的是ostream类，由此可见流插入重载是不能够写到类里面去的，我们只能将其写成全局的形式。

但这里其实出现了我们上面提过一嘴的一个问题，全局函数不能访问私有成员，我们这里给大家演示一下友元的解决方法，大家留个印象即可，博文的下面一部分会详细介绍友元。

//写在Date类的形式：
void operator<<(ostream& out)//两个对象，cout和d1
{
  out << _year << "年" << _month << "月" << _day << "日" << endl;
}
//调用时的形式：
int main()
{
  d1<<cout;// 相当于d1.operator<<(cout)
  return 0;
}
//写在全局的形式
class Date
{
  //友元声明（类的任意位置，不用加inline），我是你的朋友，我来偷你家🍑桃子了，你别放狗咬我。
  friend ostream& operator<<(ostream& out, const Date& d);
  friend istream& operator>>(istream& in, Date& d);
  //利用友元便可以解决类外函数无法访问到类内私有成员变量的问题。
  //………………………………省略一部分Date类的内容
}
// operator<<(cout,d1)  cout<<d1
inline ostream& operator<<(ostream& out, const Date& d)
{
  out << d._year << "年" << d._month << "月" << d._day << "日" << endl;//成员是公有的才可以这么用，私有需要友元来解决
  return out;
}
inline istream& operator>>(istream& in, Date& d)
{ 
  in >> d._year >> d._month >> d._day;
  return in;
}
void DateTest4()
{
  Date d1, d2;
  cout <<d1;// 相当于 cout.operatotr<<(d1)，这样的形式调用，重载必须写在全局
  cin >> d1;
  cout << d1 << d2 << endl;// 调用我们自己写的运算符重载 void operator<<(cout,d1)
  //endl可以不用重载，因为endl是内置类型，其实就是字符'\n'
  cout << d1 - d2 << endl;
}
int main()
{
  DateTest4();
  return 0;
}