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

C++三种继承方式

构造函数

析构

继承

public继承

protected继承

private继承

组合

访问权限

构造/析构函数调用顺序

初始化

总结

C++三种继承方式

C++有三种继承方式：public protected private

属性方式为

class [派生类名称] : [继承方式] [继承类名称]

{

//继承类中做相应动作

};

构造函数

1.子类继承父类时，如果父类没有定义构造函数，则编译器会后台添加无参构造函数，且子类默认使用父类的无参构造函数，此时子类构造函数可以任意书写

2.子类继承父类，父类仅有一个无参构造函数，则子类默认使用父类无参构造函数，且此时子类构造函数可以任意书写

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;
}

输出