基类的继承，虚函数，覆盖和隐藏

编程语言 2018-08-12 16:16:11 阅读次数: 0

一、类与类之间关系：

  • 1、类与类之间可能会存在共性。
  • 2、类与类之间必定会有差异。
  • 3、为了节约开发时间和代码量，我们在设计类时可以把类的共享代码，抽象出来形成一个基础类（基类）。
  • 4、使用基类＋差异生成一个新的类的叫派生类

二、继承的语法

  • 1、在设计一个类时如果已有的类中有它需要的成员，它可以从已有的类中继承那些成员
  • 被继承的类叫 父类 或 基类
  • 继承类叫作 子类 或 派生类
class 类名 : 继承方式 基类1,继承方式 基类2,...
 {

 }
  • 2、子类会完全继承父类中的所有成员（包括哪些能访问的和不能访问的）。
3、在设计类时如何形成继承的关系？
  类的设计：
   a、根据问题找对象
   b、把对象中我们需要的属性和行为抽象出来
   c、把抽象出的结果记录在一个class中形成一个类
   d、把class类实例化构造对象
   e、对象调用成员函数解决问题

  • 继承就是在对对象抽象的结果进行归纳总结，找出它们的共性形成基类，再把基类＋差异派生出子类。

  • 4、 继承的优点：代码复用。
    子类在继承父类后可以节约大量的代码、节省开发时间、缩短开发周。

  • 5、 继承的缺点：

    a、继承会提高类与类之间的耦合度
    b、会降低代码的安全性和可维护性

三、使用继承要注意的问题

1、继承虽然可以获取父类中的所有成员，但子类中可以隐藏父类中的同名成员。
2、父子类中的函数不可以形成重载，只有在同一个作用域下的同名不同参、const属性的函数才能形成重载。
3、父类中的成员在子类的访问属性。
  • 父类中的 public 在子类中 可以访问
  • 父类中的 protected 在子类中 可以访问
  • 父类中的 private 在子类中 不可以访问
    访问属性
4、继承的方式
  • 不同的继承方式会影响父类成员变量成子类成员后它们的访问属性，也就是继承来的成员在类外的访问属性。
下面的图中的 继承方式不会影响基类在子类中的访问属性 因为在子类的访问属性 是由基类中的访问属性决定的继承方式的不同 只会影响 继承过来的在类外的访问属性。
  public 不变
  protected 公有变保护，其它不变
  private 全部变成私有的

继承方式的影响

总结：

  • 1）基类的私有成员在派生类中不能被访问，如果一些基类成员不想被基类对象直接访问，可以定义为保护成员，这样子类还可以访问
  • 2）public继承是一个接口继承，保持is-a原则（2.是什么？？），每个父类可用的成员对子类也可用，因为每个子类对象也是一个父类对象。
  • 3）protect/private继承基类的部分成员并未成为子类的一部分，是has-a的关系原则（3.是什么？）这种继承关系很少用，一般用public继承关系。
  • 4）不管哪种继承关系，在派生类内部都可以访问基类中的公有成员和保护成员，但是子类中的成员不能访问父类中的私有成员。
  • 5）使用struct时的默认继承关系是public,而class时的默认继承关系是private，最好是把继承方式写出来。

5、继承与转换

  • 1）子类对象可以赋值给父类对象。
  • 2）父类对象不可以赋值给子类对象。
  • 3）父类对象的指针和引用可以指向子类对象。
  • 4）子类对象的指针和引用不能指向父类对象，但是可以通过强制转化完成 代码测试
6、继承体系中的作用域
  • （1）在继承体系中基类和派生类都有独立的作用域。
  • （2）子类和父类中有同名成员，子类成员将屏蔽父类成员的直接访问。（在子类成员函数中，可以使用基类：：基类成员访问）
  • （3）注意尽量不要在继承体系中定义同名的成员。 代码测试
7、派生类的默认成员函数
  • 在继承关系里，派生类中如果没有显示定义这六个成员函数，编译系统则会默认合成六个成员函数，即构造函数、拷贝构造函数、析构函数、赋值操作符重载、取地址操作符重载、const修饰的取地址操作符重载。 代码测试
8、单继承和多重继承
  • （1）单继承：一个子类只有一个直接父类
  • （2）多继承：一个子类有两个或以上个直接父类
    单继承与多继承
9、菱型继承

l菱形继承

菱形继承对象模型:

代码测试

10、基类定义了static成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例

五、虚函数

1、子类中会隐藏父类中的同名函数，这种关系叫作隐藏。（详解请看 成员函数的重载、覆盖与隐藏）
2、在同一作用域下的同名函数，这种关系叫作重载。（详解请看 成员函数的重载、覆盖与隐藏）
3、如果父类中的函数添加 virtual 关键字，这种函数就叫作虚函数，子类中会覆盖父类同名的虚函数。
4、虚函数是实现多态的基础。

六、继承的构造、析构、拷贝

1、在继承时先调用父类的构造函数，再调用子类的构造函数
2、在继承中先调用子类的析构，再调用父类的析构。
3、在调用拷贝构造时会先调用父类的拷贝构造，再调用子类的拷贝构造。
4、在C++中继承可以有多个父类，在构造时会按继承的顺序调用父类的构造函数。
5、在析构时子类会先调用自己的析构函数，然后按照继承表的逆序调用析构函数。

课前准备：
实现一个学生类
成员变量：姓名、性别、年龄、学号
成员函数：吃饭、睡觉、学习
实现一个教师类
成员变量：姓名、性别、年龄、工号
成员函数：吃饭、睡觉、授课
实现一个班长：

#include <iostream>
#include <string.h>

using namespace std;

class Man
{
public:
 char name[20];
 char sex;
 short age;
 Man(const char* _name="",char _sex='f',short _age=1)
 {
  strcpy(name,_name);
  sex = _sex;
  age = _age;
 }
 void eat(const char* food = "饭")
 {
  cout << "我在吃:" << food << endl;
 }

 virtual void sleep(void)
 {
  cout << "我累了，我要休息"<< endl;
 }
};

class Student : public Man
{
 int stu_id;
public:
 Student(const char* _name="",char _sex='m',
  short _age=8,int _stu_id=180601)
 {
  strcpy(name,_name);
  sex = _sex;
  age = _age;
  stu_id = _stu_id;
 }
 void sleep(void)
 {
  cout << "我学习累了，我要休息"<< endl;
 }

 void study(void)
 {
  cout << "怕什么真理无穷，进一步有进一步的欢喜" << endl; 
 }
};

class Teacher : public Man
{
 int work_id;
public:
 Teacher(const char* _name="",char _sex='m',
  short _age=26,int _work_id=161001)
 {
  strcpy(name,_name);
  sex = _sex;
  age = _age;
  work_id = _work_id;
 }

 void lecture(void)
 {
  cout << "传道、授业、解惑" << endl; 
 }
 void sleep(void)
 {
  cout << "我上课累了，我要休息"<< endl;
 }
};

int main()
{
 Man* m = new Student;
 m->eat();
 m->sleep();
 m = new Teacher;
 m->eat();
 m->sleep();
}

#include <iostream>
#include <string.h>

using namespace std;

class Zoon
{
protected:
 char type[20];
 char name[20];
public:
 Zoon(const char* type,const char* name)
 {
  strcpy(this->type,type);
  strcpy(this->name,name);
  cout << "构造一只动物" << endl;
 }
 void eat(void)
 {
  cout << name << "在吃食物" << endl;
 }
 ~Zoon()
 {
  cout << "一只动物去世了" << endl;
 }
};

class Dog : public Zoon
{
public:
 Dog(const char* type,const char* name):Zoon(type,name)
 {
  cout << "构造一条狗" << endl;
 }
 void cry(void)
 {
  cout << name << ":汪汪" << endl;
 }
 ~Dog()
 {
  cout << "一只狗去世了" << endl;
 }
};

class Mall : public Zoon
{
public:
 Mall(const char* type,const char* name):Zoon(type,name)
 {

 }
 void cry(void)
 {
  cout << name << ":买买买" << endl;
 }

};

int main()
{
 //Mall t("波斯","天猫");
 //t.cry();
 Dog g("博美","樱桃");
 g.cry();
}

#include <iostream>

using namespace std;

class A
{
public:
 void func1()
 {
  cout << "func1" << endl;
 }
 void func2()
 {
  cout << "func2" << endl;
 }
 int i;
};

class B: protected A
{
public:
 B(int a)
 {
  //想要访问 i变量 要加域限定符
  A:: i= a; 
 }
 void func3()
 {
  //同理
  A::func1();
  cout << "func3" << endl;
 }
 void func4()
 {
  //当继承方式为protected 继承时 公有-> 保护 外部无法访问 要给一个接口
  cout << i << endl;
  cout << "func4" << endl;
 }
};



int main()
{
 B b(5);
 //b.func1();
 //b.func2();
 b.func3();
 b.func4();
}

#include <iostream>
using namespace std;

class Person
{
public:
    void Display()
    {
        cout << _name << endl;
    }
protected:
    string _name;
};

class Student : public Person
{
public:
    int _num;
};

void Test()
{
    Person p;
    Student s;

    //子类对象可以赋值给父类对象
    p = s;
    //父类对象不可以赋值给子类对象
    //s = p;//error

    //父类对象的指针和引用可以指向子类对象
    Person *p1 = &s;
    Person& r1 = s;

    //子类对象的指针和引用不能指向父类的对象(但是可以通过强制类型转化完成)
    Student *p2 = (Student*)&p;
    Student& r2 = (Student&)p;
}
int main()
{
 Test();
}

返回

#include <iostream>
using namespace std;

class Person
{
public:
    Person(const char* name = "", int id = 0):_name(name), _num(id)
    {

    }
protected:
    string _name; //姓名
    int _num; //身份证
};

class Student : public Person
{
public:
    Student(const char *name, int id, int stuNum):Person(name, id), _num(stuNum)
    {

    }

    void DisplayNum()
    {
        cout << "身份证：" << Person::_num << endl;
        cout << "学号" << _num << endl;
    }
protected:
    int _num; //学号
};

void Test()
{
    Student s1("paul", 110, 1);
    s1.DisplayNum();
}

int main()
{
    Test();
    return 0;
}

返回

#include <iostream>

using namespace std;

class Person
{
public:
    Person(const char* name):_name(name)
    {
        cout << "Person()" << endl;
    }

    Person(const Person& p):_name(p._name)
    {
        cout << "Person(const Person& p)" << endl;
    }

    Person& operator = (const Person& p)
    {
        cout << "Person operatpr = (const Person& p)" << endl;
        if (this != &p)
        {
            _name = p._name;
        }
        return *this;
    }

    ~Person()
    {
        cout << "~person()" << endl;
    }

protected:
    string _name;//姓名
};


class Student : public Person
{
public:
    Student(const char* name, int num):Person(name), _num(num)
    {
        cout << "student()" << endl;
    }

    Student(const Student& s):Person(s),_num(s._num)
    {
        cout << "Student(const Student& s)" << endl;
    }

    Student& operator = (const Student& s)
    {
        cout << "Student& operator = (const Student& s)" << endl;
        if (this != &s)
        {
            Person::operator=(s);
            _num = s._num;
        }
        return *this;
    }

    ~Student()
    {
        cout << "~Student()" << endl;
    }
private:
    int _num; //学号
};

void Test()
{
    Student s1("jack", 18);
    Student s2(s1);
    Student s3("rose", 17);
    s1 = s3;
}

int main()
{
    Test();

    return 0;
}
//程序运行结果
/*
Person() s1先调用基类构造函数
student() s1然后调用子类构造函数

Person(const Person& p) s2基类拷贝构造
Student(const Student& s) s2子类拷贝构造

Person() s3先调用基类构造函数
student() s3然后调用子类构造函数

Student& operator = (const Student& s) 赋值构造
Person operatpr = (const Person& p) 赋值构造

~Student() s1先调用派生类析构函数
~person() 再调用基类析构函数

~Student() s2先调用派生类析构函数
~person() 再调用基类析构函数

~Student() s3先调用子类析构函数
~person() 再调用基类构造函数
*/

返回 

//菱形继承
class Person
{
public:
    string _name;//姓名
};

class Student : public Person
{
protected:
    int _num; //学号
};

class Teacher : public Person
{
protected:
    int _id; //职工编号
};

class Assistant : public Student, public Teacher
{
protected:
    string _majorCorse; //主修课程
};

void Test()
{
    Assistant a;
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
}

int main()
{
    Test();
    system("pause");
    return 0;
}

返回

猜你喜欢

转载自blog.csdn.net/weixin_42205987/article/details/81569813
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022