DevWiki/CPlusPlusThings
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update dir

Browse Source
This commit is contained in:
light-city 2019-07-21 11:41:27 +08:00
parent 75dcf11c89
commit 9d90e047fd
32 changed files with 1389 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
README.md
View File

@ -8,6 +8,11 @@
- [x] [const那些事](./const)
- [x] [static那些事](./static)
- [x] [this那些事](./this)
- [x] [inline那些事](./inline)
- [x] [sizeof那些事](./sizeof)
- [x] [函数指针那些事](./func_pointer)
- [x] [纯虚函数和抽象类那些事](./abstract)
- [x] [vptr_vtable那些事](./vptr_vtable)
## 关于作者：

58
abstract/README.md Normal file
View File

@ -0,0 +1,58 @@
# 纯虚函数和抽象类
## 关于作者：
个人公众号：
![](../img/wechat.jpg)
## 1.纯虚函数与抽象类
C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它!通过声明中赋值0来声明纯虚函数！
对应的代码：[test.cpp](./test.cpp)
* 纯虚函数：没有函数体的虚函数
* 抽象类：包含纯虚函数的类
对应的代码：[pure_virtual.cpp](./pure_virtual.cpp)
抽象类只能作为基类来派生新类使用，不能创建抽象类的对象,抽象类的指针和引用->由抽象类派生出来的类的对象！
## 2.实现抽象类
抽象类中：在成员函数内可以调用纯虚函数，在构造函数/析构函数内部不能使用纯虚函数。
如果一个类从抽象类派生而来，它必须实现了基类中的所有纯虚函数，才能成为非抽象类。
对应的代码：[abstract.cpp](./abstract.cpp)
## 3.重要点
- 纯虚函数使一个类变成抽象类
对应的代码：[interesting_facts1.cpp](./interesting_facts1.cpp)
- 抽象类类型的指针和引用
对应的代码：[interesting_facts2.cpp](./interesting_facts2.cpp)
- 如果我们不在派生类中覆盖纯虚函数，那么派生类也会变成抽象类。
对应的代码：[interesting_facts3.cpp](./interesting_facts3.cpp)
- 抽象类可以有构造函数
对应的代码：[interesting_facts4.cpp](./interesting_facts4.cpp)
- 构造函数不能是虚函数，而析构函数可以是虚析构函数。
对应的代码：[interesting_facts5.cpp](./interesting_facts5.cpp)
当基类指针指向派生类对象并删除对象时，我们可能希望调用适当的析构函数。如果析构函数不是虚拟的，则只能调用基类析构函数。
## 4.完整实例
抽象类由派生类继承实现！
对应的代码：[derived_full.cpp](./derived_full.cpp)

31
abstract/abstract.cpp Normal file
View File

@ -0,0 +1,31 @@
/**
* @file abstract.cpp
* @brief 抽象类中：在成员函数内可以调用纯虚函数，在构造函数/析构函数内部不能使用纯虚函数
* 如果一个类从抽象类派生而来，它必须实现了基类中的所有纯虚函数，才能成为非抽象类
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include<iostream>
using namespace std;
class A {
public:
virtual void f() = 0;
void g(){ this->f(); }
A(){}
};
class B:public A{
public:
void f(){ cout<<"B:f()"<<endl;}
};
int main(){
B b;
b.g();
return 0;
}

32
abstract/derived_full.cpp Normal file
View File

@ -0,0 +1,32 @@
/**
* @file derived_full.cpp
* @brief 完整示例！抽象类由派生类继承实现！
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include<iostream>
using namespace std;
class Base
{
int x;
public:
virtual void fun() = 0;
int getX() { return x; }
};
class Derived: public Base
{
int y;
public:
void fun() { cout << "fun() called"; } ///< 实现了fun()函数
};
int main(void)
{
Derived d;
d.fun();
return 0;
}

29
abstract/interesting_facts1.cpp Normal file
View File

@ -0,0 +1,29 @@
/**
* @file interesting_facts1.cpp
* @brief 纯虚函数使一个类变成抽象类
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include<iostream>
using namespace std;
/**
* @brief 抽象类至少包含一个纯虚函数
*/
class Test
{
int x;
public:
virtual void show() = 0;
int getX() { return x; }
};
int main(void)
{
Test t; //error! 不能创建抽象类的对象
return 0;
}

38
abstract/interesting_facts2.cpp Normal file
View File

@ -0,0 +1,38 @@
/**
* @file interesting_facts2.cpp
* @brief 抽象类类型的指针和引用
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include<iostream>
using namespace std;
/**
* @brief 抽象类至少包含一个纯虚函数
*/
class Base
{
int x;
public:
virtual void show() = 0;
int getX() { return x; }
};
class Derived: public Base
{
public:
void show() { cout << "In Derived \n"; }
Derived(){}
};
int main(void)
{
//Base b; //error! 不能创建抽象类的对象
//Base *b = new Base(); error!
Base *bp = new Derived(); // 抽象类的指针和引用 -> 由抽象类派生出来的类的对象
bp->show();
return 0;
}

30
abstract/interesting_facts3.cpp Normal file
View File

@ -0,0 +1,30 @@
/**
* @file interesting_facts3.cpp
* @brief 如果我们不在派生类中覆盖纯虚函数，那么派生类也会变成抽象类。
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include<iostream>
using namespace std;
class Base
{
int x;
public:
virtual void show() = 0;
int getX() { return x; }
};
class Derived: public Base
{
public:
// void show() { }
};
int main(void)
{
Derived d; //error! 派生类没有实现纯虚函数，那么派生类也会变为抽象类，不能创建抽象类的对象
return 0;
}

35
abstract/interesting_facts4.cpp Normal file
View File

@ -0,0 +1,35 @@
/**
* @file interesting_facts4.cpp
* @brief 抽象类可以有构造函数
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include<iostream>
using namespace std;
// An abstract class with constructor
class Base
{
protected:
int x;
public:
virtual void fun() = 0;
Base(int i) { x = i; }
};
class Derived: public Base
{
int y;
public:
Derived(int i, int j):Base(i) { y = j; }
void fun() { cout << "x = " << x << ", y = " << y; }
};
int main(void)
{
Derived d(4, 5);
d.fun();
return 0;
}

30
abstract/interesting_facts5.cpp Normal file
View File

@ -0,0 +1,30 @@
/**
* @file interesting_facts5.cpp
* @brief 构造函数不能是虚函数，而析构函数可以是虚析构函数。
* 例如：当基类指针指向派生类对象并删除对象时，我们可能希望调用适当的析构函数。如果析构函数不是虚拟的，则只能调用基类析构函数。
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include<iostream>
using namespace std;
class Base {
public:
Base() { cout << "Constructor: Base" << endl; }
virtual ~Base() { cout << "Destructor : Base" << endl; }
};
class Derived: public Base {
public:
Derived() { cout << "Constructor: Derived" << endl; }
~Derived() { cout << "Destructor : Derived" << endl; }
};
int main() {
Base *Var = new Derived();
delete Var;
return 0;
}

29
abstract/pure_virtual.cpp Normal file
View File

@ -0,0 +1,29 @@
/**
* @file pure_virtual.cpp
* @brief 纯虚函数：没有函数体的虚函数
* 抽象类：包含纯虚函数的类
*
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include<iostream>
using namespace std;
class A
{
private:
int a;
public:
virtual void show()=0; //< 纯虚函数
};
int main()
{
// 抽象类只能作为基类来派生新类使用，不能创建抽象类的对象,抽象类的指针和引用->由抽象类派生出来的类的对象！
// A a; // error 抽象类，不能创建对象
A *a1; // ok 可以定义抽象类的指针
// A *a2 = new A; // error,A是抽象类，不能创建对象
}

23
abstract/test.cpp Normal file
View File

@ -0,0 +1,23 @@
/**
* @file test.cpp
* @brief C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它!通过声明中赋值0来声明纯虚函数！
* 纯虚函数：没有函数体的虚函数
* @author 光城
* @version v1
* @date 2019-07-20
*/
/**
* @brief 抽象类
*/
class Test
{
// Data members of class
public:
// Pure Virtual Function
virtual void show() = 0;
/* Other members */
};

BIN
const/class_const/c++11_example/main
View File

Binary file not shown.

BIN
func_pointer/func1 Executable file
View File

Binary file not shown.

33
func_pointer/func_pointer.cpp Normal file
View File

@ -0,0 +1,33 @@
/**
* @file func_pointer.cpp
* @brief 函数指针的使用！
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include<iostream>
using namespace std;
/**
* @brief 定义了一个变量pFun，这个变量是个指针，指向返回值和参数都是空的函数的指针！
*/
void (*pFun)(int);
/**
* @brief 代表一种新类型，不是变量！所以与上述的pFun不一样！
*/
typedef void (*func)(void);
void myfunc(void)
{
cout<<"asda"<<endl;
}
void glFun(int a){ cout<<a<<endl;}
int main(){
func pfun = myfunc;/*赋值*/
pfun();/*调用*/
pFun = glFun;
(*pFun)(2);
}

88
inline/README.md Normal file
View File

@ -0,0 +1,88 @@
# inline那些事
## 关于作者：
个人公众号：
![](../img/wechat.jpg)
## 1.类中内联
头文件中声明方法
```c++
class A
{
public:
void f1(int x);
/**
* @brief 类中定义了的函数是隐式内联函数,声明要想成为内联函数，必须在实现处(定义处)加inline关键字。
*
* @param x
* @param y
*/
void Foo(int x,int y) ///< 定义即隐式内联函数！
{
};
void f1(int x); ///< 声明后，要想成为内联函数，必须在定义处加inline关键字。
};
```
实现文件中定义内联函数：
```c++
#include <iostream>
#include "inline.h"
using namespace std;
/**
* @brief inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字”
*
* @param x
* @param y
*
* @return
*/
int Foo(int x,int y); // 函数声明
inline int Foo(int x,int y) // 函数定义
{
return x+y;
}
// 定义处加inline关键字，推荐这种写法！
inline void A::f1(int x){
}
int main()
{
cout<<Foo(1,2)<<endl;
}
/**
* 编译器对 inline 函数的处理步骤
* 将 inline 函数体复制到 inline 函数调用点处；
* 为所用 inline 函数中的局部变量分配内存空间；
* 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
* 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。
*/
```
内联能提高函数效率，但并不是所有的函数都定义成内联函数！内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。
- 如果执行函数体内代码的时间相比于函数调用的开销较大，那么效率的收货会更少！
- 另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
以下情况不宜用内联：
（1）如果函数体内的代码比较长，使得内联将导致内存消耗代价比较高。
（2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。

BIN
inline/inline Executable file
View File

Binary file not shown.

57
inline/inline.cpp Normal file
View File

@ -0,0 +1,57 @@
#include <iostream>
#include "inline.h"
using namespace std;
/**
* @brief inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字”
*
* @param x
* @param y
*
* @return
*/
int Foo(int x,int y); // 函数声明
inline int Foo(int x,int y) // 函数定义
{
return x+y;
}
// 定义处加inline关键字，推荐这种写法！
inline void A::f1(int x){
}
/**
* @brief 内联能提高函数效率，但并不是所有的函数都定义成内联函数！内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。
* 如果执行函数体内代码的时间相比于函数调用的开销较大，那么效率的收货会更少！另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
* 以下情况不宜用内联：
* （1） 如果函数体内的代码比较长，使得内联将导致内存消耗代价比较高。
* (2) 如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
*
* @return
*/
int main()
{
cout<<Foo(1,2)<<endl;
}
/**
* 编译器对 inline 函数的处理步骤
* 将 inline 函数体复制到 inline 函数调用点处；
* 为所用 inline 函数中的局部变量分配内存空间；
* 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
* 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。
*/

19
inline/inline.h Normal file
View File

@ -0,0 +1,19 @@
class A
{
public:
void f1(int x);
/**
* @brief 类中定义了的函数是隐式内联函数,声明要想成为内联函数，必须在实现处(定义处)加inline关键字。
*
* @param x
* @param y
*/
void Foo(int x,int y) ///< 定义即隐式内联函数！
{
};
void f1(int x); ///< 声明后，要想成为内联函数，必须在定义处加inline关键字。
};

191
sizeof/README.md Normal file
View File

@ -0,0 +1,191 @@
# 类大小计算
首先来个总结，然后下面给出实际例子，实战！
- 空类的大小为1字节
- 一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。
- 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
- 普通继承，派生类继承了所有基类的函数与成员，要按照字节对齐来计算大小
- 虚函数继承，不管是单继承还是多继承，都是继承了基类的vptr。(32位操作系统4字节，64位操作系统 8字节)！
- 虚继承,继承基类的vptr。
## 1.原则1
```c++
/**
* @file blackclass.cpp
* @brief 空类的大小为1字节
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A{};
int main()
{
cout<<sizeof(A)<<endl;
return 0;
}
```
## 2.原则2
```c++
/**
* @file static.cpp
* @brief 静态数据成员
* 静态数据成员被编译器放在程序的一个global data members中，它是类的一个数据成员，但不影响类的大小。不管这个类产生了多少个实例，还是派生了多少新的类，静态数据成员只有一个实例。静态数据成员，一旦被声明，就已经存在。
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A
{
public:
char b;
virtual void fun() {};
static int c;
static int d;
static int f;
};
int main()
{
/**
* @brief 16 字节对齐、静态变量不影响类的大小、vptr指针=8
*/
cout<<sizeof(A)<<endl;
return 0;
}
```
## 3.原则3
```c++
/**
* @file morevir.cpp
* @brief 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A{
virtual void fun();
virtual void fun1();
virtual void fun2();
virtual void fun3();
};
int main()
{
cout<<sizeof(A)<<endl; // 8
return 0;
}
```
## 4.原则4与5
```c++
/**
* @file geninhe.cpp
* @brief 1.普通单继承,继承就是基类+派生类自身的大小(注意字节对齐)
* 注意：类的数据成员按其声明顺序加入内存，无访问权限无关，只看声明顺序。
* 2.虚单继承，派生类继承基类vptr
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A
{
public:
char a;
int b;
};
/**
* @brief 此时B按照顺序：
* char a
* int b
* short a
* long b
* 根据字节对齐4+4=8+8+8=24
*/
class B:A
{
public:
short a;
long b;
};
class C
{
A a;
char c;
};
class A1
{
virtual void fun(){}
};
class C1:public A
{
};
int main()
{
cout<<sizeof(A)<<endl; // 8
cout<<sizeof(B)<<endl; // 24
cout<<sizeof(C)<<endl; // 12
/**
* @brief 对于虚单函数继承，派生类也继承了基类的vptr，所以是8字节
*/
cout<<sizeof(C1)<<endl; // 8
return 0;
}
```
## 5.原则6
```c++
/**
* @file virnhe.cpp
* @brief 虚继承
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A
{
virtual void fun() {}
};
class B
{
virtual void fun2() {}
};
class C : virtual public A, virtual public B
{
public:
virtual void fun3() {}
};
int main()
{
/**
* @brief 8 8 16 派生类虚继承多个虚函数，会继承所有虚函数的vptr
*/
cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);
return 0;
}
```

18
sizeof/blackclass.cpp Normal file
View File

@ -0,0 +1,18 @@
/**
* @file blackclass.cpp
* @brief 空类的大小为1字节
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A{};
int main()
{
cout<<sizeof(A)<<endl;
return 0;
}

29
sizeof/genA.cpp Normal file
View File

@ -0,0 +1,29 @@
/**
* @file genA.cpp
* @brief 普通成员函数，大小为1,一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A
{
public:
A();
~A();
static int a;
static void fun3();
void fun();
void fun1();
};
int main()
{
cout<<sizeof(A)<<endl; // 1
return 0;
}

62
sizeof/geninhe.cpp Normal file
View File

@ -0,0 +1,62 @@
/**
* @file geninhe.cpp
* @brief 1.普通单继承,继承就是基类+派生类自身的大小(注意字节对齐)
* 注意：类的数据成员按其声明顺序加入内存，无访问权限无关，只看声明顺序。
* 2.虚单继承，派生类继承基类vptr
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A
{
public:
char a;
int b;
};
/**
* @brief 此时B按照顺序：
* char a
* int b
* short a
* long b
* 根据字节对齐4+4=8+8+8=24
*/
class B:A
{
public:
short a;
long b;
};
class C
{
A a;
char c;
};
class A1
{
virtual void fun(){}
};
class C1:public A
{
};
int main()
{
cout<<sizeof(A)<<endl; // 8
cout<<sizeof(B)<<endl; // 24
cout<<sizeof(C)<<endl; // 12
/**
* @brief 对于虚单函数继承，派生类也继承了基类的vptr，所以是8字节
*/
cout<<sizeof(C1)<<endl; // 8
return 0;
}

43
sizeof/moreinhe.cpp Normal file
View File

@ -0,0 +1,43 @@
/**
* @file moreinhe.cpp
* @brief 普通多继承与虚函数多继承
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A
{
public:
char a;
int b;
};
class B
{
public:
short a;
long b;
};
/**
* @brief 8+16+8=32
*/
class C:A,B
{
char c;
};
int main()
{
cout<<sizeof(A)<<endl; // 8
cout<<sizeof(B)<<endl; // 16
cout<<sizeof(C)<<endl; // 32
return 0;
}

24
sizeof/morevir.cpp Normal file
View File

@ -0,0 +1,24 @@
/**
* @file morevir.cpp
* @brief 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A{
virtual void fun();
virtual void fun1();
virtual void fun2();
virtual void fun3();
};
int main()
{
cout<<sizeof(A)<<endl;
return 0;
}

33
sizeof/static.cpp Normal file
View File

@ -0,0 +1,33 @@
/**
* @file static.cpp
* @brief 静态数据成员
* 静态数据成员被编译器放在程序的一个global data members中，它是类的一个数据成员，但不影响类的大小。不管这个类产生了多少个实例，还是派生了多少新的类，静态数据成员只有一个实例。静态数据成员，一旦被声明，就已经存在。
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A
{
public:
char b;
virtual void fun() {};
static int c;
static int d;
static int f;
};
int main()
{
/**
* @brief 16 字节对齐、静态变量不影响类的大小、vptr指针=8
*/
cout<<sizeof(A)<<endl;
return 0;
}

38
sizeof/virinhe.cpp Normal file
View File

@ -0,0 +1,38 @@
/**
* @file virnhe.cpp
* @brief 虚继承
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A
{
virtual void fun() {}
};
class B
{
virtual void fun2() {}
};
class C : virtual public A, virtual public B
{
public:
virtual void fun3() {}
};
int main()
{
/**
* @brief 8 8 16 派生类虚继承多个虚函数，会继承所有虚函数的vptr
*/
cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);
return 0;
}

38
sizeof/virmoreinhe.cpp Normal file
View File

@ -0,0 +1,38 @@
/**
* @file virmoreinhe.cpp
* @brief 虚函数多继承
* @author 光城
* @version v1
* @date 2019-07-21
*/
#include<iostream>
using namespace std;
class A
{
virtual void fun() {}
};
class B
{
virtual void fun2() {}
};
class C : public A, public B
{
public:
virtual void fun3() {}
};
int main()
{
/**
* @brief 8 8 16 派生类继承多个虚函数，会继承所有虚函数的vptr
*/
cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);
return 0;
}

BIN
virtual/set1/emp Executable file
View File

Binary file not shown.

52
virtual/set1/emp.cpp Normal file
View File

@ -0,0 +1,52 @@
#include<iostream>
using namespace std;
class Employee
{
public:
virtual void raiseSalary()
{
cout<<0<<endl;
}
virtual void promote()
{ /* common promote code */ }
};
class Manager: public Employee {
virtual void raiseSalary()
{
cout<<100<<endl;
}
virtual void promote()
{ /* Manager specific promote */ }
};
class Engineer: public Employee {
virtual void raiseSalary()
{
cout<<200<<endl;
}
virtual void promote()
{ /* Manager specific promote */ }
};
// Similarly, there may be other types of employees
// We need a very simple function to increment salary of all employees
// Note that emp[] is an array of pointers and actual pointed objects can
// be any type of employees. This function should ideally be in a class
// like Organization, we have made it global to keep things simple
void globalRaiseSalary(Employee *emp[], int n)
{
for (int i = 0; i < n; i++)
emp[i]->raiseSalary(); // Polymorphic Call: Calls raiseSalary()
// according to the actual object, not
// according to the type of pointer
}
int main(){
Employee *emp[]={new Manager(),new Engineer};
globalRaiseSalary(emp,2);
return 0;
}

BIN
vptr_vtable/img/base.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 133 KiB

105
vptr_vtable/vptr1.cpp Normal file
View File

@ -0,0 +1,105 @@
/**
* @file vptr1.cpp
* @brief C++虚函数vptr和vtable
* 编译：g++ -g -o vptr vptr1.cpp -std=c++11
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include <iostream>
#include <stdio.h>
using namespace std;
/**
* @brief 函数指针
*/
typedef void (*Fun)();
/**
* @brief 基类
*/
class Base
{
public:
Base(){};
virtual void fun1()
{
cout << "Base::fun1()" << endl;
}
virtual void fun2()
{
cout << "Base::fun2()" << endl;
}
virtual void fun3(){}
~Base(){};
};
/**
* @brief 派生类
*/
class Derived: public Base
{
public:
Derived(){};
void fun1()
{
cout << "Derived::fun1()" << endl;
}
void fun2()
{
cout << "DerivedClass::fun2()" << endl;
}
~Derived(){};
};
/**
* @brief 获取vptr地址与func地址,vptr指向的是一块内存，这块内存存放的是虚函数地址，这块内存就是我们所说的虚表
*
* @param obj
* @param offset
*
* @return
*/
Fun getAddr(void* obj,unsigned int offset)
{
cout<<"======================="<<endl;
void* vptr_addr = (void *)*(unsigned long *)obj; //64位操作系统，占8字节，通过*(unsigned long *)obj取出前8字节，即vptr指针
printf("vptr_addr:%p\n",vptr_addr);
/**
* @brief 通过vptr指针访问virtual table，因为虚表中每个元素(虚函数指针)在64位编译器下是8个字节，因此通过*(unsigned long *)vptr_addr取出前8字节，
* 后面加上偏移量就是每个函数的地址！
*/
void* func_addr = (void *)*((unsigned long *)vptr_addr+offset);
printf("func_addr:%p\n",func_addr);
return (Fun)func_addr;
}
int main(void)
{
Base ptr;
Derived d;
Base *pt = new Derived(); // 基类指针指向派生类实例
Base &pp = ptr; // 基类引用指向基类实例
Base &p = d; // 基类引用指向派生类实例
cout<<"基类对象直接调用"<<endl;
ptr.fun1();
cout<<"基类引用指向派生类实例"<<endl;
pp.fun1();
cout<<"基类指针指向派生类实例并调用虚函数"<<endl;
pt->fun1();
cout<<"基类引用指向基类实例并调用虚函数"<<endl;
p.fun1();
// 手动查找vptr 和 vtable
Fun f1 = getAddr(pt, 0);
(*f1)();
Fun f2 = getAddr(pt, 1);
(*f2)();
delete pt;
return 0;
}

219
vptr_vtable/深入浅出C++虚函数的vptr与vtable.md Normal file
View File

@ -0,0 +1,219 @@
# 深入浅出C++虚函数的vptr与vtable
## 关于作者：
个人公众号：
![](../img/wechat.jpg)
## 1.基础理论
为了实现虚函数，C ++使用一种称为虚拟表的特殊形式的后期绑定。该虚拟表是用于解决在动态/后期绑定方式的函数调用函数的查找表。虚拟表有时会使用其他名称，例如“vtable”，“虚函数表”，“虚方法表”或“调度表”。
虚拟表实际上非常简单，虽然用文字描述有点复杂。首先，**每个使用虚函数的类（或者从使用虚函数的类派生）都有自己的虚拟表**。该表只是编译器在编译时设置的静态数组。虚拟表包含可由类的对象调用的每个虚函数的一个条目。此表中的每个条目只是一个函数指针，指向该类可访问的最派生函数。
其次，编译器还会添加一个隐藏指向基类的指针，我们称之为vptr。vptr在创建类实例时自动设置，以便指向该类的虚拟表。与this指针不同，this指针实际上是编译器用来解析自引用的函数参数，vptr是一个真正的指针。
因此，它使每个类对象的分配大一个指针的大小。这也意味着vptr由派生类继承，这很重要。
## 2.实现与内部结构
下面我们来看自动与手动操纵vptr来获取地址与调用虚函数！
开始看代码之前，为了方便大家理解，这里给出调用图：
![base](./img/base.jpg)
代码全部遵循标准的注释风格，相信大家看了就会明白，不明白的话，可以留言！
```c++
/**
* @file vptr1.cpp
* @brief C++虚函数vptr和vtable
* 编译：g++ -g -o vptr vptr1.cpp -std=c++11
* @author 光城
* @version v1
* @date 2019-07-20
*/
#include <iostream>
#include <stdio.h>
using namespace std;
/**
* @brief 函数指针
*/
typedef void (*Fun)();
/**
* @brief 基类
*/
class Base
{
public:
Base(){};
virtual void fun1()
{
cout << "Base::fun1()" << endl;
}
virtual void fun2()
{
cout << "Base::fun2()" << endl;
}
virtual void fun3(){}
~Base(){};
};
/**
* @brief 派生类
*/
class Derived: public Base
{
public:
Derived(){};
void fun1()
{
cout << "Derived::fun1()" << endl;
}
void fun2()
{
cout << "DerivedClass::fun2()" << endl;
}
~Derived(){};
};
/**
* @brief 获取vptr地址与func地址,vptr指向的是一块内存，这块内存存放的是虚函数地址，这块内存就是我们所说的虚表
*
* @param obj
* @param offset
*
* @return
*/
Fun getAddr(void* obj,unsigned int offset)
{
cout<<"======================="<<endl;
void* vptr_addr = (void *)*(unsigned long *)obj; //64位操作系统，占8字节，通过*(unsigned long *)obj取出前8字节，即vptr指针
printf("vptr_addr:%p\n",vptr_addr);
/**
* @brief 通过vptr指针访问virtual table，因为虚表中每个元素(虚函数指针)在64位编译器下是8个字节，因此通过*(unsigned long *)vptr_addr取出前8字节，
* 后面加上偏移量就是每个函数的地址！
*/
void* func_addr = (void *)*((unsigned long *)vptr_addr+offset);
printf("func_addr:%p\n",func_addr);
return (Fun)func_addr;
}
int main(void)
{
Base ptr;
Derived d;
Base *pt = new Derived(); // 基类指针指向派生类实例
Base &pp = ptr; // 基类引用指向基类实例
Base &p = d; // 基类引用指向派生类实例
cout<<"基类对象直接调用"<<endl;
ptr.fun1();
cout<<"基类引用指向派生类实例"<<endl;
pp.fun1();
cout<<"基类指针指向派生类实例并调用虚函数"<<endl;
pt->fun1();
cout<<"基类引用指向基类实例并调用虚函数"<<endl;
p.fun1();
// 手动查找vptr 和 vtable
Fun f1 = getAddr(pt, 0);
(*f1)();
Fun f2 = getAddr(pt, 1);
(*f2)();
delete pt;
return 0;
}
```
运行结果：
```
基类对象直接调用
Base::fun1()
基类引用指向派生类实例
Base::fun1()
基类指针指向派生类实例并调用虚函数
Derived::fun1()
基类引用指向基类实例并调用虚函数
Derived::fun1()
=======================
vptr_addr:0x401130
func_addr:0x400ea8
Derived::fun1()
=======================
vptr_addr:0x401130
func_addr:0x400ed4
DerivedClass::fun2()
```
我们发现C++的动态多态性是通过虚函数来实现的。简单的说，通过virtual函数，指向子类的基类指针可以调用子类的函数。例如，上述通过基类指针指向派生类实例，并调用虚函数，将上述代码简化为：
```c++
Base *pt = new Derived(); // 基类指针指向派生类实例
cout<<"基类指针指向派生类实例并调用虚函数"<<endl;
pt->fun1();
```
其过程为：首先程序识别出fun1()是个虚函数，其次程序使用pt->vptr来获取Derived的虚拟表。第三，它查找Derived虚拟表中调用哪个版本的fun1()。这里就可以发现调用的是Derived::fun1()。因此pt->fun1()被解析为Derived::fun1()!
除此之外，上述代码大家会看到，也包含了手动获取vptr地址，并调用vtable中的函数，那么我们一起来验证一下上述的地址与真正在自动调用vtable中的虚函数，比如上述`pt->fun1()`的时候，是否一致！
这里采用gdb调试，在编译的时候记得加上`-g`。
通过`gdb vptr`进入gdb调试页面，然后输入`b Derived::fun1`对fun1打断点，然后通过输入r运行程序到断点处，此时我们需要查看调用栈中的内存地址，通过`disassemable fun1`可以查看当前有关fun1中的相关汇编代码，我们看到了`0x0000000000400ea8`，然后再对比上述的结果会发现与手动调用的fun1一致，fun2类似，以此证明代码正确!
gdb调试信息如下：
```c++
(gdb) b Derived::fun1
Breakpoint 1 at 0x400eb4: file vptr1.cpp, line 23.
(gdb) r
Starting program: /home/light/Program/CPlusPlusThings/virtual/pure_virtualAndabstract_class/vptr
基类对象直接调用
Base::fun1()
基类引用指向派生类实例
Base::fun1()
基类指针指向派生类实例并调用虚函数
Breakpoint 1, Derived::fun1 (this=0x614c20) at vptr1.cpp:23
23 cout << "Derived::fun1()" << endl;
(gdb) disassemble fun1
Dump of assembler code for function Derived::fun1():
0x0000000000400ea8 <+0>: push %rbp
0x0000000000400ea9 <+1>: mov %rsp,%rbp
0x0000000000400eac <+4>: sub $0x10,%rsp
0x0000000000400eb0 <+8>: mov %rdi,-0x8(%rbp)
=> 0x0000000000400eb4 <+12>: mov $0x401013,%esi
0x0000000000400eb9 <+17>: mov $0x602100,%edi
0x0000000000400ebe <+22>: callq 0x4009d0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
0x0000000000400ec3 <+27>: mov $0x400a00,%esi
0x0000000000400ec8 <+32>: mov %rax,%rdi
0x0000000000400ecb <+35>: callq 0x4009f0 <_ZNSolsEPFRSoS_E@plt>
0x0000000000400ed0 <+40>: nop
0x0000000000400ed1 <+41>: leaveq
0x0000000000400ed2 <+42>: retq
End of assembler dump.
(gdb) disassemble fun2
Dump of assembler code for function Derived::fun2():
0x0000000000400ed4 <+0>: push %rbp
0x0000000000400ed5 <+1>: mov %rsp,%rbp
0x0000000000400ed8 <+4>: sub $0x10,%rsp
0x0000000000400edc <+8>: mov %rdi,-0x8(%rbp)
0x0000000000400ee0 <+12>: mov $0x401023,%esi
0x0000000000400ee5 <+17>: mov $0x602100,%edi
0x0000000000400eea <+22>: callq 0x4009d0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
0x0000000000400eef <+27>: mov $0x400a00,%esi
0x0000000000400ef4 <+32>: mov %rax,%rdi
0x0000000000400ef7 <+35>: callq 0x4009f0 <_ZNSolsEPFRSoS_E@plt>
0x0000000000400efc <+40>: nop
0x0000000000400efd <+41>: leaveq
0x0000000000400efe <+42>: retq
End of assembler dump.
```