cpp继承和多态

继承

c++ 如果不写默认的私有继承

继承的基础
    继承的语法
        class 派生类名：继承方式 基类名1， 继承方式 基类名2，...，继承方式 基类名n
        {
            派生类成员声明；
        };
    支持多继承
    继承后子类可以访问父类的非private方法和成员

公有继承&私有继承&保护继承

公有继承

    当类的继承方式为公有继承时，基类的公有和保护成员的访问属性在派生类中不变，而基类的私有成员不可访问。即基类的公有成员和保护成员被继承到派生类中仍作为派生类的公有成员和保护成员。派生类的其他成员可以直接访问它们。无论派生类的成员还是派生类的对象都无法访问基类的私有成员。  

私有继承

当类的继承方式为私有继承时，基类中的公有成员和保护成员都以私有成员身份出现在派生类中，而基类的私有成员在派生类中不可访问。基类的公有成员和保护成员被继承后作为派生类的私有成员，派生类的其他成员可以直接访问它们，但是在类外部通过派生类的对象无法访问。无论是派生类的成员还是通过派生类的对象，都无法访问从基类继承的私有成员。通过多次私有继承后，对于基类的成员都会成为不可访问。因此私有继承比较少用。

保护继承

保护继承中，基类的公有成员和私有成员都以保护成员的身份出现在派生类中，而基类的私有成员不可访问。派生类的其他成员可以直接访问从基类继承来的公有和保护成员，但是类外部通过派生类的对象无法访问它们，无论派生类的成员还是派生类的对象，都无法访问基类的私有成员



构造函数和析构函数的继承性

    构造器语法：

        派生类名::派生类名（参数总表）：基类名1（参数表1），基类名（参数名2）....基类名n（参数名n），内嵌子对象1（参数表1），内嵌子对象2（参数表2）....内嵌子对象n（参数表n）
        {
            派生类新增成员的初始化语句；
        }

    构造函数的顺序:
        父类[按照声明顺序]
        成员对象[按照声明顺序]
        自己的构造函数

    析构函数的顺序:
        自己的构造函数
        成员对象[按照声明顺序]
        父类[按照声明顺序]

覆盖基类函数

    可以直接调用ojbect.spuer::xxx的形式调用，但是如果出现重载的情况有点无力

虚方法
    构造函数不能虚化

    虚函数的工作原理是新增了段指针，当然也增加了开销

    在指针情况下可以轻松实现多态。
    这是我们可以使用vitual，注意请在析构函数也使用vitual

多态

多继承
    单继承可能会出现我们无法解释的概念，必须小朋友是继承了父亲和母亲的优点
    所以有了多重继承

当然多重继承也存在一些问题
    多继承可能存在冲突的问题,比如父类中含有相同的方法，
    好吧，我们抽出相同的方法，采用共同的基类，然后使用虚继承

有点需要注意的 
    每个存在虚函数的类都要有一个4字节的指针指向自己的虚函数表，

纯虚函数
    使用它可以实现接口啦。
    纯虚函数是在基类中声明的虚函数，它可以在基类中有定义，而且派生类必须定义自己的实现方法。基类不能生成对象，可以使用指针或者引用派生类对象。基类不在基类中实现纯虚函数的方法是在函数原型后加“=0”

//
//  main.cpp
//  use_object_more
//
//  Created by bikang on 16/10/21.
//  Copyright (c) 2016年 bikang. All rights reserved.
//

#include <iostream>
#include "CrawFlag.h"
#include "FileCrawFlag.h"

using namespace std;
//设置坐标位置

class Point{
public:
    Point(double x1,double y1){x=x1;y=y1;}
    Point(){cout << "Point construct"<<endl;}
    ~Point(){cout << "Point destruct"<<endl;}
    double getX(){ return x;}
    double getY(){return y;}
    void setX(double x1){x = x1;};
    void setY(double y1){y = y1;}
private:
    double x,y;
};

class SaMonthor{
    public :
    int age;
    SaMonthor(int age1){age = age1;cout << "SaMonthor Construct"<<endl;}
    SaMonthor(){cout << "SaMonthor Construct"<<endl;}
    ~SaMonthor(){cout << "SaMonthor Construct"<<endl;}
    void showMonterData(){cout << "showData"<<endl;}
};

class SaFather{
public :
    int age;
    SaFather(int age1){age = age1;cout << "SaMonthor Construct"<<endl;}
    SaFather(){cout << "SaFather Construct"<<endl;}
    ~SaFather(){cout << "SaFather Construct"<<endl;}
    void showFathorData(){cout << "showData"<<endl;}
};


class Sa:public SaFather,public SaMonthor{

public :
    Sa(string a1,int ageF,int ageM);
    Sa(string a1);
    Sa();
    ~Sa();
    string getB()const {return b;}
    void setB(string b2){this->b = b2;};
    string a;
private:
    string b;
    Point p;
protected:
    string c;
};

Sa::Sa(string a1,int ageF,int ageM):a(a1),SaFather(ageF),SaMonthor(ageF){

}

Sa::Sa(string a1):a(a1){

    cout << "sa construct!" << endl;
}
Sa::Sa(){
    cout << "sa construct!" << endl;
}

Sa::~Sa(){
    cout << "sa destruct!" << endl;
}

class Sa2{
public:
    Sa2(string a1)
    {
        //refCout++;
        a=a1;
        b = new char[20];
        strcpy(b, a.c_str());
        cout << "sa2 construct"<<endl;
    }

    Sa2()
    {
        cout << "sa2 construct"<<endl;
    }

    Sa2(const Sa2 &r)
    {
        //refCout++;
        b = new char[20];
        a = string(r.a)+"_new";
        strcpy(b, a.c_str());
        cout << "sa2 copy construct"<<endl;
    };

    ~Sa2()
    {
        cout << "sa2 destruct"<<endl;
        //delete b;
    }
    string a;
    char *b;
    //const int refCout;
};

class Sa3{
public:
    static const  int s;
    const int s2;
    Sa3():s2(2){cout << "sa3 cons"<<endl;};
    ~Sa3(){cout << "sa3 des"<<endl;};
};
const int Sa3::s = 11;

class Sa4{
public:
    Sa4(int a1):a(a1){cout << "sa4 cons"<<endl;}
    virtual ~Sa4(){cout << "sa4 des"<<endl;}
    void speak(){
        cout << "a=" << a<<endl;
    }
    void speak(int aint){
        cout << aint<<endl;
    }
    virtual void move(){
        cout << "sa4 move" << endl;
    }
    int a;
};

class Sa5:public Sa4{
public:
    Sa5(int a1,int b1):Sa4(a1),b(b1){cout << "sa5 cons"<<endl;}
    ~Sa5(){cout << "sa5 des"<<endl;}
    void speak(){
        cout << "a=" << a<<",";
        cout << "b="<< b <<endl;
    }
    virtual void move(){
        cout << "sa5 move" << endl;
    }
    int b;
};

class Sa6fm{
public:
    Sa6fm(){}
    virtual ~Sa6fm(){cout << "Sa6fm desc" <<endl;}
    void say2(){cout << "sa6f say2" <<endl;}
};


class Sa6f:virtual public Sa6fm{
public:
    Sa6f(){}
    virtual ~Sa6f(){cout << "Sa6f desc " <<endl;}
    void say1(){cout << "sa6f say1" <<endl;}
};

class Sa6m:virtual public Sa6fm{
public:
    Sa6m(){}
    virtual ~Sa6m(){cout << "Sa6m desc " <<endl;}
    void say3(){cout << "Sa6m say3" <<endl;}
};

class Sa6:public Sa6f,public Sa6m{
public:
    Sa6(){}
    virtual ~Sa6(){cout << "Sa6 desc " <<endl;}
};

class Sa7vir{
public:
    Sa7vir(){}
    virtual ~Sa7vir(){cout << "~Sa7vir desc " <<endl;}
    virtual int ss()=0;
};

class Sa7:public Sa7vir{
public:
    Sa7(){}
    virtual ~Sa7(){cout << "Sa7 desc " <<endl;}
    int ss(){
        return 11;
    }
};


//测试类,继承
void tobject();
//测试拷贝构造函数
void tobjCopy();
void tobjCopy2(Sa2 s);
//测试静态变量
void tstatic();

//测试单继承，可以调用父类的方法，也可以调用父类被覆盖的方法
void tInhretOver();
void tInhret();

//测试多重继承
void tMultiInhret();

//测试纯虚函数
void tvitualFunc();


int main(int argc, const char * argv[]) {
    cout << "start test#####" << endl;
    //tobject();
    //tobjCopy();
    //tInhretOver();
    //tInhret();
    //tMultiInhret();
    tvitualFunc();
    return 0;
}
void tvitualFunc(){
    Sa7vir *s = new Sa7();
    cout << s->ss() << endl;
    delete s;
}
void tMultiInhret(){
    Sa6 *s = new Sa6();
    s->say2();//error
    delete s;
    return;
}
void tInhret(){
    Sa4 *s = new Sa5(1,2);
    s->speak();
    s->move();
    delete s;

}

void tInhretOver(){
    //Sa4 s1(1);
    Sa5 s2(1,2);
    s2.Sa4::speak();
    s2.Sa4::speak(123);
    s2.speak();
    //s2.speak(23);//error

}

void tstatic(){
    Sa3 s;
    cout << s.s << endl;
}

void tobjCopy(){
    Sa2 s1("copy data");
    Sa2 s2 = s1;
    cout << "b is:"<< s1.b<< "#"<<s2.b<<endl;
    //tobjCopy2(s1);


}

void tobjCopy2(Sa2 s){
    return;
}

void tobject(){
    Sa s2("a");
}