update dir

README.md

@@ -20,6 +20,8 @@
 - [x] [extern那些事](./extern)
 - [x] [struct那些事](./struct)
 - [x] [struct与class那些事](./struct_class)
+- [x] [union那些事](./union)
+- [x] [c实现c++多态](./c_poly)
 
 代码运行：
  全部在linux下用vim编写，使用gcc/g++调试！全部可正常运行！

c_poly/README.md

@@ -0,0 +1,32 @@
+# C实现C++的面向对象特性
+## 1.C++实现案例
+
+C++中的多态:在C++中会维护一张虚函数表，根据赋值兼容规则，我们知道父类的指针或者引用是可以指向子类对象的。
+
+如果一个父类的指针或者引用调用父类的虚函数则该父类的指针会在自己的虚函数表中查找自己的函数地址，如果该父类对象的指针或者引用指向的是子类的对象，而且该子类已经重写了父类的虚函数，则该指针会调用子类的已经重写的虚函数。
+
+学习案例代码见:[c++_examp.cpp](./c++_examp.cpp)
+
+
+
+## 2.C实现
+
+- 封装
+
+C语言中是没有class类这个概念的，但是有struct结构体，我们可以考虑使用struct来模拟；
+
+使用函数指针把属性与方法封装到结构体中。
+
+- 继承
+
+结构体嵌套
+
+- 多态
+
+类与子类方法的函数指针不同
+
+在C语言的结构体内部是没有成员函数的，如果实现这个父结构体和子结构体共有的函数呢？我们可以考虑使用函数指针来模拟。但是这样处理存在一个缺陷就是：父子各自的函数指针之间指向的不是类似C++中维护的虚函数表而是一块物理内存，如果模拟的函数过多的话就会不容易维护了。
+
+
+
+学习案例代码见:[c_examp.c](./c_examp.c)

c_poly/c++_examp.cpp

@@ -0,0 +1,42 @@
+/**
+ * @file c++_examp.cpp
+ * @brief c++中的多态
+ * @author 光城
+ * @version v1
+ * @date 2019-08-06
+ */
+
+#include <iostream>
+
+using namespace std;
+class A
+{
+    public:
+        virtual void f()//虚函数实现
+        {
+            cout << "Base A::f() " << endl;
+        }
+};
+
+class B:public A    // 必须为共有继承，否则后面调用不到，class默认为私有继承！
+{
+    public:
+        virtual void f()//虚函数实现,子类中virtual关键字可以没有
+        {
+            cout << "Derived B::f() " << endl;
+        }
+};
+
+
+int main() 
+{
+    A a;//基类对象
+    B b;//派生类对象
+
+    A* pa = &a;//父类指针指向父类对象
+    pa->f();//调用父类的函数
+
+    pa = &b; //父类指针指向子类对象，多态实现
+    pa->f();//调用派生类同名函数
+    return 0;
+}

c_poly/c_examp.c

@@ -0,0 +1,55 @@
+/**
+ * @file c_examp.c
+ * @brief C实现多态
+ * @author 光城
+ * @version v1
+ * @date 2019-08-06
+ */
+
+#include <stdio.h>
+
+/// 重定义一个函数指针类型
+typedef void (*pf) ();
+
+/**
+ * @brief 父类 
+ */ 
+typedef struct _A
+{
+    pf _f;
+}A;
+
+
+/**
+ * @brief 子类
+ */
+typedef struct _B
+{ 
+    A _b; ///< 在子类中定义一个基类的对象即可实现对父类的继承。 
+}B;
+
+void FunA() 
+{
+    printf("%s\n","Base A::fun()");
+}
+
+void FunB() 
+{
+    printf("%s\n","Derived B::fun()");
+}
+
+
+int main() 
+{
+    A a;
+    B b;
+
+    a._f = FunA;
+    b._b._f = FunB;
+
+    A *pa = &a;
+    pa->_f();
+    pa = (A *)&b;   /// 让父类指针指向子类的对象,由于类型不匹配所以要进行强转 
+    pa->_f();
+    return 0;
+}

union/README.md

@@ -0,0 +1,12 @@
+# UNION那些事
+
+联合（union）是一种节省空间的特殊的类，一个 union 可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点：
+
+- 默认访问控制符为 public
+- 可以含有构造函数、析构函数
+- 不能含有引用类型的成员
+- 不能继承自其他类，不能作为基类
+- 不能含有虚函数
+- 匿名 union 在定义所在作用域可直接访问 union 成员
+- 匿名 union 不能包含 protected 成员或 private 成员
+- 全局匿名联合必须是静态（static）的

union/union.cpp

@@ -0,0 +1,50 @@
+/**
+ * @file union.cpp
+ * @brief UNION
+ * @author 光城
+ * @version v1
+ * @date 2019-08-06
+ */
+
+#include<iostream>
+/**
+ * 默认访问控制符为public
+ */
+union UnionTest {
+    /**
+     * 可以含有构造函数、析构函数
+     */
+    UnionTest() : i(10) {print(i);};
+    ~UnionTest(){};
+    int i; 
+private:
+    void print(int i){std::cout<<i<<std::endl;};
+};
+/**
+ * 全局匿名联合必须是静态的 
+ */
+static union {
+    int i;
+    double d;
+};
+
+int main() {
+    UnionTest u;
+
+    union {
+        int i;
+        double d;
+    };
+
+    std::cout << u.i << std::endl;  // 输出 UnionTest 联合的 10
+
+    ::i = 20;
+    std::cout << ::i << std::endl;  // 输出全局静态匿名联合的 20
+    /**
+     * 匿名union在定义所在作用域可直接访问union成员
+     */
+    i = 30;
+    std::cout << i << std::endl;    // 输出局部匿名联合的 30
+
+    return 0;
+}