继承与派生

最新推荐文章于 2024-05-15 23:41:59 发布
最新推荐文章于 2024-05-15 23:41:59 发布
阅读量244 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KaiLoveM/article/details/79154756
版权

继承与派生

类之间的关系：使用、包含、继承
使用：一个类使用了另一个类的对象，友元类、
包含：一个类中有另一个类的对象，例如，圆类 和 点类
继承：一个类是另一个类的特殊实例

继承是使用已经编写好的类来创建新类，新的类具有原有类的所有属性和操作，也可以在原有的基础上进行增补。
通常我们将新类称为派生类（子类），将被继承的类称为基类（父类）;

语法：

class 派生类: 继承权限 基类
{
};

继承权限有三种：public、protected、private

这里写图片描述
说明：
1.派生类中的 public 属性，在派生类的内部与外部都可以访问；
2.派生类中的 protected 属性，在派生类的内部可以访问，在外部无法访问；
3.派生类初次以 private 继承时，基类的public 和 protected 虽然都变成了 private，但依旧可以在类的内部进行访问，在类的外部不可访问。如果派生类又作为另一个类的基类，无论是以什么样的权限继承，都无法进行访问！
4.基类中的 private 成员无论以什么样的权限继承，都无法使用，但并不能认为没有从基类中继承过来。

举个动物类的例子，形象的说明：

#include <iostream>

using namespace std;

class Animal()
{
public: //基类有四个公有函数，init,sleep,eat,print;
    void init(int age, char *name)
    {
        this->age = age;
        this->name = name;
    }

    void eat()
    {
        cout << "动物： " << name << "在吃饭" << endl;    
    }

    void sleep()
    {
        cout << "动物： " << name << "在睡觉" << endl;
    }

    void print()
    {
        printf("age = %d , name  = %s\n", age, name);
    }
private:
    int age;
    char *name;
};

//公有继承时，基类中的四个函数都可被派生类对象直接调用
//派生类也可以实现自己的功能，例如，猫 捉老鼠
class Cat: public Animal 
{
public:
    void CatchMouse()
    {
        printf("猫 在捉老鼠\n");
    }
};

class Dog: public Animal
{
public:
    void LookHouse()
    {
        printf("狗 在看家\n");
    }
};

int main()
{
    Animal a;
    a.init(10, "动物");
    a.sleep();
    a.eat();
    a.print();

    Cat c;
    c.init(12, "蓝猫");
    c.sleep();
    c.eat();
    c.print();
    c.CatchMouse();

    Dog d;
    d.init(13, "哈士奇");
    d.sleep();
    d.eat();
    d.print();
    d.LookHouse();

    return 0;
}
//这个例子中，我们称 Aminal 为基类，Cat 和 Dog 为派生类

类型兼容性原则

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

首先我们定义两个类：Parent 和 Child 类，Child 公有继承 Parent

//基类有两个私有成员 a 和 b，两个公有函数 setAB、printAB
class Parent
{
public:
    void setAB(int a, int b)
    {
        this->a = a;
        this->b = b;
    }
    void printAB() const 
    {
        cout << "a = " << a << ", b = " << b << endl;
    }
private:
    int a;
    int b;
};

//派生类有自己的成员 c，自己的函数 setC、printC
class Child :public Parent
{
public:
    void setC(int c)
    {
        this->c = c;
    }

    void printC()
    {
        cout << "c = " << c << endl;
    }
private:
    int c;
};

1.派生类对象可当做基类对象直接使用
理由：派生类对象只是在基类对象的基础上，添加自己特有的成员

int main()
{
    Child p
    p.setAB(1, 2);
    p.printAB();   //a = 1, b = 2

    return 0;
}

2.基类指针可以指向派生类对象

int main()
{
    Child *c = new Child;
    c->setAB(1, 2);
    c->SetC(3);

    Parent *p;
    p = c;
    p->printAB();  // a = 1, b = 2

    //基类的指针指向派生类的对象，但基类指针只可使用基类中有的方法和成员，派生类中特有的，无法访问
    //p->printC();

    return 0;
}

3.基类引用可以直接引用派生类对象
原因：引用的本质 ==> 指针

void test(Parent *p)
{
    p->printAB();  // printAB(p)
}

void test(const Parent &p)
{
    p.printAB();  // printAB(p)
}

int main()
{
    Parent p;
    p.setAB(1,2);
    // test(&p);
    test(p);

    Child c;
    c.setAB(5,6);
    c.setC(9);
    // test(&c);
    test(c); //调用函数时，&p = c ⇒ Parent *const p = &c

    Parent &p1 = c; 
    p1.setAB(7, 8);
    p1.printAB(); // a = 7, b = 8

    return 0;
}

4.派生类对象可直接初始化基类对象

int main()
{
    Child c;
    c.setAB(1, 2);
    c.setC(3);

    //派生类对象是一种特殊的基类对象，因此在初始化时，会发生拷贝构造
    Parent p = c; //Parent(c) ⇒ Parent(const Parent &obj) ⇒ Parent(&c) 
                  //Parent(&c) ⇒ Parent(const Parent *const obj)

    return 0;
}

5.派生类对象可直接对基类对象赋值

int main()
{
    Child c;
    c.setAB(1, 2);
    c.setC(3);

    Parent p;
    //Parent &operator=(const Parent &obj)
    p = c;

    return 0;
}

继承中的构造和析构

派生类的组成：基类继承过来的成员 + 派生类自己定义的
原则：谁的成员，谁去初始化
对于基类的成员，在对象初始化列表中，显示调用基类的构造函数

构造函数执行的顺序：1.基类的构造函数、2.组合对象的构造函数、3.派生类自己的构造函数
析构函数执行的顺序与 构造函数 相反。

#include <iostream>

using namespace std;

class Obj
{
public:
    Obj(int a, int b)
    {
        this->a = a;
        this->b = b;

        cout << "调用了Obj的构造函数" << endl;
    }
    ~Obj()
    {
        cout << "调用了Obj的析构函数" << endl;
    }
private:
    int a;
    int b;
};

class Parent
{
public:
    Parent(int a, int b)
    {
        this->a = a;
        this->b = b;

        cout << "调用了Parent的构造函数" << endl;
    }
    ~Parent()
    {
        cout << "调用了Parent的析构函数" << endl;
    }
private:
    int a;
    int b;
};

class Child:public Parent
{
public:
    Child(int c) :Parent(1, 2),o1(2,3),o2(3,4)
    {
        this->c = c;
        cout << "调用了Child的构造函数" << endl;
    }
    ~Child()
    {
        cout << "调用了Child的析构函数" << endl;
    }

private:
    int c;
    Obj o1;
    Obj o2;
};

int main()
{
    Child c(1);

    return 0;
}

执行结果如下：
调用了Parent的构造函数
调用了Obj的构造函数
调用了Obj的构造函数
调用了Child的构造函数
调用了Child的析构函数
调用了Obj的析构函数
调用了Obj的析构函数
调用了Parent的析构函数

继承中的同名成员和同名函数

当基类成员变量（函数）和派生类成员变量（函数）重名时，默认使用派生类自己的成员（函数），如若想使用基类中的，使用域解析符 ：： 即可。

#include <iostream>

using namespace std;

class AA
{
public:
    void print()
    {
        printf("A 的成员函数\n");
    }
public:
    int a;
    int b;
};

class BB: public AA
{
public:
    void print()
    {
        printf("B 的成员函数\n");
    }
public:
    int a;
    int c;
};

int main()
{
    BB b;
    b.b = 2;
    b.c = 3;
    b.a = 1;        //默认使用派生类的成员
    b.AA::a = 4;    //使用域解析符，指明所属的类;
    b.print();      //B 的成员函数
    b.AA::print();  //A 的成员函数

    return 0;
}

继承中的重载问题

重载只能发生在一个类之中， 派生类不能重载基类的同名函数
当派生类重载基类的函数的时候，会将基类所有同名函数全屏蔽掉，不能再使用

重定义：派生类有和父类 成员函数原型一样的函数，叫函数重定义

#include <iostream>

using namespace std;


class Parent
{
public:
    void  print()
    {
        printf("a = %d, b = %d\n", a, b);
    }

    void func()
    {
        printf("基类： 无参\n");
    }

    void func(int a)
    {
        printf("基类： 有一个参数\n");
    }
public:
    int a;
    int b;
};

class Child : public Parent
{
public:
    // 派生类的同名成员函数会屏蔽基类的同名成员函数
    // 函数原型一样， 叫函数重定义
    void print()
    {
        printf("a = %d, c = %d\n", a, c);
    }

    void func(int a, int b)
    {
        printf("派生类： 有两个参数\n");
    }
public:
    int a;
    int c;
};

int main()
{
    Child c;
    c.Parent::a = 1;
    c.b = 2;
    c.a = 3;
    c.c = 4;

    // 默认使用派生类的函数
    c.print();

    c.Parent::print();

    c.Parent::func();
    //c.func(10);
    c.func(1, 2);

    return 0;
}

派生类中static关键字使用

#include <iostream>

using namespace std;

class A
{
public:
    int a;
    static int sa;
};

int A::sa = 10;

class B :public A
{
public:
    int b;
};

class C:public A
{
public:
    int c;
};

// 类的静态变量是所有派生类所共享的
// 静态变量存放在数据区，测算类的大小时，不包括静态变量
int main()
{
    cout << "sizeof B : " << sizeof B << endl; // sizeof B : 8
    B  b;
    b.sa = 123;

    cout << "C::sa = " << C::sa << endl; // C::sa = 123

    return 0;
}

多继承

当一个派生类有多个基类时，构造函数的执行顺序与继承时的声明顺序有关。
析构函数的执行顺序与 构造函数的执行顺序 相反

#include <iostream> 

using namespace std;

class AA
{
public:
    AA(int a, int b)
    {
        this->a = a;
        this->b = b;
        printf("AA 的构造函数被调用\n");
    }
    ~AA()
    {
        printf("AA 的析构函数被调用\n");
    }

    void printa()
    {
        printf("a = %d, b = %d\n", a, b);
    }
private:
    int a;
    int b;
};

class BB
{
public:
    BB(int a, int b)
    {
        this->c = a;
        this->d = b;
        printf("BB 的构造函数被调用\n");
    }
    ~BB()
    {
        printf("BB 的析构函数被调用\n");
    }
    void printb()
    {
        printf("c = %d, d = %d\n", c, d);
    }
private:
    int c;
    int d;

};

class CC :public AA, public BB
{
public:
    CC(int a) :AA(1, 2), BB(3, 4)
    {
        this->e = a;
        printf("CC 的构造函数被调用\n");
    }
    ~CC()
    {
        printf("CC 的析构函数被调用\n");
    }
    void printc()
    {
        printf("e = %d\n", e);
    }
private:
    int e;
};

void func1(AA &obj)
{
    obj.printa();
}

void func2(BB &obj)
{
    obj.printb();
}

int main()
{
    CC c(5);

    // 基类指针指向派生类对象的时候，指针会根据基类数据成员在派生类中的
    // 存储位置不同，做不同的偏移 
    func1(c);
    func2(c);

    AA *p = &c;
    BB *p1 = &c;
    printf("AA  %p\n", p);
    printf("BB  %p\n", p1);
    printf("&c  %p\n", &c);

    return 0;
}

执行结果如下：
AA 的构造函数被调用
BB 的构造函数被调用
CC 的构造函数被调用
a = 1, b = 2
c = 3, d = 4
AA  0115FDC0
BB  0115FDC8
&c  0115FDC0
CC 的析构函数被调用
BB 的析构函数被调用
AA 的析构函数被调用

内存模型：
这里写图片描述

多继承的二义性

1.普通继承时

#include <iostream>

using namespace std;

class Parent1
{
public:
    Parent1(int a, int b)
    {
        this->a = a;
        this->b = b;
        cout << "Parent1 构造函数被调用" << endl;
    }

    void  print1()
    {
        printf("a = %d, b = %d\n", a, b);
    }

public:
    int a;
    int b;
};

class Parent2
{
public:
    Parent2(int a, int d)
    {
        this->a = a;
        this->d = d;
        cout << "Parent2 构造函数被调用" << endl;
    }

    void  print2()
    {
        printf("c = %d, d = %d\n", a, d);
    }

public:
    int a;
    int d;
};

class C :public Parent1, public Parent2
{
public:
    C(int e) :Parent1(1, 2), Parent2(3, 4)
    {
        this->e = e;
        cout << "C 构造函数被调用" << endl;
    }
    void  printc()
    {
        printf("e = %d\n", e);
    }
private:
    int e;
};

int main()
{
    C c(10);

    printf("sizeof c = %d\n", sizeof(c));
    c.Parent1::a = 10;
    c.Parent2::a = 12;
    //c.a = 13;  编译器并不知道该调用哪一个基类的 a 
    c.print1();
    c.print2();
    c.printc();

    return 0;
}

运行结果如下：
Parent1 构造函数被调用
Parent2 构造函数被调用
C 构造函数被调用
sizeof c = 20
a = 10, b = 2
c = 12, d = 4
e = 10

内存模型：
这里写图片描述
2.虚继承
如果一个派生类从多个基类派生，而这些基类又有一个共同的基类，则在对该基类中声明的名字进行访问时，可能产生二义性，要使这个公共基类在派生类中只产生一个子对象，必须对这个基类声明为虚继承，使这个基类成为虚基类。

这里举个钻石型结构的例子

#include <iostream>

using namespace std;

class Parent
{
public:
    Parent(int a = 0)
    {
        this->a = a;
        cout << "Parent  构造函数被调用" << endl;
    }
public:
    int a;
};

class Parent1 :virtual public Parent
{
public:
    Parent1(int b) :Parent(1)
    {
        this->b = b;
        cout << "Parent1 构造函数被调用" << endl;
    }

    void  print1()
    {
        printf("b = %d\n", b);
        cout << "Parent1  构造函数被调用" << endl;
    }

public:
    int b;
};

class Parent2 :virtual public Parent
{
public:
    Parent2(int b) :Parent(3)
    {
        this->d = b;
        cout << "Parent2 构造函数被调用" << endl;
    }

    void  print2()
    {
        printf("d = %d\n", d);
    }

public:
    int d;
};

class C :public Parent1, public Parent2
{
public:
    C(int e) :Parent1(2), Parent2(4)
    {
        this->e = e;
        cout << "C 构造函数被调用" << endl;
    }
    void  printc()
    {
        printf("e = %d\n", e);
    }
private:
    int e;
};

int main()
{
    C c(10);

    printf("sizeof c = %d\n", sizeof(c));
    c.Parent1::a = 11;
    printf("a = %d\n", c.a);
    c.Parent2::a = 12;
    printf("a = %d\n", c.a);
    c.a = 13;
    printf("a = %d\n", c.a);

    return 0;
}

运行结果：
Parent  构造函数被调用
Parent1 构造函数被调用
Parent2 构造函数被调用
C 构造函数被调用
sizeof c = 24
a = 11
a = 12
a = 13

内存模型：
这里写图片描述

这里写图片描述

KaiLoveM
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
继承和派生
fighting123678的博客
04-19 378
继承 1、单继承和多继承 只能从一个基类派生的继承称为单继承，可以从多个基类派生的继承称为多继承。在单继承方式下，派生类只有一个基类；而在多继承方式下，派生类可以有多个继承。C++中既支持单继承，也支持多继承。 2、Protected 基类的protected成员虽然不能被派生类的外部函数访问，却能被其派生类直接访问。Protected成员可以在（1）基类的成员函数（2）基类的友元函数（3...
派生类与继承
cgsdjn的博客
12-09 973
#include <iostream> using namespace std; class Base{ public: void setx(int i) { x = i; } int getx() { return x; } public: int x; }; class Derived:public Base { public: void sety(int i) { y = i; } int gety() { return y; } void s.
派生和继承
liu_xinLL的博客
07-01 265
派生和继承 创建派生类对象时构造函数的调用次序
继承与派生（一）
努力进阶的小菜鸟
12-04 302
1.继承的作用： 代码复用 继承和派生， 基类和派生类 class Stu : public People 类标识 类名 访问限定符 基类类名 访问限定符一般都为public 2.派生类继承基类的什么东西 除了基类的构造和析构函数以外的所有成员 所以，派生类的构造需要自己实现 参考代码： class Base { ...
C++面向对象程序设计习题继承与派生.pdf
09-30
"C++面向对象程序设计习题继承与派生.pdf" 继承是面向对象程序设计中的一种重要机制，它允许一个类继承另一个类的属性和行为特征。通过继承，新类可以从现有类中获得特征，从而达到代码复用的目的。在C++中，继承...
第11章 继承与派生.doc
08-20
继承与派生 继承与派生是面向对象编程（Object-Oriented Programming，OOP）中两个重要的概念，它们之间存在着紧密的联系。继承是指在一个已存在的类基础上建立一个新类，而派生是指已存在的类产生一个新类。下面将...
C++ 课程作业 继承与派生 （motorcycle类设计（虚基类））
04-18
从bicycle和motorcar派生出motorcycle，观察虚基类对继承的影响。 定义一个motorcycle的对象，分别调用run()和stop(),观察构造/析构函数的调用情况。 注意：构造函数和析构函数中均为cout语句，说明哪个构造/析构...
c++继承和派生的理解
zhc_24的博客
10-01 723
定义  继承：在定义一个新的类B时，如果该类与某个已有的类A相似(指的是B拥有A的全部特点)，那么就可以把A作为一个基类，而把B作为基类的一个派生类(也称子类)。     派生类是通过对基类进行修改和扩充得到的。在派生类中，可以扩充新的成员变量和成员函数。 派生类拥有基类的全部成员函数和成员变量，不论是private、protected、public 。 在派生类的各个成员函数中，
派生和继承的各种方式
qq_44695317的博客
02-21 258
派生和继承的各种方式 派生和继承的各种方式 public（公有）继承[使用最频繁] 父类中定义的成员（数据成员和函数成员）被继承后，访问权限不变！ public --> public protected --> protected private --> private private（私有）继承 父类中定义的成员（数据成员和函数成员）被继承后，访问权限都变成private public --> private protected --> priva
继承与派生详解
最新发布
PumpkinYY的博客
05-15 1129
class Aprivate:protected:public://继承 A's members//定义 B's members在这里我们发现了B对于A的继承有三种方式private/protected/public，我们也用PPT中的一张图来说明这三种方式继承的区别和联系：当B以public方式继承A时，A的public类型在B中仍为public，A的protected类型仍为protected。
继承和派生初了解
weixin_43680743的博客
03-24 193
1、概述 子类（派生类）继承于父类（基类） 父类（基类）派生出子类（派生类） 继承的优点：减少代码的冗余，提高代码重用性 2、格式 Class 派生类名 ： 继承方式 基类名{ }； class 子类 ：继承方式 父类名{ }； 继承方式分类： public：公有继承 private：私有继承 protected：保护继承 父类个数分类： 单继承：指每个派生类只直接继承了一个基类的特征...
c++学习笔记（1）继承与派生
rwerty的博客
10-25 328
1.继承方式包括三种：public、private、protected。默认的继承方式是private 例：（1）公有方式继承  class A : public B { ....... }  （2）默认为私有继承 class A : B { ....... } 2、派生类中的成员包括从基类继承过来的成员和自己增加的成员。从基类继承过来的成员体现了派生类从基类继承而获得的共性
Java 错题整理
weixin_44047746的博客
05-26 1171
类Parent和Child定义如下： 1 ．class Parent{ 2. public float aFun(float a, float b) { } 3 ．} 4 ．class Child extends Parent{ 5 ． 6 ．} 将以下哪种方法插入行5是不合法的。（ ） A.float aFun(float a, float b){ } B.public int aFun(int a, int b) { } C.public float aFun(float p
知识单元四 异常处理
qq_64314976的博客
07-15 1164
1. 类Parent、Child定义如下： public class Parent { public float aFun(float a, float b) throws IOException { …… } } public class Child extends Parent{ } 将以下哪种方法插入行6是不合法的。（ ） [单选题] * float aFun(float a, float b){…… }(正确答案) public int aFun(int a, int...
C++继承与派生详解
"继承与派生是C++中面向对象编程的重要概念，它允许我们创建新的类（派生类）基于已存在的类（基类），以实现代码的重用和扩展。继承使得派生类能够继承基类的属性和方法，同时可以添加新的特性或者覆盖原有的行为。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值