【C++笔记】十二、类的继承

1.类的继承

#include <iostream>
using namespace std;
class BaseClass
{
protected:
    int mCode = 20;
public:
    int getCode();
};
int BaseClass::getCode()
{
    return mCode;
}

class MyClass : public BaseClass  //继承写法，MyClass可以使用BaseClass中public和protected下的内容
{
public:
    void setCode(int code);
};
void MyClass::setCode(int code)
{
    mCode = code;
}
int main(int argc, const char * argv[]) {
    // 类的继承
    //  1. 封装
    //  2. 继承
    //  3. 多态
    
    MyClass myClass;
    cout << myClass.getCode() << endl;
    myClass.setCode(432);
    cout << myClass.getCode() << endl;
    return 0;
}

2.子类构造方法调用父类的构造方法

#include <iostream>
using namespace std;
class ParentClass
{
private:
    int mCode = 10;
public:
    int getCode()
    {
        return mCode;
    }
    ParentClass(int code)
    {
        mCode = code;
    }
    ParentClass()
    {
        mCode = 123;
    }
};

class MyClass : public ParentClass
{
private:
    string mName = "abc";
public:
    MyClass() : ParentClass(345),mName("fgh")  // 在子类构造方法调用父类构造方法的写法， 后面是初始化mName的方法之一
    {
        //  mName = "abc";  // 初始化mName的顺序：mName先等于abc，再等于fgh，最后等于Bill
        //  mName = "fgh"
        mName = "Bill";
    }

    MyClass(int code) : ParentClass(code)// ParentClass()
    {
        
    }

    string getName()
    {
        return mName;
    }
};
int main(int argc, const char * argv[]) {
    // 派生类构造方法调用父类的构造方法
    
    MyClass myClass = MyClass();     // 创建子类对象时，会同时创建一次父类对象（创建就要初始化里面的变量），
//这样子类才能使用父类中的内容，使用子类没有参数的构造方法时，同时会调用父类没有参数的构造方法，
//如果此时父类自定义了一个有参数的构造方法且没有定义无参数的构造方法时，那么子类没有参数的构造方
//法就会调用父类有参数的构造方法，此时就会报错，这个报错有两个解决方法，1.在父类中定义一个没有参
//数的构造方法 2.在子类构造方法中显示的指定父类构造方法
    cout << myClass.getCode() << endl;  // 打印 345
    cout << myClass.getName() << endl;  // 打印 Bill

    MyClass *pMyClass = new MyClass(6789);
    cout << pMyClass->getCode() << endl;  // 打印 6789

    return 0;
}

3.虚方法与多态

#include <iostream>
using namespace std;

class Vehicle
{
private:
    string mName = "未知";
    float mMaxSpeed = 0;
public:
    virtual string getName()  // 虚方法，父类必须加virtual，子类可加可不加
    {
        return mName;
    }
    void setMaxSpeed(float maxSpeed)
    {
        
    }
    bool hasWheel()
    {
        return false;
    }
    int getWheelCount()
    {
        return 0;
    }
    
    bool canFly()
    {
        return false;
    }
};

class Car:public Vehicle
{
public:
    string getName()
    {
        return "小汽车";
    }
    bool hasWheel()
    {
        return true;
    }
    bool canFly()
    {
        return false;
    }
    int getWheelCount()
    {
        return 4;
    }
};

class Plane : public Vehicle
{
    string getName()
    {
        return "飞机";
    }
    bool hasWheel()
    {
        return true;
    }
    bool canFly()
    {
        return true;
    }
    int getWheelCount()
    {
        return 3;
    }

};

int main(int argc, const char * argv[]) {
 
    // 虚方法与多态
    Vehicle *vehicle = new Car();              // 用父类实例化一个子类
    cout << vehicle->getWheelCount() << endl;  // 打印 0，getWheelCount不是虚方法
    cout << vehicle->getName() << endl;        // 打印 小汽车，getName为虚方法
    
    return 0;
}

#include <iostream>
using namespace std;

class Vehicle
{
private:
    string mName = "未知";
    float mMaxSpeed = 0;
public:
    virtual string getName()
    {
        return mName;
    }
    void setMaxSpeed(float maxSpeed)
    {
        
    }
    bool hasWheel()
    {
        return false;
    }
    virtual int getWheelCount()
    {
        return 0;
    }
    
    bool canFly()
    {
        return false;
    }
};

class Car:public Vehicle
{
public:
    string getName()
    {
        return "小汽车";
    }
    bool hasWheel()
    {
        return true;
    }
    bool canFly()
    {
        return false;
    }
    int getWheelCount()
    {
        return 4;
    }
};

class Car1:public Car   // 此时，Car成了父类，要用到虚方法的时候，Car的方法前必须加virtual，Car1可加可不加
{
public:
    string getName()
    {
        return "小汽车1";
    }
};

class Plane : public Vehicle
{
    string getName()
    {
        return "飞机";
    }
    bool hasWheel()
    {
        return true;
    }
    bool canFly()
    {
        return true;
    }
    int getWheelCount()
    {
        return 3;
    }

};
int main(int argc, const char * argv[]) {
    // 虚方法与多态
    
    Vehicle *vehicle = new Car();
    vehicle = new Plane();  // 多态，同一个父类的变量，可以在不同时间表示不同子类的对象
    cout << vehicle->getWheelCount() << endl;  // 3
    cout << vehicle->getName() << endl;        // 飞机
    
   // Vehicle vehicle1 = Car();  // 必须定义成指针，否则不行
   // cout << vehicle1.getWheelCount() << endl;

    return 0;
}

4.protected访问控制

#include <iostream>
using namespace std;

class ParentClass
{
private:
    int code1 = 20;
protected:
    int code2 = 30;
public:
    int getCode1()
    {
        return code1;  // 内联方法，返回了私有成员
    }
};

class SubClass : public ParentClass
{
public:
    int getCode2()
    {
        return code2;  // 返回了父类的protected成员
    }
};

int main(int argc, const char * argv[]) {

    // protected，在类的外部和private类似，在子类中可以访问父类的public和protected
    // 即：protected用于外部访问时，和private类似，用于内部访问时，和public类似
    SubClass subClass;
    cout << subClass.getCode2() << endl;
    cout << subClass.getCode1() << endl;
    // 但是subClass.code1和subClass.code2都是无法访问的，因为此时在类外
   
    return 0;
}

5.抽象类和纯虚函数

#include <iostream>
using namespace std;

class ParentClass
{
public:
    virtual void process()
    {
        cout << "ParentClass.process" << endl;
    }
    virtual void process1() = 0;  //  纯虚函数，一旦类包含了纯虚函数，那么就不能用该类创建实例了
};

class MyClass : public ParentClass
{
public:
     void process1()
     {
     cout << "MyClass.process1" << endl;
     }
};

int main(int argc, const char * argv[]) {

    // 抽象类与纯虚函数
    MyClass *pMyClass = new MyClass();
    pMyClass->process();     // ParentClass.process
    pMyClass->process1();     // MyClass.process1
    delete pMyClass;         
    //ParentClass parentClass;  报错
    return 0;
}