六、类的实例化

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

类是对 对象 进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它 。

比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。

一个类可以实例化多个对象：

   就好比类是图纸，根据图纸可以建造出楼房，四栋都不是问题。

但是对于类本身是图纸，图纸并不能住人；房子才能住人。

所以对于类创建出来的对象，可以访问类中成员；但是对于类本身，是不能访问成员与方法的：

所以对于类仅仅起 描述作用 而已，真正使用还是要类对象 。而我们可以认为类这些代码存在代码段，是公共的。

七、类对象模型

1、类对象大小

对于类对象的大小，该如何计算？

class Stack
{
public:
  void Init();
  void push(int x);
  // ... 
private:
  int* _a;
  int _capacity;
  int _top;
};

打印看看：

那么对象中存了成员变量，是否存了成员函数呢？ 答案是没存成员函数。如何理解？先修改代码（将 Stack 都变为公有），便于测试：

class Stack
{
public:
  void Init();
  void push(int x);
  // ...  
  int* _a;
  int _capacity;
  int _top;
};

对于两个不同的类对象，各自具有独立的空间，具有独立的成员变量：

但是调用成员函数只有一份。

2、类对象存储方式

那么为什么不包含成员函数？看下方成员变量和成员函数都存储的设计方式：

每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。

但是如果采用设计方法，就可以减少对空间的消耗：

对于类中成员变量，独立保存起来；但是类中成员函数就和普通的函数一样存在于公共代码区，即代码段，也就是常量字符串存储地，这里存在代码段的含义就是：函数被编译后的指令存在于代码段。

对于如何计算类的大小有几点：

       类中只计算成员变量的大小，计算方式满足C语言结构体内存对齐，不了解的话可以跳转 结构体内存对齐

       空类和只具有成员函数的类大小为 1

第 2 点说明：

对于空类和只有成员函数的类也有自己的地址，并不是空，所以一定有大小，编译器给了空类 1 字节来唯一标识空类（当然也有类的大小也为1，具体看实现）：

这 1 字节是为了占位，并不存储有效数据，标识对象被实例化定义了，表示存在 。

总结：计算类或类对象的大小，只看成员变量，并考虑内存对齐，C++内存对齐规则跟 C 结构体一致

八、this 指针

对于之后的学习，我们将围绕日期类和栈类，来对类和对象更好地理解，所以我们先写出一个日期类：

class Date
{
public:
  void Init(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;
};

1、引子

我们先看一个问题，之前说过类中成员变量命名风格最好加上 ‘_’ ，以示区分；但如果不加区分，对于成员函数中访问的变量访问那个？

测试一下：

对于成员函数中的 year 的值是 2023 ，而日期对象 s 的 year 为随机值；说明如果发生这种情况，成员函数访问形参，遵守局部优先原则。

那如何让成员函数访问成员变量的 year ？，可以使用域作用限定符 ::

但是尽量不要这么写，其一是因为容易误导，其二是小题大做，明明只有命名风格的事情，又上升到语法了。

回到主线，我们继续测试日期类：

class Date
{
public:
  void Init(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;
  d1.Init(2023, 1, 31);
  d1.Print();
  Date d2;
  d2.Init(2023, 2, 1);
  d2.Print();
  return 0;
}

此刻执行程序：

上面讲过 类的实例化 后，我们知道类实例化处的每个对象是独立的，所以对象的成员变量是独立的，但是多个类对象都使用共同的成员函数 ：

我们调试起来转到反汇编看一下：

看到 call 指令这一行，发现函数的地址是相同的，也印证了我们的说法：不同对象使用相同成员函数。

2、特性

   但是有个问题，就拿 Print 函数来说，当 d1 调用 Print 函数时，打印的是 d1 的成员变量；当 d2 调用时，打印的是 d2 的成员变量。而类对象中的成员变量是独立的，如何做到每次调用都可以输出正确的成员变量的？

这就依靠的是 this 指针 ：

对于 d1._year ，即对象访问成员变量，意义是在类对象这块空间中，访问到 _year 这个成员变量，对其进行操作：

而对于 d1.Print() ，则是访问成员函数，是到公共区域代码段上找到成员函数，找到变为 call 指令，进行调用，这里有两层，第一层就是我们前面说的；第二层就是 this 指针。

举一个游泳的例子：

   好比说，在公共游泳馆中，大家都可以去游泳，因为有一个公有的泳池，就好比是成员函数；对于每一个对象，也就是游泳的人，都可以去游泳。

   但是每个人去游泳都要穿泳衣，可是泳衣是独立的，不可能每个人都穿同一套泳衣，这个泳衣就好比是成员变量，每个对象都有独立的成员变量。

   而泳衣是必须的，因为你不可能不穿衣服去游泳，所以我得找到我的泳衣；对于游泳馆，会发一个号码牌，通过号码，指向对应的柜子，让你存放你的衣物，这就好比是 this 指针，用 this 指针找到你的衣服后，再穿好泳衣，去游泳，这就完成了通过 this 指针找到成员变量，调用成员函数的过程。

当代码被编译之后，编译器会对成员函数进行处理，例如这里的 Print 函数，就有一个隐藏的 this 指针 ，类似：

void Print(Date* const this) // const 是因为 this 指针不可改，this 是指针，所以直接用 const 修饰 this  
{
    cout << this->year << "-" << this->_month << "-" << this->_day << endl;
}
// 调用  
d1.Print(&d1);

大约就是这么处理的。当不同的对象调用时，根据传过来的地址，this 指针会指向不同的对象。同理，对于 Init 函数也是这样，我就不多赘述了。

但是注意一点，虽然道理是这样，但是我们不能这么写，例如 d1.Print(&d1) 就会报错，因为 this 指针是隐藏的，统一规定就别写，由此提炼出两点：

       调用成员函数时，不能显示传实参给 this

       定义成员函数时也不能声明形参 this

即形参和实参不能写，但是在成员函数中，是可以显示写的，但是很少用：

cout << this->year << "-" << this->_month << "-" << this->_day << endl;

甚至打印 this 指针也是可以的：

void Print(Date* const this) // const 是因为 this 指针不可该，this 是指针，所以直接用 const 修饰 this  
{
    cout << this << endl;
    cout << this->year << "-" << this->_month << "-" << this->_day << endl;
}

这里打印的 this 指针的地址，就是对应对象的地址：

但是我们一般不这么写，在一些场景下，需要显示用 this ，这个我们之后再看。

   this 指针在哪里？一般情况下在栈区，因为 this 指针是隐含的形参，this 指针并不在对象中 。而 this 指针不需要处理，一般会直接转换为指令，我们不用担心。

但是有时也会特殊处理：

在 vs 下，有些情况会将对象的地址（即 this 指针）放到寄存器 ecx 中，因为在调用成员函数时 this 指针要被经常使用（this->_year）。

3、考题

接下来，通过这几个题目看看你对于类的理解吧！

q1 ：

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
  void PrintA()
  {
    cout << "Print()" << endl;
  }
private:
  int _a;
};
int main()
{
  A* p = nullptr;
  p->Print();
  return 0;
}

q2 ：

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
  void PrintA()
  {
    cout << _a << endl;
  }
private:
  int _a;
};
int main()
{
  A* p = nullptr;
  p->PrintA();
  return 0;
}

q3：

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
  void PrintA()
  {
    cout << "PrintA()" << endl;
  }
private:
  int _a;
};
int main()
{
  A* p = nullptr;
  (*p).PrintA();
  return 0;
}

答案揭晓：

q1 ：C 正常运行

q2：B 运行奔溃

q3：C 正常运行

可是，为什么？别急，我们一个个讲解。

q1分析：

   PrintA() 是成员函数，成员函数在代码段，在公共区域；虽然 p 是空指针，但是访问公共区域并不会报错，因为我不需要到对象里面找。

   而调用函数，会把 p 当做 this 指针传过去，在 PrintA() 函数中，并没有解引用，所以没有问题，只不过此刻的 this 指针为空而已。

   提一个注意点 ：

       这里可以定义变量访问 PrintA 函数，也可以用指针，例如 d.PrintA() 和 p->PrintA() 都是可以的；但是千万不要写成 PrintA(); 的形式，因为类是有作用域的，在调用函数时，只会默认在全局找，得规定在哪个类中，二是因为 this 指针的问题，因为此刻没有对象，this 指针也不清楚，所以这样是错误的.

q2 分析：

   同理 PrintA() 在公共区域，所以调用时是没有问题的，问题在于当 this 指针传递过去后，函数中是这样的：cout << _a << endl; 这里实际上为 cout << this->_a << endl ，对空指针进行了解引用，这就崩溃了。

q3 分析：

   PrintA() 是公共的，不在对象里面；这里表面上看 (*p).PrintA() 是对空指针进行解引用了，其实并没有，编译器对其进行了处理，这里是把 p 传递给了 this ，而这里本质上和 p->PrintA() 是相同的，我们看一下汇编代码：

这里的崩溃与否取决于访问的东西是否在对象中，如果访问的是公共区域，那么就再看传递的 this 指针为空指针时，会不会对 对象 进行解引用。

九、结语

到这里，本篇博客就到此结束了。

今天的干货还是很多的，主要是多和杂，如果看完一遍不太理解的小伙伴们可以反复看看，去试试程序。

而今天的掌握程度对于下篇文章的学习是起决定性作用的，因为类和对象中的知识点更多，更难。所以小伙伴们要好好消化，努力攻克类和对象这一难关。

如果觉得 a n d u i n anduin anduin 写的不错的话，可以点赞 + 收藏 + 评论支持一下哦！

那么我们下期见！