C++笔记（二）--- 继承和组合

class A
{
public:
//  A(){}    //写与不写，对子类继承时构造函数书写无影响。
             //写无参构造函数目的是实现一些初始化等工作，如果没有则可以不写
    int m;
};

class B : public A
{
public:
//    B(int a){n = a;}//默认继承基类的无参构造函数
                //如果不写构造函数，则后台对B类生成一个无参构造函数，且继承基类A的无参构造函数
    int n;
}

3.子类继承父类，父类有有参构造函数，则子类必须显示指定继承方式且对父类构造函数初始化

class A
{
public:
    A(int m){ n = m;}//因写了构造函数，编译器不在生成默认的无参构造函数
    int n;
}

class B : public A
{
public:
//  B(int i) { j = i; }    //报错，提示 “A” 没有合适的默认构造函数可用
    B(int i):A(i){ j = i; }    //子类的构造函数必须显式调用父类的有参构造函数
    int j;
};

析构

先构造的后析构，后构造的先析构

继承

基类A，后续以此基类进行讨论继承关系。

class A
{
public:
    A(int t){ j = t; cout << "基类A" << endl;};
    void pubA(){ k = 0;}//正确，private只能本类成员函数访问
    int i;
protected:
    void proA(){cout << "基类proA! " << endl;};
    int j;
private:
    void priA();
    int k;
};

public继承

派生类继承的基类中的 public 和 protected成员变量仍旧是 public 和 protected，派生类不能访问基类的private成员变量，派生类定义的变量不能访问基类的protected成员（其实就是protected成员函数只能在本类和其子类访问，而不能在其类实例访问一样）

class B : public A
{
public:
    B(){
        cout << "派生类B!" << endl;
        i = 0;//正确
        j = 0;//正确
        k = 0;//错误，无法访问基类的private成员
    }
    void pubB();
    int iB;
protected:
    void proB();
    int jB;
private:
    void priB();
    int kB;
};

int main()
{
    B b;
    b.pubA();    //正确，继承之后为public
//    b.proA();    //报错，无法访问protected成员（在"A"类中声明）
}

protected继承

派生类继承的基类 public 和 protected 成员变量后变为自己 protected，即基类的成员变量只能在派生类的成员函数中访问，而不能在实例中访问。派生类不能访问基类的private成员变量

class B : protected A
{
public:
    void pubB(){cout << "派生类pubB;" << endl;}
    int iB;
protected:
    void proB(){ cout << "派生类proB;" << endl;  proA(); }//正确
//    void proB_priA() { iB = k; }    //错误，不能访问基类的private成员变量或函数
};

int main(void)
{
    B b;
//    b.pubA();    //报错，A::pubA不可访问，因为“B”使用“protected”从“A”继承
    b.proB();    //正确，打印  派生类proB; 基类proA! 
}

private继承

派生类继承的基类 public 和 protected 成员变量后变为自己的 private 成员变量，但派生类仍不能访问基类的 private 成员变量和函数，虽然是以 private 继承的

class B : private A
{
public:
    void pubB(void){ pubA(); proA(); }    //正确，相当于访问自己类的private成员函数
    void pubB_priA(void){ priA(); }     //错误，不能访问基类的private成员函数
};

组合

组合其实就是一个类调用另外一个类，并对其进行实例化

访问权限

组合只能访问调用类的public

class A
{
public:
    A(){ cout << "基类A！" << endl;}
    void pubA(void){ cout << "pubA~~~" << endl; }
protected:
    void proA(void) { cout << "proA~~~" << endl; }
private:
    void priA(void) { cout << "priA~~~" << endl; }
}

class B
{
public:
    B() { cout << "继承类B！" << endl; }
    void pubB(void) { a.pubA(); cout << "pubB~~~" << endl; }//正确，可以访问public成员函数
protected:
    void proB(void) { a.proA(); cout << "proB~~~" << endl; }//错误，不能访问A类的public以外的成员变量和函数。报错信息：“A::proA”: 无法访问 protected 成员(在“A”类中声明)
private:
    A a;
};

构造/析构函数调用顺序

组合调用构造函数的顺序是：先依次调用内嵌类的构造函数（依次是按定义顺序，而非赋值顺序），在调用本类的构造函数。输出时正好以相反的顺序调用析构函数

class A
{
public:
    A() { cout << "A" << endl; }
    ~A() { cout << "~A" << endl; }
};

class B
{
public:
    B() { cout << "B" << endl; }
    ~B() { cout << "~B" << endl; }
};

class C
{
public:
    C() { cout << "C" << endl; }
    ~C() { cout << "~C" << endl; }
private:
    A a;
    B b;
};

int main(void)
{
    C c;
    return 0;
}

输出

初始化

当调用内嵌类的含参构造函数时，需对其初始化。初始化必须在构造函数的初始化列表中完成

string s = "Hello";
class A
{
public:
    A(int a) { iA = a; }
    A(string s) { iS = s; cout << "A:iS : " << iS << endl;}
private:
    int iA;
    string iS;
};

class C
{
public:
    C(int b) : a(b) { iB = b; }    //a(b)进行类实例初始化
    C(string s) : a(::s) { iS = s; cout << "C:cS :" << iS << endl;}    //::s 表示使用全局变量s
private:
    int iB;
    string iS;
    A a;
};

int main(void)
{
    C c("World!");
    return 0;
}

输出