继承与派生

基本概念

在定义一个新的类B时，如果该类与某个已有的类A的特点相似，及B拥有A的全部特点，那么久可以把A作为一个基类，而把B作为一个派生类（子 类）

派生类写法：

class A:public B{
……..
;}

class CStudent{
private:
    string sName;
    int nAge;
public:
    bool isThreeGood(){};
    void setName(const string & name){
        sName=name;
    }
};

class CUndergraduateStudent:public CStudent{
private:
    int nDepartment;
public:
    bool isThreeGood();
    bool CanBaoYan();
};

举例：

class CStudent{
private:
    string name;string id;
    char gender; int age;
public:
    void PrintInfo();
    void SetInfo(const string & name_, const string & id_, char gender_, int age_);
    string GetName() {
        return name;
    }
};

void CStudent::PrintInfo() {
    cout << "Name:" << name << endl; 
    cout << "ID:" << id << endl; 
    cout << "Age:" << age << endl; 
    cout << "Gender:" << gender << endl;
}

void CStudent::SetInfo(const string & name_, const string & id_, char gender_, int age_) {
    name = name_; id = id_; 
    gender = gender_; age = age_;
}

class CUndergraduateStudent:public CStudent{
private:
    string deparment;
public:
    void QualifiedForBaoYan() {
        cout << "qualified for baoyan" << endl;
    }
    void PrintInfo() {
        CStudent::PrintInfo();
        cout << "deparment:" << deparment << endl;
    }
    void SetInfo(const string & name_, const string & id_, char gender_, int age_, const string &deparment_) {
        CStudent::SetInfo(name_, id_, gender_, age_);
        deparment = deparment_;
    }
};

int main(int argc, const char * argv[]) {
    CUndergraduateStudent s2;
    s2.SetInfo("feng", "123", 'm', 23, "yiqi");
    cout << s2.GetName() << endl;
    s2.QualifiedForBaoYan();
    s2.PrintInfo();
    return 0;
}

输出：

派生类对象的内存空间

派生类对象的体积，等于基类对象的体积，加上派生类对象自己成员变量的体积。

class BASE{
    int v1,v2;
}
class deriverd:public BASE{
    int v3;
}

继承和复合关系

继承：“是”的关系
–基类A，B是基类A的派生类。
–逻辑上要求，一个B对象也是A对象。
———- *
复合：“有”的关系
–类C中有成员变量K，K是类D的对象，则C和D是复合关系
–逻辑上要求，D对象是C对象固有属性或组成部分

---

• 继承–一个男人同时也是人
  
• 点与圆
  

注意：
一个圆不是一个点，而圆包含点的属性（圆心）

基类/派生类同名成员 与Protected关键字

• 基类/派生类同名成员

class base{
private:
    int j;
public:
    int i;
    void fun();
};

class derived:public base{
private:
public:
    int i;
    void access();
    void func();
};

void derived::access(){
    j = 5; //error
    i = 5; //引用的是派生类的 i
    base::i = 5; //引用的是基类的 i
    func(); //派生类的
    base::func(); //基类的
}

- Protected关键字

基类的private成员: 可以被下列函数访问
•—-基类的成员函数
•—-基类的友员函数
基类的public成员: 可以被下列函数访问
•—-基类的成员函数
•—-基类的友员函数
•—-派生类的成员函数
•—-派生类的友员函数
•—-其他的函数
基类的protected成员: 可以被下列函数访问
•—-基类的成员函数
•—-基类的友员函数
•—-派生类的成员函数可以访问当前对象的基类的保护成员

---

class Father {
private: int nPrivate; //私有成员
public: int nPublic; //公有成员
protected: int nProtected; // 保护成员
};
class Son : public Father {
    void AccessFather() {
        nPublic = 1; // ok;
        nPrivate = 1; // wrong
        nProtected = 1; // OK, 访问从基类继承的protected成员
        Son f;
        f.nProtected = 1; //wrong, f不是当前对象
    }
};

int main() {
    Father f;
    Son s;
    f.nPublic = 1; // Ok
    s.nPublic = 1; // Ok
    f.nProtected = 1; // error
    f.nPrivate = 1; // error
    s.nProtected = 1; //error
    s.nPrivate = 1; // error
    return 0;
}

派生类的构造函数

派生类对象包含基类对象
执行派生类对象构造函数之前，先执行基类对象构造函数

---

class Bug {
private:
    int nLegs; int nColor;
public:
    int nType;
    Bug(int legs, int color);
    void PrintBug() { };
};
class FlyBug : public Bug { // FlyBug是Bug的派生类
    int nWings;
public:
    FlyBug(int legs, int color, int wings);
}; 

Bug::Bug(int legs, int color) {
    nLegs = legs;
    nColor = color;
}
//错误的FlyBug构造函数:
FlyBug::FlyBug(int legs, int color, int wings) {
    nLegs = legs; // 不能访问
    nColor = color; // 不能访问
    nType = 1; // ok
    nWings = wings;
}
//正确的FlyBug构造函数:
FlyBug::FlyBug(int legs, int color, int wings) :Bug(legs, color) {
    nWings = wings;
}

int main() {
    FlyBug fb(2, 3, 4);
    fb.PrintBug();
    fb.nType = 1;
    fb.nLegs = 2; // error.nLegs is private
    return 0;
}

调用基类构造函数的两种方式

• 显式方式（基类构造函数提供参数）
• 隐式方式（省略基类构造函数，调用基类默认构造函数）

---

派生类析构函数执行时候，先执行派生类析构函数，在执行基类析构函数

class Base{
public:
    int n;
    Base(int i) :n(i) {
        cout << "Base" << n << "constructed" << endl;
    }
    ~Base() {
        cout << "Base" << n << "deconstructed" << endl;
    }
};

class Derived:public Base{
public:
    Derived(int i) :Base(i) {
        cout <<"derived constructed" << endl;
    }

    ~Derived() {
        cout << "derived deconstructed" << endl;
    }
};

int main(int argc, const char * argv[]) {
    Derived obj(3);
    return 0;
}

public继承的赋值兼容规则

class base{};
class derived:public base{
base b;
}
derived d;

---

• 派生类对象可以赋值给基类： b=d;
• 派生类对象可以初始化基类引用：base & br=d;
• 派生类对地址可以赋值给基类地址：base *br=&d;

class Base { 
public: int n; 
        Base(int i) :n(i) { 
            cout << "Base " << n << " constructed" << endl;
        } 
        ~Base() { 
            cout << "Base " << n << " destructed" << endl;
        } 
};

class Derived :public Base
{
public:
    Derived(int i) :Base(i) {
        cout << "Derived constructed" << endl;
    }
    ~Derived() {
        cout << "Derived destructed" << endl;
    }
};

class MoreDerived :public Derived {
public:
    MoreDerived() :Derived(4) {
        cout << "More Derived constructed" << endl;
    }
    ~MoreDerived() {
        cout << "More Derived destructed" << endl;
    }
};
int main()
{
    MoreDerived Obj;
    return 0;
}