虚函数和虚继承及其在内存中布局

最新推荐文章于 2024-02-03 23:46:12 发布
最新推荐文章于 2024-02-03 23:46:12 发布
阅读量278 收藏
点赞数
分类专栏： c/c++基础 文章标签： dll DLL Dll library Library

转自：http://blog.csdn.net/fantasywm/article/details/7828744

1.虚函数

一般类的布局

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. public:  
  4.     int m_pbl;  
  5. protected:  
  6.     int m_prt;  
  7. private:  
  8.     int m_prv;  
  9. public:  
  10. voidfun() // 不在堆栈中占空间  
  11. {  
  12.         cout << "It'sfun." << endl;  
  13.     }  
  14. };  
class A
{
public:
    int m_pbl;
protected:
    int m_prt;
private:
    int m_prv;
public:
voidfun() // 不在堆栈中占空间
{
        cout << "It'sfun." << endl;
    }
};

 

1>  class A   size(12):

1>       +---

1>   0   |m_pbl

1>   4   |m_prt

1>   8   |m_prv

1>       +---

1.1 单个类

1.1.1 单个虚函数

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. public:  
  4.     int m_pbl;  
  5. protected:  
  6.     int m_prt;  
  7. private:  
  8.     int m_prv;  
  9. public:  
  10.     void virtual f1()  
  11.     {  
  12.         cout << "It'sf1." << endl;  
  13.     }  
  14. };  
class A
{
public:
    int m_pbl;
protected:
    int m_prt;
private:
    int m_prv;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};

 

2>  class A   size(16):

2>       +---

2>   0   | {vfptr} // 虚表指针

2>   4   |m_pbl

2>   8   |m_prt

2>  12   |m_prv

2>        +---

2> 

2>  A::$vftable@:// 虚表

2>       | &A_meta

2>        |  0

2>   0   |&A::f1

2> 

2>  A::f1 this adjustor: 0

1.1.2 多个虚函数

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. public:  
  4.     int m_pbl;  
  5. protected:  
  6.     int m_prt;  
  7. private:  
  8.     int m_prv;  
  9. public:  
  10.     void virtual f1()  
  11.     {  
  12.         cout << "It'sf1." << endl;  
  13.     }  
  14.     void virtual f2()  
  15.     {  
  16.         cout << "It'sf2." << endl;  
  17.     }  
  18. };  
class A
{
public:
    int m_pbl;
protected:
    int m_prt;
private:
    int m_prv;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
    void virtual f2()
    {
        cout << "It'sf2." << endl;
    }
};

 

1>  class A   size(16):

1>       +---

1>   0   |{vfptr}

1>   4   |m_pbl

1>   8   |m_prt

1>  12   | m_prv

1>       +---

1> 

1>  A::$vftable@: // 同一张表中

1>       | &A_meta

1>       |  0

1>   0   |&A::f1

1>   1   |&A::f2

1> 

1>  A::f1 this adjustor: 0

1>  A::f2 this adjustor: 0

1.2 继承

1.2.1 不加函数

[cpp] view plain copy print ?
  1. class B : public A  
  2. {  
  3. };  
class B : public A
{
};

1>  class B   size(16):

1>  +---

1>  | +--- (baseclass A)

1>   0   | | {vfptr}//同一个指针

1>   4   | |m_pbl

1>   8   | |m_prt

1>  12   | |m_prv

1>   | +---

1>  +---

1> 

1> B::$vftable@: // B的虚表

1>  |&B_meta

1>  |  0

1>   0   |&A::f1

1>   1   |&A::f2

1.2.2 子类override父类的函数

[cpp] view plain copy print ?
  1. class B : public A  
  2. {  
  3. public:  
  4.     void f1()  
  5.     {  
  6.         cout << "It'sf1 in B." << endl;  
  7.     }  
  8. };  
class B : public A
{
public:
    void f1()
    {
        cout << "It'sf1 in B." << endl;
    }
};

1>  class B   size(16):

1>       +---

1>       | +--- (base class A)

1>   0   | |{vfptr}

1>   4   | |m_pbl

1>   8   | |m_prt

1>  12   | |m_prv

1>       | +---

1>       +---

1> 

1>  B::$vftable@:

1>       | &B_meta// B用来标识类

1>       |  0

1>   0   | &B::f1 // 变成了B的版本

1>   1   |&A::f2

1> 

1>  B::f1 this adjustor: 0

1.2.3 子类添加虚函数

[cpp] view plain copy print ?
  1. class B : public A  
  2. {  
  3. public:  
  4.     void f1()  
  5.     {  
  6.         cout << "It'sf1 in B." << endl;  
  7.     }  
  8.     void virtual f3()  
  9.     {  
  10.         cout << "It'sf3." << endl;  
  11.     }  
  12. };  
class B : public A
{
public:
    void f1()
    {
        cout << "It'sf1 in B." << endl;
    }
    void virtual f3()
    {
        cout << "It'sf3." << endl;
    }
};

1>  class B   size(16):

1>  +---

1>  | +---(base class A)

1>   0   | |{vfptr} //合成一个表

1>   4   | |m_pbl

1>   8   | |m_prt

1>  12   | |m_prv

1>  | +---

1>  +---

1> 

1>  B::$vftable@:

1>  |&B_meta

1>  |  0

1>   0   |&B::f1

1>   1   |&A::f2

1>   2   | &B::f3 // 添加到虚表的尾部，类标识为B

1> 

1>  B::f1 this adjustor: 0

1>  B::f3 this adjustor: 0

1.2.4 多继承

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. private:  
  4.     int m_data;  
  5. public:  
  6.     void virtual f1()  
  7.     {  
  8.         cout << "It'sf1." << endl;  
  9.     }  
  10. };  
  11. class B  
  12. {  
  13. public:  
  14.     void virtual f1()  
  15.     {  
  16.         cout << "It'sf1 in B." << endl;  
  17.     }  
  18. };  
  19. class C : public A, public B  
  20. {  
  21. };  
class A
{
private:
    int m_data;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};
class B
{
public:
    void virtual f1()
    {
        cout << "It'sf1 in B." << endl;
    }
};
class C : public A, public B
{
};

 

1>  class C   size(12):

1>        +---

1>       | +--- (base class A)

1>   0   | |{vfptr}

1>   4   | |m_data

1>       | +---

1>       | +--- (base class B)

1>   8   | | {vfptr}  // 多个指针

1>       | +---

1>       +---

1> 

1>  C::$vftable@A@:

1>  |&C_meta

1>  |  0

1>   0   |&A::f1

1> 

1>  C::$vftable@B@:

1>  | -8

1>   0   |&B::f1 

1.3 纯虚函数

1.3.1 只在父类

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. private:  
  4.     int m_data;  
  5. public:  
  6.     void virtual f1() = 0;  
  7. };  
class A
{
private:
    int m_data;
public:
    void virtual f1() = 0;
};

1>  class A   size(8):

1>        +---

1>   0   |{vfptr}

1>   4   | m_data

1>       +---

1> 

1>  A::$vftable@:

1>       | &A_meta

1>       |  0

1>   0   |&A::f1

1> 

1>  A::f1 this adjustor: 0

子类实现

[cpp] view plain copy print ?
  1. class B : public A  
  2. {  
  3. public:  
  4.     void f1()  
  5.     {  
  6.         cout << "It'sf1 in B." << endl;  
  7.     }  
  8. };  
class B : public A
{
public:
    void f1()
    {
        cout << "It'sf1 in B." << endl;
    }
};

1>  class B   size(8):

1>       +---

1>       | +--- (base class A)

1>   0   | |{vfptr}

1>   4   | |m_data

1>       | +---

1>       +---

1> 

1>  B::$vftable@:

1>       | &B_meta

1>       |  0

1>   0   | &B::f1

1> 

1>  B::f1 this adjustor: 0 

1.3.2 父类子类都有

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. private:  
  4.     int m_data;  
  5. public:  
  6.     void virtual f1() = 0;  
  7. };  
  8. class B : public A  
  9. {  
  10. public:  
  11.     void virtual f3() = 0;  
  12. };  
class A
{
private:
    int m_data;
public:
    void virtual f1() = 0;
};
class B : public A
{
public:
    void virtual f3() = 0;
};

1>  class B   size(8):

1>       +---

1>       | +--- (base class A)

1>   0   | |{vfptr}

1>   4   | |m_data

1>       | +---

1>       +---

1> 

1>  B::$vftable@:

1>       | &B_meta

1>       |  0

1>   0   |&A::f1

1>   1   |&B::f3

1> 

1>  B::f3 this adjustor: 0

 纯虚函数在内存中布局和一般的虚函数一样。


2.虚继承

2.1 虚继承

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. private:  
  4.     int m_data;  
  5. };  
  6. class B : virtual public A  
  7. {  
  8. };  
class A
{
private:
    int m_data;
};
class B : virtual public A
{
};

1>  class B   size(8):

1>       +---

1>   0   | {vbptr} // 指针

1>       +---

1>       +--- (virtual base A)

1>   4   |m_data

1>       +---

1> 

1>  B::$vbtable@:// 虚继承表

1>   0   | 0

1>   1   | 4(Bd(B+0)A)

1> 

1> 

1>  vbi:       class offset o.vbptr  o.vbte fVtorDisp

1>                 A       4      0       4 0

2.2 两个父类继承自同一个祖父类

2.2.1 没有用虚继承

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. private:  
  4.     int m_data;  
  5. };  
  6. class B :  public A  
  7. {  
  8. };  
  9. class C :  public A  
  10. {  
  11. };  
  12. class D : public B, public C  
  13. {  
  14. };  
class A
{
private:
    int m_data;
};
class B :  public A
{
};
class C :  public A
{
};
class D : public B, public C
{
};

1>  class D   size(8):

1>       +---

1>       | +--- (base class B)

1>       | | +--- (base class A)

1>   0   | || m_data

1>       | | +---

1>       | +---

1>       | +--- (base class C)

1>       | | +--- (base class A)

1>   4   | || m_data // 两个m_data

1>       | | +---

1>       | +---

1>       +---

2.2.2 加上虚继承之后

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. private:  
  4.     int m_data;  
  5. };  
  6. class B : virtual public A  
  7. {  
  8. };  
  9. class C : virtual public A  
  10. {  
  11. };  
  12. class D : public B, public C  
  13. {  
  14. };  
class A
{
private:
    int m_data;
};
class B : virtual public A
{
};
class C : virtual public A
{
};
class D : public B, public C
{
};

1>  class D   size(12):

1>       +---

1>       | +--- (base class B)

1>   0   | |{vbptr}

1>       | +---

1>       | +--- (base class C)

1>   4   | |{vbptr} //添加了两个虚继承的指针

1>       | +---

1>       +---

1>        +--- (virtual base A)

1>   8   | m_data // 只有了一个m_data

1>       +---

1> 

1> D::$vbtable@B@:

1>   0   | 0

1>   1   | 8(Dd(B+0)A)

1> 

1> D::$vbtable@C@:

1>   0   | 0

1>   1   | 4(Dd(C+0)A)

1> 

1> 

1>  vbi:      class  offset o.vbptr  o.vbte fVtorDisp

1>                 A       8      0       4 0

 

3.虚函数和虚继承结合

3.1 一般结合

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. private:  
  4.     int m_data;  
  5. public:  
  6.     void virtual f1()  
  7.     {  
  8.         cout << "It'sf1." << endl;  
  9.     }  
  10. };  
  11. class B : virtual public A  
  12. {  
  13. public:  
  14.     void f1()  
  15.     {  
  16.         cout << "It'sf1 in B." << endl;  
  17.     }  
  18. };  
class A
{
private:
    int m_data;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};
class B : virtual public A
{
public:
    void f1()
    {
        cout << "It'sf1 in B." << endl;
    }
};

1>  class B   size(12):

1>       +---

1>   0   | {vbptr} //虚继承的指针在前

1>       +---

1>       +--- (virtual base A)

1>   4   | {vfptr} // 虚函数的指针在后

1>   8   |m_data

1>       +---

1> 

1>  B::$vbtable@:

1>   0   | 0

1>   1   | 4(Bd(B+0)A)

1> 

1>  B::$vftable@:

1>        | -4

1>   0   |&B::f1

1> 

1>  B::f1 this adjustor: 4

1> 

1>  vbi:      class  offset o.vbptr  o.vbte fVtorDisp

1>                 A       4      0       4 0

3.2 子类中有虚函数

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. private:  
  4.     int m_data;  
  5. public:  
  6.     void virtual f1()  
  7.     {  
  8.         cout << "It'sf1." << endl;  
  9.     }  
  10. };  
  11. class B : virtual public A  
  12. {  
  13. public:  
  14.     void virtual f2()  
  15.     {  
  16.         cout << "It'sf2." << endl;  
  17.     }  
  18. };  
class A
{
private:
    int m_data;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};
class B : virtual public A
{
public:
    void virtual f2()
    {
        cout << "It'sf2." << endl;
    }
};

 

class B  size(16):

1>       +---

1>   0   | {vfptr}

1>   4   | {vbptr}

1>       +---

1>       +--- (virtual base A)

1>   8   | {vfptr} // 2个指针

1>  12   |m_data

1>       +---

1> 

1> B::$vftable@B@:

1>      |&B_meta

1>      |  0

1>   0  | &B::f2

1> 

1>  B::$vbtable@:

1>   0   |-4

1>   1   | 4(Bd(B+4)A)

1> 

1> B::$vftable@A@:

1>  | -8

1>   0  | &A::f1

1> 

1>  B::f2 this adjustor: 0

1> 

1>  vbi:      class offset o.vbptr  o.vbte fVtorDisp

1>                 A       8      4       4 0

这种情况比较特殊，与不是虚继承的类相比，子类单独添加了一个虚表的指针。

若B对f1重写了，则

[cpp] view plain copy print ?
  1. class B : virtual public A  
  2. {  
  3. public:  
  4.     void f1()  
  5.     {  
  6.         cout << "It'sf1 int B." << endl;  
  7.     }  
  8.     void virtual f2()  
  9.     {  
  10.         cout << "It'sf2." << endl;  
  11.     }  
  12. };  
class B : virtual public A
{
public:
    void f1()
    {
        cout << "It'sf1 int B." << endl;
    }
    void virtual f2()
    {
        cout << "It'sf2." << endl;
    }
};

 

1>  class B   size(16):

1>       +---

1>   0   |{vfptr}

1>   4   |{vbptr}

1>        +---

1>        +--- (virtual base A)

1>   8   |{vfptr}

1>  12   |m_data

1>       +---

1> 

1>  B::$vftable@B@:

1>       | &B_meta

1>       |  0

1>   0   |&B::f2

1> 

1>  B::$vbtable@:

1>   0   |-4

1>   1   | 4(Bd(B+4)A)

1> 

1>  B::$vftable@A@:

1>       | -8

1>   0   | &B::f1 // f1变成了B的版本

1> 

1>  B::f1 this adjustor: 8

1>  B::f2 this adjustor: 0

1> 

1>  vbi:       class offset o.vbptr  o.vbte fVtorDisp

1>                 A       8      4       4 0

3.3 继承的两个父类继承自同一个祖父类

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. private:  
  4.     int m_data;  
  5. public:  
  6.     void virtual f1()  
  7.     {  
  8.         cout << "It'sf1." << endl;  
  9.     }  
  10. };  
  11. class B : virtual public A  
  12. {  
  13. };  
  14. class C : virtual public A  
  15. {  
  16. };  
  17. class D : public B, public C  
  18. {  
  19. };  
class A
{
private:
    int m_data;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};
class B : virtual public A
{
};
class C : virtual public A
{
};
class D : public B, public C
{
};

1>  class D   size(16):

1>       +---

1>       | +--- (base class B)

1>   0   | |{vbptr}

1>       | +---

1>       | +--- (base class C)

1>   4   | |{vbptr} // 不同类的不同

1>       | +---

1>        +---

1>       +--- (virtual base A)

1>   8   | {vfptr} // 只有一个

1>  12   |m_data

1>       +---

1> 

1>  D::$vbtable@B@:

1>   0   | 0

1>   1   | 8(Dd(B+0)A)

1> 

1>  D::$vbtable@C@:

1>   0   | 0

1>   1   | 4(Dd(C+0)A)

1> 

1>  D::$vftable@:

1>       | -8

1>   0   |&A::f1

1> 

1> 

1>  vbi:        class  offset o.vbptr  o.vbte fVtorDisp

1>                 A       8      0       4 0

3.4 继承的两个父类继承自同一个祖父类并且都有虚函数

[cpp] view plain copy print ?
  1. class A  
  2. {  
  3. private:  
  4.     int m_data;  
  5. public:  
  6.     void virtual f1()  
  7.     {  
  8.         cout << "It'sf1." << endl;  
  9.     }  
  10. };  
  11. class B : virtual public A  
  12. {  
  13. public:  
  14.     void virtual f2()  
  15.     {  
  16.         cout << "It'sf2." << endl;  
  17.     }  
  18. };  
  19. class C : virtual public A  
  20. {  
  21. public:  
  22.     void virtual f3()  
  23.     {  
  24.         cout << "It'sf3." << endl;  
  25.     }  
  26. };  
  27. class D : public C, public B  
  28. {  
  29. public:  
  30.     void virtual f4()  
  31.     {  
  32.         cout << "It'sf4." << endl;  
  33.     }  
  34. };  
class A
{
private:
    int m_data;
public:
    void virtual f1()
    {
        cout << "It'sf1." << endl;
    }
};
class B : virtual public A
{
public:
    void virtual f2()
    {
        cout << "It'sf2." << endl;
    }
};
class C : virtual public A
{
public:
    void virtual f3()
    {
        cout << "It'sf3." << endl;
    }
};
class D : public C, public B
{
public:
    void virtual f4()
    {
        cout << "It'sf4." << endl;
    }
};

1>  class D   size(24):

1>       +---

1>       | +--- (base class C) // 虚继承C

1>   0   | |{vfptr}

1>   4   | |{vbptr}

1>       | +---

1>        | +--- (base class B) // 虚继承B

1>   8   | |{vfptr}

1>  12   | |{vbptr}

1>       | +---

1>       +---

1>        +--- (virtual base A)

1>  16   |{vfptr}

1>  20   |m_data

1>       +---

1> 

1>  D::$vftable@C@:

1>       | &D_meta

1>       |  0

1>   0   |&C::f3

1>   1   | &D::f4 // 非虚继承则不添加虚表指针，虚函数加到第一个虚表中

1> 

1>  D::$vftable@B@:

1>       | -8

1>   0   |&B::f2

1> 

1>  D::$vbtable@C@:

1>   0   |-4

1>   1   |12 (Dd(C+4)A)

1> 

1>  D::$vbtable@B@:

1>   0   |-4

1>   1   | 4(Dd(B+4)A)

1> 

1>  D::$vftable@A@:

1>       | -16

1>   0   |&A::f1

1> 

1>  D::f4 this adjustor: 0

1> 

1>  vbi:       class offset o.vbptr  o.vbte fVtorDisp

1>                 A      16      4       4 0

 

桐落
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
对虚函数和虚继承的理解
猫步旅人- 程序员的旅途
03-31 535
对虚函数和虚继承的理解，涉及到大小计算和内存分布问题。不同编译器，比如g++和 VS 对虚继承的内存分布是不同的。
C++多态虚函数实现原理，对象和虚函数表的内存布局
回头太难
05-17 2724
基本概念 我们知道C++动态多态是用虚函数实现的，而虚函数的实现方式虽说C++标准没有要求，但是基本都是用虚函数表实现的（编译器决定）。所以我们有必要了解一下虚函数表的实现原理。 用virtual关键字声明的成员函数是虚函数。 具有虚函数的类及其派生的类会在编译时创建虚函数表，简称虚表（vtbl），虚表是虚函数指针的数组。 具有虚函数的类对象有一个虚表指针（vfptr），是编译器生成的指针，在对象构造时初始化。虚表指针vfptr指向虚表的第一个虚函数指针（即vfptr的值是虚表第一个...
【C++】虚函数及其内存布局
Jacky_Feng的博客
10-18 1854
一、函数调用捆绑 把函数体与函数调用相联系称为捆绑。 当捆绑在程序运行之前（由编译器和连接器）完成时，称为早捆绑。C编译只有一种函数调用方式，就是早捆绑。 早捆绑引起的问题：因为编译器在只有对象的地址时它并不知道要调用的正确函数。 根据对象的类型，捆绑发生在运行时，这种捆绑方式称为晚捆绑，又称动态捆绑。 二、虚函数 对于特定的函数，为了引起晚捆绑，C++要求在基类中声明这个函数时使用virtual关键字，这样的函数称为虚函数。晚捆绑只对virtual函数起作用，而且只在使用含有virtual函.
C++之深入解析虚函数和虚继承的内存模型及其原理
╰つ栺尖篴夢ゞ
04-17 1099
C++ 中虚函数、虚继承的内存模型是一个经典问题，其实现依赖于编译器，但其主要原理大体相同。本文以问题导向的方式，详细介绍 g++ 中虚函数和虚继承的内存模型及其原理。
C++对象模型：单继承，多继承，虚继承，菱形虚继承，及其内存布局图
萧戈的专栏
11-26 512
C++目前使用的对象模型： 此模型下，nonstatic数据成员被置于每一个类的对象中，而static数据成员则被置于类对象之外，static和nonstatic函数也都放在类对象之外（通过函数指针指向），而对于virtual函数，则通过虚函数表+虚函数指针来支持： 1)每个类生成一个表格，称为虚表(virtual table,简称vtbl),虚函数表中存在一堆指针，这些指针指向该类的每一个虚...
c++虚函数及其内存布局、静态绑定与动态绑定与多态
qq_58158950的博客
02-03 1034
首先说明，所谓接下来，我们直接看一段代码来说明问题上述代码中，定义了一个Base类和一个Derive类，并且Derive类继承了Base类，其中Base类中有一组互为重载关系的成员函数showDerive类中有一个与Base类中同名的成员函数，因此，Derive::show()与Base::show()、Base::show(int)构成了隐藏关系。
C++基础——虚继承及其内存分布
chenyijun的专栏
08-09 295
1、虚继承 在C++继承中会遇到一种特殊的情况——“钻石继承”。“钻石继承”指的是当一个基类A被两个派生类B和C同时继承，此时另一个派生类D又同时继承B和C，如果此时用图表示出来就像一个菱形一样，如下图。 派生类D通过继承之后拥有基类A和派生类B，C的成员，所以一旦派生类D想要调用基类A的成员（无论是数据成员还是成员函数）时，此时派生类是通过派生类B来访问基类A的成员呢?还是通过派生类C...
C++虚函数、虚继承、对象内存模型
彦祖老师
11-09 5454
一、虚函数的工作原理       虚函数的实现要求对象携带额外的信息，这些信息用于在运行时确定该对象应该调用哪一个虚函数。典型情况下，这一信息具有一种被称为 vptr（virtual table pointer，虚函数表指针）的指针的形式。vptr 指向一个被称为 vtbl（virtual table，虚函数表）的函数指针数组，每一个包含虚函数的类都关联到 vtbl。当一个对象调用了虚函数，
C++之深入解析虚函数表的实现及其内存布局
╰つ栺尖篴夢ゞ
04-17 1195
C++ 中的虚函数的作用主要是实现了多态的机制，关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数：Derive d;b1 -> f();这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI 技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。
C++ 内存对象布局
11-08
在C++中，对象的内存布局受到多种因素的影响，例如成员变量的类型、是否有虚函数等。接下来我们将详细探讨不同情况下的对象内存布局。 ##### 1. **空类** 空类是指没有任何成员变量的类。尽管此类没有任何成员，但...
vf.rar_虚函数
09-21
2. **对象初始化**：每个类的对象在创建时，编译器会在对象内存布局中插入一个隐藏的成员，即虚函数表指针（vfptr）。这个指针指向该对象所属类的虚函数表。 3. **虚函数调用**：当我们通过基类指针调用虚函数时，...
C++虚函数表分析
12-22
5. 对象的内存布局由成员变量和指向虚函数表的指针组成，可能会因为虚继承而增加vbptr。 理解虚函数表的工作原理有助于优化代码，特别是涉及多态性和继承的复杂场景。通过调试工具和特殊的编译选项，开发者可以深入...
c++中虚函数的实现详解
08-31
每个类的对象在其内存布局中都会包含一个隐藏的虚函数指针，这个指针指向对应的虚函数表。当通过基类指针调用虚函数时，编译器会使用这个指针找到相应的虚函数表，然后根据表中的地址调用正确的函数。 以一个简单的...
chromedriver-mac-arm64_126.0.6465.0.zip
07-31
chromedriver-mac-arm64_126.0.6465.0.zip
chromedriver-mac-x64_122.0.6235.0.zip
最新发布
07-31
chromedriver-mac-x64_122.0.6235.0.zip
chromedriver-mac-x64_122.0.6188.0.zip
07-31
chromedriver-mac-x64_122.0.6188.0.zip
【JCR2区】基于matlab阿基米德算法优化最小二乘法AOA-LSSVM数据分类【含Matlab源码 6004期】.zip
07-31
CSDN海神之光上传的代码均可运行，亲测可用，换数据就行，适合小白； 1、代码压缩包内容 主函数：main.m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化最小二乘法支持向量机LSSVM分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化LSSVM 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化LSSVM 4.4.3 灰狼算法GWO/狼群算法WPA优化LSSVM 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化LSSVM 4.4.5 萤火虫算法FA/差分算法DE优化LSSVM 4.4.6 其他优化算法优化LSSVM
C++虚函数详解：虚表与对象内存布局
"C++虚函数实现机制及其在内存布局中的应用" C++中的虚函数是实现多态性的重要工具，这种动态绑定机制使得程序能够通过基类指针或引用调用派生类重写的成员函数。虚函数的核心在于虚函数表（Virtual Table，简称...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值