C++中变量、函数存储、包括虚函数多态实现机制说明

从C语言转到C++开发，对于类内变量的存储，类内函数的存储，存在疑惑； 

1. 子类如何继承父类的变量的？如果子类和父类变量同名了怎么办?
2. C++中，函数有了作用域，类内函数，只能是这个类或对应对象才能访问，这个控制怎么实现的？
3. 多个对象要编译多个函数实体吗？
4. 父类和子类同名的函数如何控制？

下面就这个差异做下分析 ，一一给出答案

1、子类和父类成员变量的存储

        子类和父类的成员变量存储。 如果只有父类，那么成员变量的存储，类似于C语言的结构体，不再赘述。

        C++中，如何实现，子类继承父类的呢？

        答：在 C++ 中，父类的成员变量在内存中位于子类对象的前部，而子类新增的成员变量则紧随其后。这种内存布局是继承机制的核心实现方式之一，它直接影响了通过父类指针访问成员时的行为。

可以理解为include，就是子类直接包含了父类的变量，父类的放到前面，子类在后面扩展。

这块内存，通过父类对象访问，就只能访问到父类自己管理的内存域，通过子类访问可以访问父类+子类的区域

 示例：

class Base {
public:int base_var = 10;  // 父类成员变量
};class Derived : public Base {
public:int derived_var = 20;  // 子类新增成员变量
};

如果定义一个子类对象 Derived d，d的内存布局如下

|------------------|
| Base::base_var   |  <- 父类部分（内存起始地址）
|------------------|
| Derived::derived_var |  <- 子类新增部分
|------------------|

        当通过父类指针 Base* ptr = &d 访问时，指针实际指向的是子类对象中父类部分的起始地址。此时，编译器只能“看到”父类定义的内存范围，因此只能访问父类的成员变量，即使子类有同名变量。

关键说明：内存布局决定了先后顺序；变量访问是在编译阶段确定的，编译器默认只能寻址到变量类型自己对应的内存范围；（一般会将类编译成一个符号表，0地址是类的第一个变量，max地址是类的最后一个变量），编译器访问某个变量时候，是根据当时对象的基地址+偏移地址决定的

1.1 子类和父类成员变量访问

按照上面结论，子类会继承父类所有的成员变量，并放在内存块的前面；

访问规则：

• 子类对象可以访问父类的变量（如果是protected 可以通过成员函数访问），如果是private则虽然在子类的内存中，但是不可以直接访问，只能通过封装的函数访问。
• 父类指针指向子类对象，可以通过指针访问父类管理的变量，子类部分不可以访问

1.2 子类和父类同名成员变量访问

       在C++中，当父类和子类定义了同名且同类型的成员变量时，子类中实际上会存在两个独立的变量：一个属于父类，另一个属于子类。按照上一章节的解释，父类只能看到父类的变量，它们的访问规则如下：

核心结论

1. 变量共存：子类对象中会同时存在父类和子类的同名变量，二者位于不同的内存位置。对于开发看到的虽然是两个同名变量，其实在C++内部是不同的，内部编译时候会增加类名称区分。

2. 默认访问子类变量：在子类中直接使用变量名时，默认访问的是子类自己的变量。

3. 显式访问父类变量：需要通过作用域解析运算符 Base:: 访问父类的变量（例如 Base::a）。

4. 隐藏机制：子类的变量会**隐藏（hide）**父类的同名变量，但不会覆盖或删除父类的变量。

#include <iostream>class Base {
public:int a;  // 父类成员变量Base() : a(10) {}
};class Derived : public Base {
public:int a;  // 子类同名成员变量Derived() : a(20) {}
};int main() {Derived d;std::cout << d.a << std::endl;          // 输出子类的a：20std::cout << d.Base::a << std::endl;    // 输出父类的a：10Base ptr* = &d;std::cout << ptr->a << std::endl;      // 输出父类的a：10return 0;
}

常见问题

1、同名变量类型不同会怎样？

   和类型相同类似，都是会共存，访问父类仍然需要通过作用域解析运算法；

2、父类变量是private类型的，子类是否可以同名？

    可以，依旧保持共存，但是子类对象是无法访问父类；

2、子类和父类成员函数分析（不考虑虚函数情况）

结论：在C++中，子类和父类的非虚成员函数的调用规则与成员变量类似，包括子类和父类如果存在完全相同的函数（入参类型也相同），因此不再具体分析子类和父类的函数访问规则，可以参照第一章的变量访问带入即可。

不过成员函数和成员变量在内部实现机制上是不同的。

• 成员变量：父类变量在子类对象内存中位于子类新增变量之前（物理顺序）。

• 非虚函数：函数代码本身不存储在对象内存中，而是位于代码段。所有对象共享同一份代码段，即针对一个类的成员函数，只有一个函数实体；

2.1 成员函数的编译机制

针对C++成员函数的，编译做一下简要说明

• 非静态成员函数

编译器会隐式添加 this 指针作为第一个参数，例如：

class A {
public:void func(int x) { /* ... */ }  // 编译器生成 void A_func(A* this, int x)
};

• 成员变量的访问通过 this 指针实现偏移量计算（如 this->x 编译为 *(this + offset)）。

• 调用时需要通过对象（如 obj.func(10)）隐式传递 &obj 作为 this。

• 实际编译过程，会做翻译， obj.func(10)会被编译成 func（&obj，10）；说明func在编译出来的代码中，也并非就是func名称，编译器会自动增加类名称，变量名称，主要用于区分不同类的同名函数，变量名称主要是为了重载时候，区分不同函数。

妙啊，怪不得在C++的面向对象编程中，不用传递对象的成员变量，原来是编译器帮我们做了封装，实际上的原理是和C语言还是一致的。

---

前面是C语言转C++时候总有一个疑问，为啥函数能直接访问成员变量；今日终于了解；

可以理解为，类就是一个结构体，只是定义在类内的函数，编译器编译时候会帮忙增加一个结构体指针作为参数因而才能访问结构体内的所有成员； 这个实现确实高明，减少了写代码时候的成本。

• 静态成员函数

静态函数没有 this 指针，编译器处理方式与普通函数类似：

class A {
public:static void s_func(int x) { /* ... */ }  // 编译为普通函数 void A_s_func(int x)
};

• 只能访问静态成员变量，无法直接访问非静态成员。

• 可通过类名直接调用（如 A::s_func(10)），无需对象实例。

特性	非静态成员函数	静态成员函数
this 指针	隐式传递	无
访问成员变量	通过 this 指针	只能访问静态成员
调用方式	必须通过对象（obj.func()）	类名或对象均可调用
函数签名修饰	包含类名（如 A::func）	类似普通函数
内存占用	不占用对象空间	不占用对象或类空间

2.2 成员函数的存储

        所有成员函数，都存储在代码段，所有的对象共享同一个函数；（和C语言的函数编译其实是一样的，只是函数名称，被编译器加工了，为了区分不同的类的同名函数，编译器会增类名称，变量类型等）。

静态绑定：非虚函数的调用在编译时根据指针或引用的静态类型（声明时的类型）确定，而非实际对象的类型。注意是在编译阶段确定需要访问的那个函数。

隐藏而非覆盖：若子类定义了与父类同名的非虚函数，父类的函数会被隐藏，但不会被覆盖。需通过作用域解析符显式调用父类版本

3、子类和父类成员函数分析（虚函数）

       通过前面的学习，可以了解到，在没有虚函数情况下，多态是没法做到的；通过父类指针只能访问父类的成员变量和成员函数；每个子类的差异无法体现，

        虚拟函数是C++里多态的核心，下面就虚函数的管理进行说明；

C++中的多态是一种允许不同类的对象通过同一接口进行访问的机制，其核心在于运行时动态绑定。以下是其实现机理的详细解析：

• 动态多态（运行时多态）：通过虚函数和继承实现，允许在运行时根据对象类型决定调用的函数。

• 静态多态（编译时多态）：通过函数重载和模板实现，在编译时确定具体调用。

3.1 虚函数Virtual  function

• 基类使用virtual关键字声明的函数，可以在基类做默认实现，也可以不做实现。

• 派生类根据实际需要可以可重写（override）这些函数。

多态举例

举例：Animal类里面有speak方法，声明为虚函数； 那么派生的具体的Dog和Cat子类，可以根据具体的特征，重写该函数；  比如：Dog的实现是Woof； Cat的实现是 Meow；

 示例：

#include <iostream>
using namespace std;class Animal {
public:String animal ="Animal"; //没有实际用途，便于后面解释内存布局virtual void speak() { cout << "Animal sound" << endl; }
};class Dog : public Animal {
public:String  Dog= "dog";void speak() override { cout << "Woof!" << endl; } //覆写为Woof
};class Cat : public Animal {
public:String  Cat= "cat";void speak() override { cout << "Meow!" << endl; } //覆写为Meowvirtual void display() { cout << "I am  cat" << endl; }
};class Mouse: public Animal {
public:String  mouse= "mouse";//函数未覆写speak方法
};int main() {Dog  d;Cat  c;Mouse m;Animal * ani =  &d;ani->speak();// // 动态绑定，输出Woof! 调用的是Dog类实现的方法ani = &c;ani->speak();// // 动态绑定，输出Meow! 调用的是Cat类实现的方法ani = &m;ani->speak();// // 动态绑定，输出Animal sound!  调用的是Animal的默认实现return 0;
}

关键问题是，如何通过基类能够访问到子类的函数，实现运行时候多态呢?

回答这个问题，首先要解释两个概念，vptr和vtable；

vptr：指向vtable的指针；

存在虚函数的基类，会有一个vptr，位置是类的第一个变量；（开发人员看不到，编译器给产生的）。

示例代码的内存布局如下。

Animal对象内存布局：
+----------------+
| Animal的vptr          | → 指向Animal的vtable 存储函数指针{Animal::speak}
| 字符串变量 animal | 
+----------------+

Dog对象内存布局：
+----------------+
| Animal的vptr           | → 指向一个新的的vtable 存储函数指针{Dog::speak}
| 字符串变量 animal | 基类成员变量在前，子类成员变量在后
| 字符串变量 dog      | dog类成员变量
+----------------+

Cat对象内存布局：
+----------------+
| Animal的vptr          | → 指向一个新的vtable 存储函数指针{cat::speak； Cat::display}
| 字符串变量 animal | 基类成员变量在前，子类成员变量在后
| 字符串变量 cat       | cat类成员变量
+----------------+

Mouse对象内存布局：
+----------------+
| Animal的vptr           | → 指向Animal的vtable 存储函数指针{Animal::speak}
| 字符串变量 animal  | 基类成员变量在前，子类成员变量在后
| 字符串变量 mouse  | mouse类成员变量
+----------------+

总结：对于单继承关系的，子类继承基类的vptr变量；（针对多层继承关系，也都只是继承基类的vptr），即从一个基类派生的所有的子类，都只是继承整个派生关系的第一个基类的vptr；

vtable：存储虚函数指针的容器

特征：

• vtable和函数类似，vtable不占用成员变量的地址，在编译阶段生成，类似于一个全局变量；
• vtable存在共享和覆盖；参见上面的示例，Mouse类没有覆写，因此编译器不会再生成一个vtable； Cat类，增加了自己的虚函数display； vtable会在后面追加子类的虚函数指针。

vtable和全局变量，静态变量类似，存储在数据段；

vtable是按照组管理的，上面示例中的vtable，从一个基类派生出来的子类，包括多层子类，都会放到一起，如下管理。

Vtable	存储的函数指针
默认的vtable	{Animal::speak}
被Dog覆写后的vtable	{Dog::speak}
被Cat覆写并追加了display的vtable	{cat::speak； Cat::display}

编译器是管理了，Animal类的一组vtable，这些vtable只是指针组合，如果有多个子类有相同的指针组合，编译器也只会产生一个vtable；

这种管理方式优点：

1、vtable存储在数据段，而不是类内的成员变量。 减少了每一个对象的内存消耗。

2、相同的指针组合，共享一个vtable，减少了数据段空间的内存消耗。

3.2 虚函数实现多态

vtable是在编译阶段根据虚函数指针组合生成。

动态绑定过程

• 当通过基类指针或引用调用虚函数时，编译器生成代码：

1. 通过对象的vptr找到其对应的vtable。
2. 根据函数声明顺序索引vtable，获取实际函数地址。
3. 链接目标函数。

3.3 其他说明

抽象类：包含纯虚函数的类virtual void func() = 0;，继承抽象类的子类，必须覆写纯虚函数。

多重继承：如果一个类继承了多个父类，则会包含多个vptr；但是只有第一个基类的指针具备多态特性。

class Base1 {
public:virtual void f1() {}
};class Base2 {
public:virtual void f2() {}
};class Derived : public Base1, public Base2 {
public:void f1() override {}  // 覆盖Base1::f1void f2() override {}  // 覆盖Base2::f2virtual void f3() {}   // 新增虚函数
};

Derived对象内存布局：
+----------------+
| Base1的vptr     | → 指向Derived中Base1部分的vtable（包含f1和f3）
| Base1成员数据   |
| Base2的vptr     | → 指向Derived中Base2部分的vtable（仅包含f2）
| Base2成员数据   |
| Derived成员数据 |
+----------------+

 问题1：按照上面布局，那么通过derived对象访问f2如何做到？

答：编译器在编译时候，发现是derived对象要去访问f2，会在vptr里查找，找到base2对应的vptr，并进行关系绑定。

问题2：通过base2类型的指针，是无法调用函数f3的？

答：是的，无法访问

结束语：

      在C转C++过程，对于类，继承，多态的疑惑导致设计和编码时候总是不知道什么时候该用什么，上文历时一周完成，在学习和应用过程中，针对遇到的问题，逐一进行了分析确认，对于C转C++有了一次跳跃性理解。 期望本文也能对于在C++中苦恼的各位有所帮助