17多继承

最新推荐文章于 2021-07-08 09:17:46 发布
最新推荐文章于 2021-07-08 09:17:46 发布
阅读量389 收藏
点赞数
分类专栏： C++

多继承

1.基础知识

1.1 类之间的关系

has-A，uses-A 和 is-A

has-A

包含关系，用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示，即一个类中的数据成员是另一种已经定义的类。
常和构造函数初始化列表一起使用

uses-A

一个类部分地使用另一个类。通过类之间成员函数的相互联系，定义友元函数友元类或对象参数传递实现。

is-A

机制称为继承。关系具有传递性,不具有对称性。

1.2 继承概念
万事万物都有继承

1.3 继承示例代码

注意：C++中的继承方式（public、private、protected）会影响子类的对外访问属性。

#include <iostream>
using namespace std;

class Parent
{
public:
    void print()
    {
        a = 0;
        b = 0;
        cout<<"a"<<a<<endl;
        cout<<"b"<<b<<endl;
    }

    int b;
protected:
private:
    int a;
};

//class Child : private Parent
//class Child :  protected Parent public
class Child :  public Parent
{
public:
protected:
private:
    int c;
};

void main11()
{

    Child c1;
    //c1.c = 1;//err
    //c1.a = 2;//err
    c1.b = 3;

    c1.print();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

1.4 重要说明

1、子类拥有父类的所有成员变量和成员函数
4、子类可以拥有父类没有的方法和属性
2、子类就是一种特殊的父类
3、子类对象可以当作父类对象使用

2.派生类的访问控制

派生类继承了基类的全部成员变量和成员方法（除了构造和析构之外的成员方法），但是这些成员的访问属性，在派生过程中是可以调整的。

2.1 单个类的访问控制

1、类成员访问级别（public、private、protected）
2、思考：类成员的访问级别只有public和private是否足够？


#include <iostream>
using namespace std;

//public 修饰的成员变量 方法 在类的内部 类的外部都能使用
//protected: 修饰的成员变量方法,在类的内部使用 ,在继承的子类中可用 ;其他 类的外部不能被使用
//private: 修饰的成员变量方法 只能在类的内部使用 不能在类的外部

//派生类访问控制的结论
//1 protected 关键字 修饰的成员变量 和成员函数 ,是为了在家族中使用 ,是为了继承
//2 项目开发中 一般情况下 是 public
//3


class Parent
{
public:
            int a; //老爹的名字
protected:
            int b; //老爹的银行密码
private:
            int c; //老的情人
};


//保护继承
class Child3 : protected Parent
{
public:
protected:
private:
public: 
    void useVar()
    {
        a = 0; // ok
        b = 0; // ok //b这这里 写在了子类Child3的内部  2看protected 3密码===>protected
        //c = 0; //err
    }
};

void main()
{
    Child3 c3;
    //c3.a = 10; //err
    //c3.b = 20; //err
    //c3.c = 30;//err

}



//私有继承
class Child2 : private Parent
{
public:
    void useVar()
    {
        a = 0; //ok
        b = 0; //ok
        //c = 0; // err
    }

protected:
private:
};

void main22()
{
    Child2 c2;
    //c1.a = 10; err
    //c2.b = 20; err
    //c3.b = 30;
}



class Child : public Parent
{
public:
    void useVar()
    {
        a = 0; //ok
        b = 0; //ok
        //c = 0; // err
    }

protected:
private:
};


/*
C++中的继承方式（public、private、protected）会影响子类的对外访问属性 
    判断某一句话，能否被访问
    1）看调用语句，这句话写在子类的内部、外部
    2）看子类如何从父类继承（public、private、protected）  
    3）看父类中的访问级别（public、private、protected）
*/
//共有继承 
void main21()
{
    Parent t1, t2;
    t1.a  = 10; //ok
    //t1.b = 20; //err
    //t2.c = 30 ; //err

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

2.2 不同的继承方式会改变继承成员的访问属性

1）C++中的继承方式会影响子类的对外访问属性

public继承
父类成员在子类中保持原有访问级别
private继承
父类成员在子类中变为private成员
protected继承
父类中public成员会变成protected
父类中protected成员仍然为protected
父类中private成员仍然为private

2）private成员在子类中依然存在，但是却无法访问到。不论种方式继承基类，派生类都不能直接使用基类的私有成员 。

3）C++中子类对外访问属性表

继承方式父类成员访问级别
publicprotectedprivate
publicpublicprotectedprivate
protectedprotectedprotectedprivate
privateprivateprivateprivate


2.3 “三看”原则

C++中的继承方式（public、private、protected）会影响子类的对外访问属性
判断某一句话，能否被访问

1）看调用语句，这句话写在子类的内部、外部
2）看子类如何从父类继承（public、private、protected）
3）看父类中的访问级别（public、private、protected）

2.4 派生类类成员访问级别设置的原则

思考：如何恰当的使用public，protected和private为成员声明访问级别？
1、需要被外界访问的成员直接设置为public
2、只能在当前类中访问的成员设置为private
3、只能在当前类和子类中访问的成员设置为protected，protected成员的访问权限介于public和private之间。

示例代码


//类的继承方式对子类对外访问属性影响

#include <cstdlib>
#include <iostream>

using namespace std;

class A
{
private:
    int a;
protected:
    int b;
public:
    int c;

    A()
    {
        a = 0;      b = 0;      c = 0;
    }

    void set(int a, int b, int c)
    {
        this->a = a;        this->b = b;        this->c = c;
    }
};
class B : public A
{
public:
    void print()
    {
        //cout<<"a = "<<a; //err
        cout<<"b = "<<b; //ok
        cout<<"c = "<<endl; //ok
    }
};

class C : protected A
{
public:
    void print()
    {
        //cout<<"a = "<<a; //err
        cout<<"b = "<<b; // ok
        cout<<"c = "<<endl; //ok
    }
};

class D : private A
{
public:
    void print()
    {
        //cout<<"a = "<<a; //err
        cout<<"b = "<<b<<endl;  //ok
        cout<<"c = "<<c<<endl; // ok
    }
};

int main()
{

    A aa;
    B bb;
    C cc;
    D dd;

    aa.c = 100;  //ok
    bb.c = 100; // ok
    //cc.c = 100; // err 保护的
    //dd.c = 100;  // err

    aa.set(1, 2, 3); //ok
    bb.set(10, 20, 30); //ok
    //cc.set(40, 50, 60); // err
    //dd.set(70, 80, 90);  //err


    bb.print(); //ok
    cc.print(); //ok
    dd.print(); //


    /**/
    system("pause");
    return 0;
}

3.继承中的构造和析构

3.1 类型兼容性原则

类型兼容规则是指在需要基类对象的任何地方，都可以使用公有派生类的对象来替代。通过公有继承，派生类得到了基类中除构造函数、析构函数之外的所有成员。这样，公有派生类实际就具备了基类的所有功能，凡是基类能解决的问题，公有派生类都可以解决。类型兼容规则中所指的替代包括以下情况：

  • 子类对象可以当作父类对象使用
  • 子类对象可以直接赋值给父类对象
  • 子类对象可以直接初始化父类对象
  • 父类指针可以直接指向子类对象
  • 父类引用可以直接引用子类对象
  • 在替代之后，派生类对象就可以作为基类的对象使用，但是只能使用从基类继承的成员。
  • 类型兼容规则是多态性的重要基础之一。

总结：子类就是特殊的父类 (base *p = &child;)


#include <iostream>
using namespace std;

class Parent
{
public:
    void printP()
    {
        cout<<"我是爹..."<<endl;
    }

    Parent()
    {
        cout<<"parent构造函数"<<endl;
    }

    Parent(const Parent &obj)
    {
        cout<<"copy构造函数"<<endl;
    }

private:
    int a;
};

class child : public Parent
{
public:
    void printC()
    {
        cout<<"我是儿子"<<endl;
    }
protected:
private:
    int c;
};



/*
兼容规则中所指的替代包括以下情况：
    子类对象可以当作父类对象使用
    子类对象可以直接赋值给父类对象
    子类对象可以直接初始化父类对象
    父类指针可以直接指向子类对象
    父类引用可以直接引用子类对象
    */



//C++编译器 是不会报错的 .....
void howToPrint(Parent *base)
{
    base->printP(); //父类的 成员函数 

}

void howToPrint2(Parent &base)
{
    base.printP(); //父类的 成员函数 
}
void main()
{
    //

    Parent p1;
    p1.printP();

    child c1;
    c1.printC();
    c1.printP();


    //赋值兼容性原则 
    //1-1 基类指针 (引用) 指向 子类对象
    Parent *p = NULL;
    p = &c1;
    p->printP();  

    //1-2 指针做函数参数

    howToPrint(&p1);
    howToPrint(&c1); 

    //1-3引用做函数参数
    howToPrint2(p1);
    howToPrint2(c1); 


    //第二层含义

    //可以让子类对象   初始化   父类对象
    //子类就是一种特殊的父类
    Parent p3 = c1;


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

3.2 继承中的对象模型

  • 类在C++编译器的内部可以理解为结构体
  • 子类是由父类成员叠加子类新成员得到的


问题：如何初始化父类成员？父类与子类的构造函数有什么关系

  • 在子类对象构造时，需要调用父类构造函数对其继承得来的成员进行初始化
  • 在子类对象析构时，需要调用父类析构函数对其继承得来的成员进行清理
#include <cstdlib>
#include <iostream>
using namespace std;

class Parent04
{
public:
    Parent04(const char* s)
    {
        cout<<"Parent04()"<<" "<<s<<endl;
    }

    ~Parent04()
    {
        cout<<"~Parent04()"<<endl;
    }
};

class Child04 : public Parent04
{
public:
    Child04() : Parent04("Parameter from Child!")
    {
        cout<<"Child04()"<<endl;
    }

    ~Child04()
    {
        cout<<"~Child04()"<<endl;
    }
};

void run04()
{
    Child04 child;
}

int main_04(int argc, char *argv[])
{
    run04();

    system("pause");
    return 0;
}

3.3 继承中的构造析构调用原则

1、子类对象在创建时会首先调用父类的构造函数
2、父类构造函数执行结束后，执行子类的构造函数
3、当父类的构造函数有参数时，需要在子类的初始化列表中显示调用
4、析构函数调用的先后顺序与构造函数相反


#include <iostream>
using namespace std;

//结论
//先 调用父类构造函数 在调用 子类构造函数
//析构的顺序  和构造相反

/*
1、子类对象在创建时会首先调用父类的构造函数
    2、父类构造函数执行结束后，执行子类的构造函数
    3、当父类的构造函数有参数时，需要在子类的初始化列表中显示调用
    4、析构函数调用的先后顺序与构造函数相反
*/

class Parent
{
public:
    Parent(int a, int b)
    {
        this->a = a;
        this->b = b;
        cout<<"父类构造函数..."<<endl;
    }
    ~Parent()
    {
        cout<<"析构函数..."<<endl;
    }

    void printP(int a, int b)
    {
        this->a = a;
        this->b = b;
        cout<<"我是爹..."<<endl;
    }
private:
    int a;
    int b;
};


class child : public Parent
{
public:
    child(int a, int b, int c) : Parent(a, b)
    {
        this->c = c;
        cout<<"子类的构造函数"<<endl;
    }
    ~child()
    {
        cout<<"子类的析构"<<endl;
    }
    void printC()
    {
        cout<<"我是儿子"<<endl;
    }
protected:
private:
    int c;
};


void playObj()
{
    child c1(1, 2, 3);
}
void main()
{
    //Parent p(1, 2);
    playObj();


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

3.4 继承与组合混搭情况下，构造和析构调用原则

  • 先构造父类，再构造成员变量、最后构造自己
  • 先析构自己，在析构成员变量、最后析构父类

#include <iostream>
using namespace std;

class Object
{
public:
    Object(int a, int b)
    {
        this->a = a;
        this->b = b;
        cout<<"object构造函数 执行 "<<"a"<<a<<" b "<<b<<endl;
    }
    ~Object()
    {
        cout<<"object析构函数 \n";
    }
protected:
    int a;
    int b;
};


class Parent : public Object
{
public:
    Parent(char *p) : Object(1, 2)
    {
        this->p = p;
        cout<<"父类构造函数..."<<p<<endl;
    }
    ~Parent()
    {
        cout<<"析构函数..."<<p<<endl;
    }

    void printP(int a, int b)
    {
        cout<<"我是爹..."<<endl;
    }

protected:
    char *p;

};


class child : public Parent
{
public:
    child(char *p) : Parent(p) , obj1(3, 4), obj2(5, 6)
    {
        this->myp = p;
        cout<<"子类的构造函数"<<myp<<endl;
    }
    ~child()
    {
        cout<<"子类的析构"<<myp<<endl;
    }
    void printC()
    {
        cout<<"我是儿子"<<endl;
    }
protected:
    char *myp;
    Object obj1;
    Object obj2;
};


void objplay()
{
    child c1("继承测试");
}
void main()
{
    objplay();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

3.5 继承中的同名成员变量处理方法

1、当子类成员变量与父类成员变量同名时
2、子类依然从父类继承同名成员
3、在子类中通过作用域分辨符::进行同名成员区分（在派生类中使用基类的同名成员，显式地使用类名限定符）
4、同名成员存储在内存中的不同位置

总结：同名成员变量和成员函数通过作用域分辨符进行区分



#include <iostream>
using namespace std;


class A
{
public:
    int a;
    int b;
public:
    void get()
    {
        cout<<"b "<<b<<endl;
    }
    void print()
    {
        cout<<"AAAAA "<<endl;
    }
protected:
private:
};

class B : public A
{
public:
    int b;
    int c;
public:
    void get_child()
    {
        cout<<"b "<<b<<endl;
    }
    void print()
    {
        cout<<"BBBB "<<endl;
    }
protected:
private:
};

void main()
{
    B b1;
    b1.print(); 

    b1.A::print();
    b1.B::print(); //默认情况

    system("pause");
}

//同名成员变量
void main71()
{

    B b1;
    b1.b = 1; //
    b1.get_child();

    b1.A::b = 100; //修改父类的b
    b1.B::b = 200; //修改子类的b 默认情况是B

    b1.get();


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

3.6 派生类中的static关键字

继承和static关键字在一起会产生什么现象哪？
理论知识

  • 基类定义的静态成员，将被所有派生类共享
  • 根据静态成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问性质 （遵守派生类的访问控制）
  • 派生类中访问静态成员，用以下形式显式说明：
    类名 :: 成员
    或通过对象访问 对象名 . 成员


总结：
1> static函数也遵守3个访问原则
2> static易犯错误（不但要初始化，更重要的显示的告诉编译器分配内存）
3> 构造函数默认为private


#include <iostream>
using namespace std;

//单例
class A
{
    A()
    {
        cout<<"A的构造函数"<<endl;
    }
public:
    /*
    static int a;
    int b;
    */
public:
    /*
    void get()
    {
        cout<<"b "<<b<<endl;
    }
    void print()
    {
        cout<<"AAAAA "<<endl;
    }
    */
protected:
private:
};

//int A::a = 100; //这句话 不是简单的变量赋值 更重要的是 要告诉C++编译器 你要给我分配内存 ,我再继承类中 用到了a 不然会报错..


/*
class B : private A
{

public:
    int b;
    int c;
public:
    void get_child()
    {
        cout<<"b "<<b<<endl;
        cout<<a<<endl;
    }
    void print()
    {
        cout<<"BBBB "<<endl;
    }
protected:
private:
};
*/

//1 static关键字 遵守  派生类的访问控制规则

//2  不是简单的变量赋值 更重要的是 要告诉C++编译器 你要给我分配内存 ,我再继承类中 用到了a 不然会报错..

//3 A类中添加构造函数 
    //A类的构造函数中   A的构造函数是私有的构造函数 ... 
    //被别的类继承要小心....
    //单例场景 .... UML

void main()
{
    A a1;
    //a1.print();

     //B b1;
    // b1.get_child();
    system("pause");
}

void main01()
{
    // B  b1;
     //b1.a = 200;
    system("pause");
}

4.多继承

4.1 多继承概念

一个类有多个直接基类的继承关系称为多继承

  • 多继承声明语法
    class 派生类名 : 访问控制 基类名1 , 访问控制 基类名2 , … , 访问控制 基类名n
    {
    数据成员和成员函数声明
    }；

  • 类 C 可以根据访问控制同时继承类 A 和类 B 的成员，并添加自己的成员 


#include <iostream>
using namespace std;

class Base1
{
public:
    Base1(int b1)
    {
        this->b1 = b1;
    }
    void printB1()
    {
        cout<<"b1:"<<b1<<endl; 
    }
protected:
private:
    int  b1;
};

class Base2
{
public:
    Base2(int b2)
    {
        this->b2 = b2;
    }
    void printB2()
    {
        cout<<"b2:"<<b2<<endl; 
    }
protected:
private:
    int  b2;
};

class B : public Base1, public Base2
{
public:
    B(int b1, int b2, int c): Base1(b1), Base2(b2)
    {
        this->c = c;
    }
    void printC()
    {
        cout<<"c:"<<c<<endl; 
    }
protected:
private:
    int c;
};

void main()
{
    B b1(1, 2, 3);
    b1.printC();
    b1.printB1();
    b1.printB2();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

4.2 多继承的派生类构造和访问

  • 多个基类的派生类构造函数可以用初始式调用基类构造函数初始化数据成员
  • 执行顺序与单继承构造函数情况类似。多个直接基类构造函数执行顺序取决于定义派生类时指定的各个继承基类的顺序。
  • 一个派生类对象拥有多个直接或间接基类的成员。不同名成员访问不会出现二义性。如果不同的基类有同名成员，派生类对象访问时应该加以识别。

4.3 简单应用

4.4 虚继承
如果一个派生类从多个基类派生，而这些基类又有一个共同的基类，则在对该基类中声明的名字进行访问时，可能产生二义性

分析如下：


#include <iostream>
using namespace std;

class B
{
public:
    int b;
protected:
private:

};

class B1 : virtual public B
{
public:
    int b1;

};

class B2 : virtual  public B
{
public:
    int b2;
};

class C : public B1, public B2
{
public:
    int c;
};

void main()
{

    C  c1;
    c1.b1 = 100;
    c1.b2 = 200;
    c1.c = 300;

    c1.b = 500; //继承的二义性 和 虚继承解决方案
    //c1.B1::b = 500;
    //c1.B2::b = 500;


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

小结：
1)如果一个派生类从多个基类派生，而这些基类又有一个共同
的基类，则在对该基类中声明的名字进行访问时，可能产生二义性
2)如果在多条继承路径上有一个公共的基类，那么在继承路径的某处汇合点，这个公共基类就会在派生类的对象中产生多个基类子对象
3)要使这个公共基类在派生类中只产生一个子对象，必须对这个基类声明为虚继承，使这个基类成为虚基类。
4)虚继承声明使用关键字 virtual


4.5 总结

  • 继承是面向对象程序设计实现软件重用的重要方法。程序员可以在已有基类的基础上定义新的派生类。
  • 单继承的派生类只有一个基类。多继承的派生类有多个基类。
  • 派生类对基类成员的访问由继承方式和成员性质决定。
  • 创建派生类对象时，先调用基类构造函数初始化派生类中的基类成员。调用析构函数的次序和调用构造函数的次序相反。
  • C++提供虚继承机制，防止类继承关系中成员访问的二义性。
  • 多继承提供了软件重用的强大功能，也增加了程序的复杂性。
小帅比simon
关注
专栏目录
odoo17 | 模型视图继承
洛阳泰山的博客
01-07 1447
向模型添加字段，覆盖模型中字段的定义，向模型添加约束，向模型添加方法，重写模型中的现有方法。
【Java基础知识 17】Java继承和多态
学Java，找哪吒
11-18 7349
关键字extends表明正在构造的新类派生于一个已存在的类。已存在的类称为超类(superclass)，新类称为子类（subclass)。超类和子类是 Java 程序员最常用的两个术语。在设计类的时候，应该将通用的方法放在超类中， 而将具有特殊用途的方法放在子类中。
C++ 多继承
Chroniccandy的博客
10-05 1043
要深入多继承的概念,首先要了解 继承的三种方式: 公有继承(public),私有继承(private),保护继承(protected) 三种继承方式的说明,如下表所示：
C++多继承
weixin_44823313的博客
07-08 952
多继承 1.一个子类可以继承多个父类，会增加程序的复杂度，不建议这么做 2.如果子类继承的多个父类都有虚函数，子类对象则会创建多张虚表 3.子类和父类有同名的函数调用 Undergraduate:Student Undergraduate ug; ug.eat();//调用子类Undergraduate的eat ug.Undergraduate::eat();//调用子类Undergraduate的eat ug.Student::eat();//调用父类Student的eat ...
基础篇 | 17 C++ 编程入门（八）类型转换与多重继承
LorneNote
06-09 790
C++ 其它类型转换 前面文章我们讲过dynamic_cast —&gt; RTTI,static_cast;今天再讲讲reinterpret_cast ,const_cast,这些就是C++里面的全部类型转换，这些都熟练掌握后，写C++的类型转换会行云流水。 回顾一下之前： dynamic cast &lt;-&gt; RTTI(at runtime) 在一条继承链上，向上或向下做类型转...
当C++多继承遇上类型转换
smstong的成长轨迹
04-25 7536
1 由来 客户用陈旧的VC++6.0进行项目开发，有一块功能需要我来实现。让一个早就习惯了VS2013的人去使用C++支持不太好的VC6去做开发实在是非常不爽，于是另辟蹊径，打算使用VC++2013开发编译出DLL，供VC6下调用即可。使用C++开发DLL的基本原则是减少暴露和接口简单化，最常用的方式就是使用纯虚类导出接口。另一种就是使用C++实现，但是导出时只导出C函数。处于使用的便利性考虑，
C 程序设计课件：第17章 多重继承.ppt
06-18
多重继承是 C++ 编程语言中的一种继承机制，它允许一个类继承多个基类，从而使得子类拥有多个基类的特性。多重继承是面向对象编程（Object-Oriented Programming，OOP）的一种重要特性，它使得程序设计变得更加灵活...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值