实验4 继承

task2:

原：

#include<iostream>
#include<typeinfo>

using namespace std;

class graph{
    public:
        void draw(){
            cout << "graph::draw() : just as an interface" << endl;
        }
};

class rectangle : public graph{
    public: 
        void draw(){
            cout << "rectangle::draw(): programs of draw a rectangle\n" ;
        }
};

class circle : public graph{
    public:
        void draw(){
            cout << "circle::draw(): programs of draw a circle" << endl;
        } 
};

void fun(graph *ptr)
{
    cout << "pointr type: " << typeid(ptr).name() << endl;
    cout << "RTTI type: " << typeid(*ptr).name() << endl;  // RTTI运行时类型识别 
    ptr -> draw(); //virtual使得能在子类中重写基类函数，基类中被重写的函数称作虚函数。 
}
int main()
{
    graph g1;
    rectangle r1;
    circle c1;
    
    g1.draw();
    r1.draw();
    c1.draw();
    
    r1.graph::draw();//二元作用域分辨符 
    c1.graph::draw();
    
    cout << endl;
    
    fun(&g1);
    fun(&r1);
    fun(&c1);
    
    return 0;
} 

 

 

改：

#include<iostream>
#include<typeinfo>

using namespace std;

class graph{
    public:
        virtual void draw(){
            cout << "graph::draw() : just as an interface" << endl;
        }
};

class rectangle : public graph{
    public: 
        void draw(){
            cout << "rectangle::draw(): programs of draw a rectangle\n" ;
        }
};

class circle : public graph{
    public:
        void draw(){
            cout << "circle::draw(): programs of draw a circle" << endl;
        } 
};

void fun(graph *ptr)
{
    cout << "pointr type: " << typeid(ptr).name() << endl;
    cout << "RTTI type: " << typeid(*ptr).name() << endl;  // RTTI运行时类型识别 
    ptr -> draw(); //virtual使得能在子类中重写基类函数，基类中被重写的函数称作虚函数。 
}
int main()
{
    graph g1;
    rectangle r1;
    circle c1;
    
    g1.draw();
    r1.draw();
    c1.draw();
    
    r1.graph::draw();//二元作用域分辨符 
    c1.graph::draw();
    
    cout << endl;
    
    fun(&g1);
    fun(&r1);
    fun(&c1);
    
    return 0;
} 

 

 同名覆盖原则:

派生类与基类中有相同成员时，若未强行指名，则通过派生类对象使用的是派生类的同名成员；

如果要通过派生类的对象访问基类被覆盖的同名成员，需要加 对象名.基类名::同名成员 来限定。

 

二元作用域分辨符：

在派生类内部访问基类同名成员的语法形式：

基类名::数据成员名; 基类名::函数成员名(参数表);

如果是在派生类外通过派生类对象访问的话，前面还要加上“派生类对象名.”：

派生类对象名.基类名::数据成员名; 

派生类对象名.基类名::函数成员名(参数表); 

 

类型兼容原则：

类型兼容原则是指在需要基类对象的任何地方，都可以使用共有派生类的对象来替代。

（1）   派生类的对象可以赋值给基类对象

（2）   派生类的对象可以初始化基类的引用。

（3）   派生类对象的地址可以赋值给基类的指针。

task3:

task3.cpp

#include <iostream>
#include "electriccar.hpp"

int main()
{
    using namespace std;

    // test class of Car
    car oldcar("Audi", "a4", 2016);
    cout << "--------oldcar's info--------" << endl;
    oldcar.update_odometers(25000);
    oldcar.info();

    cout << endl;

    // test class of ElectricCar
    electriccar newcar("Tesla", "model s", 2016);
    newcar.update_odometers(2500);
    cout << "\n--------newcar's info--------\n";
    newcar.info();
}

electrical.hpp:

#include<string>
#include<iostream>
#include"Battery.hpp"
#include"car.hpp"

class electriccar : public  car{
    public:
        electriccar(string n_maker, string n_model, int n_year, int n_battery = 70):
            car(n_maker, n_model, n_year), battery(n_battery){ //使用基类构造函数 
            odometers = 0;
        }
        void info() {
            car::info();
            cout << "capacity: " << battery.get_capacity() << "-kwh" << endl;
        }
    private:
        Battery battery;
};

car.hpp

#include<iomanip>
#include<iostream>
#include<string>

using namespace std;

class car{
    public:
        car(string n_maker, string n_model, int n_year):
            maker(n_maker), model(n_model), year(n_year){
            odometers = 0;
        }
        void info() {
            cout << "maker: " << maker << endl;
            cout << "model: " << model << endl;
            cout << "year: "  << year  << endl;
            cout << "odometers: " << odometers << endl;
        }
        void update_odometers(int x){
            if(x < odometers){
                cout << "Invalid input. Please check your info." << endl;
            }else
                odometers = x;
        }
        int odometers;
    private:
        string maker;
        string model;
        int year;
};

Battery.hpp:

class Battery{
    public:
        Battery(int n_capacity = 70):capacity(n_capacity){}; 
        int get_capacity() {
            return capacity;
        }
    private:
        int capacity;    
};

 

 

task4:

#include <iostream>
#include "pets.hpp"

void play(machinepets *ptr)
{
    std::cout << ptr->get_nickname() << " says " << ptr->talk() << std::endl;
}

int main()
{
    petcats cat("miku");
    petdogs dog("da huang");

    play(&cat);
    play(&dog);
}

pets.hpp:

#include<string>

using namespace std;

class machinepets{
    public:
        string nickname;
        machinepets(const string s):nickname(s){};
        virtual string talk(){};
        string get_nickname() const{
            return nickname;
        }
    private:
        
};

class petcats : public machinepets{
    public:
        petcats(const string s): machinepets(s){};
        string talk(){
            return "miao wu~";
        }
};

class petdogs : public machinepets{
    public:
        petdogs(const string s): machinepets(s){};
        string talk(){
            return "wang wang~";
        }
};