继承

代码的重用性
父类构造函数先调用，子类的析构函数先调用
父类和子类有重名的函数，是覆盖，并非多态

继承的访问修饰

基类中 继承方式 子类中
public ＆ public继承 = > public
public ＆ protected继承 = > protected
public ＆ private继承 = > private
protected ＆ public继承 = > protected
protected ＆ protected继承 = > protected
protected ＆ private继承 = > private
private ＆ public继承 = > 子类无权访问
private ＆ protected继承 = > 子类无权访问
private ＆ private继承 = > 子类无权访问

class Human{
public:
    Human(char* name, int age){
        this->name = name;
        this->age = age;
    }
    void say(){
        cout << "说话" << endl;
    }
protected:
    char* name;
    int age;
};
//男人
class Man : public Human{
public:
    //给父类构造函数传参，同时给属性对象赋值,":"后面第一个表明调用父类哪个构造方法，接下来是给属性对象赋值
    Man(char *brother, char *s_name, int s_age, char *h_name, int h_age) : Human(s_name, s_age), h(h_name,h_age){
        this->brother = brother;
    }
    //泡妞
    void chasing(){
        cout << "泡妞" << endl;
    }
private:
    //兄弟
    char* brother;
    Human h;
};

void main(){
    Man m1("danny","jack",18,"jason",18);
    m1.Human::say();//调用父类的方法
    m1.Human::age = 10;
    system("pause");
}

继承二异性

虚继承，不同路径继承来的同名成员只有一份拷贝，解决不明确的问题

多态

多态（程序的扩展性）
动态多态：程序运行过程中，决定哪一个函数被调用（重写）
静态多态：重载

发生动态的条件：

1.继承
2.父类的引用或者指针指向子类的对象
3.函数的重写（需要用virtual修饰方法）

纯虚函数(抽象类)

1.当一个类具有一个纯虚函数，这个类就是抽象类
virtual void sayArea() = 0;//纯虚函数
2.抽象类不能实例化对象
3.子类继承抽象类，必须要实现纯虚函数，如果没有，子类也是抽象类
抽象类的作用：为了继承约束，根本不知道未来的实现

接口

只是逻辑上的划分，语法上跟抽象类的写法没有区别

可以当做一个接口
class Drawble{
    virtual void draw();
};

模板函数（泛型）

根据实际类型自动推导

//发现：这两个函数业务逻辑一样，数据类型不一样
template <typename T>
void myswap(T& a, T& b){
    T tmp = 0;
    tmp = a;
    a = b;
    b = tmp;
}

模版类

template<class T>
class A{
public:
    A(T a){
        this->a = a;
    }
protected:
    T a;
};
//继承模版类
class B : public A<int>{
public:
    B(int a,int b) : A<int>(a){
        this->b = b;
    }
private:
    int b;
};
//模版类继承模版类
template <class T>
class C : public A<T>{
public:
    C(T c, T a) : A<T>(a){
        this->c = c;
    }
protected:
    T c;
};

void main(){
    A<int> a(6);
    system("pause");
}