实验四：继承

1.实验任务2

程序源码如下：

#include <iostream>
#include<typeinfo>

class Graph{
    public:
        virtual void draw(){
            std::cout<<"Graph::draw():just as an interface\n";
        }
};

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

class Circle : public Graph
{
    public:
        void draw(){
            std::cout<<"Circle::draw(): programs of draw a circle\n";
        }
};

void fun(Graph *ptr){
    std::cout << "Pointer type:"<<typeid(ptr).name()<<"\n";
    std::cout << "RTTI type:"<<typeid(*ptr).name()<<"\n";
    ptr -> draw();
}
int main(){
    Graph g1;
    Rectangle r1;
    Circle c1;
    g1.draw();
    r1.draw();
    c1.draw();
    
    std::cout << "\n";
    
    r1.Graph::draw();
    c1.Graph::draw();
    
    std::cout << "\n";
    fun(&g1);
    fun(&r1);
    fun(&c1);
}

修改之前截图为：

 

 

加virtual修改后的运行结果如图：

 

 

归纳总结：

1.可以观察到运行时ptr成功指向了派生类，但ptr指针本身还是Graph类的。前面的5，6，9数字和字母P是什么还暂时不知道。

2.当派生类出现与基类同名成员时，会优先运行派生类的函数成员，用二元作用域分辨符标识后可运行基类成员

如r1.Graph::draw();   c1.Graph::draw();

3.类型兼容原则：派生类对象可以被当作基类对象使用，但当作基类对象使用时，只能使用作为基类的那一部分接口。因此函数声明成员类型是Graph，draw（）必然显示是基类。

2.实验任务3

以下为Battery.hpp

#pragma once
class Battery {
public:
    int get_capacity() {
        return capacity;
    }
    Battery(int obj = 70):capacity(obj){}
private:
    int capacity;
};

以下为Car.hpp

#pragma once
#include<iostream>
#include<string>
using namespace std;
class Car {
private:
    string maker;
    string model;
    int year;
    int odometers;
public:
    Car();
    Car(string m1, string m2, int y) :maker(m1), model(m2), year(y), odometers(0) {};
    void info();
    void update_odometers(int n);
};
void Car::info() {
    cout << maker << endl;
    cout << model << endl;
    cout << year << endl;
    cout << odometers << endl;
}
void Car::update_odometers(int n) {
    if (n >= odometers)
        odometers = n;
    else
        cout << "data is error!";
}

以下为ElectricCar.hpp

ElectricCar.hpp

以下为task3.cpp

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

int main()
{
    using namespace std;

    // test class of Car
    Car oldcar("Audi", "a6", 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(12500);
    cout << "\n--------newcar's info--------\n";
    newcar.info();
}

 

 

 

 3.实验任务四

pets.hpp

#pragma once
#include<string>
#include<iostream>
using namespace std;
class MachinePets {
private:
    string nickname;
public:
    MachinePets();
    MachinePets(const string s):nickname(s){}
    const string get_nickname() {
        return nickname;
    }
    virtual string talk() {
        return"talk~";
    }
};
class PetCats : public MachinePets{
public:
    PetCats(const string st):MachinePets(st){}
    string talk() {
        return "miao wu~";
    }
};
class PetDogs :public MachinePets{
public:
    PetDogs();
    PetDogs(const string s1):MachinePets(s1){
        
    }
    string talk() {
        return "wang!wang!";
    }
};

 

task4.cpp

#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);
}

测试截图如下：

 

 归纳总结：

1.可以观察到运行时ptr成功指向了派生类，但ptr指针本身还是Graph类的。前面的5，6，9数字和字母P是什么还暂时不知道。

2.当派生类出现与基类同名成员时，会优先运行派生类的函数成员，用二元作用域分辨符标识后可运行基类成员

如r1.Graph::draw();   c1.Graph::draw();

3.类型兼容原则：派生类对象可以被当作基类对象使用，但当作基类对象使用时，只能使用作为基类的那一部分接口。因此函数声明成员类型是Graph，draw（）必然显示是基类

4.用typeid().name()获取类型名

5.在继承类中初始化时，构造函数放在大括号前面，不然会出现重定义的问题。