diff --git a/README.md b/README.md
index cda2cba..bde6487 100644
--- a/README.md
+++ b/README.md
@@ -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)
 
 ## 关于作者：
 
diff --git a/abstract/README.md b/abstract/README.md
new file mode 100644
index 0000000..5629dc1
--- /dev/null
+++ b/abstract/README.md
@@ -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)
\ No newline at end of file
diff --git a/abstract/abstract.cpp b/abstract/abstract.cpp
new file mode 100644
index 0000000..61e6665
--- /dev/null
+++ b/abstract/abstract.cpp
@@ -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;
+}
diff --git a/abstract/derived_full.cpp b/abstract/derived_full.cpp
new file mode 100644
index 0000000..90a938f
--- /dev/null
+++ b/abstract/derived_full.cpp
@@ -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; 
+} 
diff --git a/abstract/interesting_facts1.cpp b/abstract/interesting_facts1.cpp
new file mode 100644
index 0000000..c98690d
--- /dev/null
+++ b/abstract/interesting_facts1.cpp
@@ -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; 
+} 
+
diff --git a/abstract/interesting_facts2.cpp b/abstract/interesting_facts2.cpp
new file mode 100644
index 0000000..84d293e
--- /dev/null
+++ b/abstract/interesting_facts2.cpp
@@ -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; 
+} 
+
diff --git a/abstract/interesting_facts3.cpp b/abstract/interesting_facts3.cpp
new file mode 100644
index 0000000..6ff352b
--- /dev/null
+++ b/abstract/interesting_facts3.cpp
@@ -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; 
+} 
+
diff --git a/abstract/interesting_facts4.cpp b/abstract/interesting_facts4.cpp
new file mode 100644
index 0000000..028554b
--- /dev/null
+++ b/abstract/interesting_facts4.cpp
@@ -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; 
+} 
diff --git a/abstract/interesting_facts5.cpp b/abstract/interesting_facts5.cpp
new file mode 100644
index 0000000..e9152b9
--- /dev/null
+++ b/abstract/interesting_facts5.cpp
@@ -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;
+}
+
diff --git a/abstract/pure_virtual.cpp b/abstract/pure_virtual.cpp
new file mode 100644
index 0000000..ab552d4
--- /dev/null
+++ b/abstract/pure_virtual.cpp
@@ -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是抽象类，不能创建对象
+}
diff --git a/abstract/test.cpp b/abstract/test.cpp
new file mode 100644
index 0000000..7797c90
--- /dev/null
+++ b/abstract/test.cpp
@@ -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 */
+}; 
diff --git a/const/class_const/c++11_example/main b/const/class_const/c++11_example/main
index f15e688..62017da 100755
Binary files a/const/class_const/c++11_example/main and b/const/class_const/c++11_example/main differ
diff --git a/func_pointer/func1 b/func_pointer/func1
new file mode 100755
index 0000000..0849a18
Binary files /dev/null and b/func_pointer/func1 differ
diff --git a/func_pointer/func_pointer.cpp b/func_pointer/func_pointer.cpp
new file mode 100644
index 0000000..60f8bb9
--- /dev/null
+++ b/func_pointer/func_pointer.cpp
@@ -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); 
+}
diff --git a/inline/README.md b/inline/README.md
new file mode 100644
index 0000000..9fde997
--- /dev/null
+++ b/inline/README.md
@@ -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）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
diff --git a/inline/inline b/inline/inline
new file mode 100755
index 0000000..c45bdb6
Binary files /dev/null and b/inline/inline differ
diff --git a/inline/inline.cpp b/inline/inline.cpp
new file mode 100644
index 0000000..5b1463b
--- /dev/null
+++ b/inline/inline.cpp
@@ -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）。
+ */
+
+
+
diff --git a/inline/inline.h b/inline/inline.h
new file mode 100644
index 0000000..7827c11
--- /dev/null
+++ b/inline/inline.h
@@ -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关键字。
+    
+};
diff --git a/sizeof/README.md b/sizeof/README.md
new file mode 100644
index 0000000..a148be6
--- /dev/null
+++ b/sizeof/README.md
@@ -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;
+}
+```
+
diff --git a/sizeof/blackclass.cpp b/sizeof/blackclass.cpp
new file mode 100644
index 0000000..6c25a43
--- /dev/null
+++ b/sizeof/blackclass.cpp
@@ -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;
+}
diff --git a/sizeof/genA.cpp b/sizeof/genA.cpp
new file mode 100644
index 0000000..cfbc2a4
--- /dev/null
+++ b/sizeof/genA.cpp
@@ -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;
+}
diff --git a/sizeof/geninhe.cpp b/sizeof/geninhe.cpp
new file mode 100644
index 0000000..a0acaad
--- /dev/null
+++ b/sizeof/geninhe.cpp
@@ -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;
+}
diff --git a/sizeof/moreinhe.cpp b/sizeof/moreinhe.cpp
new file mode 100644
index 0000000..6cbd5ef
--- /dev/null
+++ b/sizeof/moreinhe.cpp
@@ -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;
+}
diff --git a/sizeof/morevir.cpp b/sizeof/morevir.cpp
new file mode 100644
index 0000000..66292d2
--- /dev/null
+++ b/sizeof/morevir.cpp
@@ -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;
+}
diff --git a/sizeof/static.cpp b/sizeof/static.cpp
new file mode 100644
index 0000000..35fe4d3
--- /dev/null
+++ b/sizeof/static.cpp
@@ -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;
+}
diff --git a/sizeof/virinhe.cpp b/sizeof/virinhe.cpp
new file mode 100644
index 0000000..ed0a8ac
--- /dev/null
+++ b/sizeof/virinhe.cpp
@@ -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;
+}
diff --git a/sizeof/virmoreinhe.cpp b/sizeof/virmoreinhe.cpp
new file mode 100644
index 0000000..f6d69d7
--- /dev/null
+++ b/sizeof/virmoreinhe.cpp
@@ -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;
+}
diff --git a/virtual/set1/emp b/virtual/set1/emp
new file mode 100755
index 0000000..2f081b0
Binary files /dev/null and b/virtual/set1/emp differ
diff --git a/virtual/set1/emp.cpp b/virtual/set1/emp.cpp
new file mode 100644
index 0000000..7d81040
--- /dev/null
+++ b/virtual/set1/emp.cpp
@@ -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;
+}
diff --git a/vptr_vtable/img/base.jpg b/vptr_vtable/img/base.jpg
new file mode 100644
index 0000000..669f2a0
Binary files /dev/null and b/vptr_vtable/img/base.jpg differ
diff --git a/vptr_vtable/vptr1.cpp b/vptr_vtable/vptr1.cpp
new file mode 100644
index 0000000..f092ff6
--- /dev/null
+++ b/vptr_vtable/vptr1.cpp
@@ -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;
+}
diff --git a/vptr_vtable/深入浅出C++虚函数的vptr与vtable.md b/vptr_vtable/深入浅出C++虚函数的vptr与vtable.md
new file mode 100644
index 0000000..6c46d5c
--- /dev/null
+++ b/vptr_vtable/深入浅出C++虚函数的vptr与vtable.md
@@ -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.
+```
+