c++的继承

c++的继承  子类继承父类元素 父类派生子类元素

在继承中 原有类称为基类或者父类 新类称为子类或者是派生类

子类继承所有父类的成员和函数并且在父类成员的基础上增加了新的成员

当子类成员或者函数和父类重名的时候父类得到隐藏优先使用子类新的成员

类的成员函数：默认构造 析构 拷贝构造 重载

父类构造和析构不能用于子类 子类需要用到构造和析构的时候需要自己重新区写

子类构造必须调用父类构造 如果没有显式调用 那就调用父类的无参构造

子类先调用父类的构造 然后调用子类的构造 再调用子类的析构再调用父类的构造

下图是继承时：类的访问权限 类内成员默认私有

头文件people.h

#pragma once
#include<iostream>
using namespace std;
class people
{
protected:
    char name[20];
    char sex;
    int age;
public:
    people();
    ~people();
    people(int x);
    void eat();
    void sleep();
    void getup();
};

class student :public people//学生类继承人类 人类派生学生类
{
    float score;//在继承父类的成员变量的同时有自己的成员 
    char name[10];//默认私有 重写父类中的成员变量 
public:
    void fun()//新加的属性
    {
        sex = 'M';//调用父类中protect里的sex成员
        eat();//默认输出子类的函数
        cout << name << endl;//子类定义的成员
        cout << people::name << endl;//父类隐藏的成员
    }
    void eat(){
        cout << "按时吃饭" << endl;//学生类类中eat函数的输出
    }
    student() :people(1)//子类的构造函数必须调用父类的构造函数
        //子类继承父类的成员 初始化交给父类的构造函数
    {
        //people(1);错误的方式  创建了一个临时对象
    }
    ~student(){
        cout << "调用子类析构" << endl;//子类定义的成员
    }
};

class A
{
protected:
    int x;
public:
    A(int x = 0) :x(x){}//显式调用x 
    ~A(){}
    A operator+(const A&a)//重载加法
    {
        return A(x + a.x);
    }
};
class B :public A//B类继承A类
{
protected:
    int y;
public:
    B(int x = 0, int y = 0) :A(x), y(y){}//给A类中x显示赋值x 给b中y利用初始化形参列表赋值
    ~B(){}
    B operator+(const B&b){
        B c;
        c.x = x + b.x;
        c.y = y + b.y;
        return c;
    }
};
void fun2();//全局变量中定义 调用头文件中直接使用

头文件中定义类 在.cpp文件中声明类的方法

#include "people.h"


people::people()
{
}
people::people(int x){
    cout << "调用有参构造" << endl;
}
void eat(){ cout << "吃饭" << endl; }
void sleep(){ cout << "睡觉" << endl; }
void getup(){ cout << "8点起床" << endl; }
people::~people()
{
    cout << "调用析构函数" << endl;
}
void fun2(){//在头文件people中调用fun2方法
    A a(1); //给类a中的x显示赋1
    B b(1, 2);//调用类b的构造方法
    B c(3, 4);//与上一个式子功能相同 在类b中构造
    a + c;//重载运算符在类B和类A中同时定义 保证类的加法可以进行
}

 

主函数

#include"people.h"
int main()
{
    A a;//类外定义对象的时候自动调用
    A b = a;//同类对象初始化 调用拷贝构造

    {
        student Mn;//先调用父类的有参构造 再调用子类有参构造 再调用子类析构 再调用父类析构
        Mn.eat();//访问学生类中的eat函数 父类函数隐藏
        cout << sizeof(Mn) << endl;
    }//利用作用域来显示调用析构函数的次数
    people peo;
    //peo.sex;//私有成员可以访问但不可调用
    cin.get();
    return 0;
}