实验四继承

2021-11-25 02:01:41 阅读：142 来源： 互联网

标签：基类 string 继承 HPP 实验派生类 include public

task2

//origin

#include<iostream>
#include<typeinfo>

using namespace std;

//definition og Graph
class Graph
{
public:
    //声明时加入关键词virtual
     void draw() { cout << "Graph::draw(): just as an interface\n"; };
};

//definition of Rectangle, derived from Graph
class Rectangle :public Graph
{
public:
    void draw()
    {
        cout << "Rectangle::draw(): programs of draws a rectangle\n";
    }
};

//definition of Circle, derived from Graph
class Circle :public Graph
{
public:
    void draw()
    { 
        cout << "Circle::draw() : programs of draws a rectangle\n";
    }
};

//definition of fun():as a call interface
void fun(Graph* ptr)
{
    //typeid：用于获取运行时类型信息
    cout << "Pointer type: " << typeid(ptr).name() << "\n";
    //Runtime Type Info的首字母缩写，运行时类型信息。
    cout << "RTTI typde: " << typeid(*ptr).name() << "\n";
    ptr->draw();
}

//test
int main()
{
    Graph g1;
    Rectangle r1;
    Circle c1;

    //call by object name
    g1.draw();
    r1.draw();
    c1.draw();

    cout << endl;

    //call by object name, and using the scope resolution operator::
    r1.Graph::draw();
    c1.Graph::draw();

    cout << endl;

    //call by pointer to Base class
    fun(&g1);
    fun(&r1);
    fun(&c1);
}

//after

同名覆盖原则：　　不同作用域声明的标识符的可见性原则：

　　　　如果存在两个或多个具有包含关系的作用域，外层声明了一个标识符，而内层没有再次声明同名标识符，那么外层标识符在内层依然可见，如果在内层声明了同名标识符，则外层标识符在内层不可见，　　　　　　　　　　

　　　　称内层标识符隐藏了外层同名标识符，这种现象称为隐藏规则。

　　二元作用域分辨符：　　作用域运算符（::）作用：　　　　（1）存在具有相同名称的局部变量时，访问全局变量。　　　　（2）在类之外定义类相关函数。
　　　　（3）访问类的静态变量。
　　　　（4）在多重继承的情况下，如果两个基类中存在相同的变量名，可以使用作用域运算符来进行区分。
　　　　（5）限定成员函数所属的类。类型兼容原则　　（1）派生类的对象可以赋值给基类对象

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

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

task 3

//battery.hpp

#ifndef BATTERY_HPP
#define BATTERY_HPP

#include<iostream>
#include<string>

using namespace std;

class Battery {
public:
    Battery(string cap = "70-kWh") :capacity(cap) {}
    string get_capacity(){
        return capacity;
    }
private:
    string capacity;
};

#endif

//car.hpp

#ifndef CAR_HPP
#define CAR_HPP

#include<iostream>

using namespace std;

class Car {
public:
    Car(string a, string b, int c, int d = 0) :maker(a), model(b), year(c), odometers(d) {}
    void info()
    {
        cout << "maker: " << maker << endl
             << "model: " << model << endl
             << "year: " << year << endl
             << "odometers: " << odometers << endl;
    }
    void update_odometers(int n)
    {
        if (n < odometers)
        {
            printf("数值有误!\n");
            return;
        }
        else
        {
            odometers = n;
        }
    }
private:
    string maker;
    string model;
    int year;
    int odometers;
};

#endif

//electricCar.hpp

#ifndef ELECTRIC_HPP
#define ELECTRIC_HPP

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

using namespace std;

class ElectricCar :public Car{
public:
    ElectricCar(string maker, string model, int year, int odo = 0, string b = "70-kMh") :
        Car(maker, model, year, odo), battery(b) {}
    void info()
    {
        Car::info();
        cout << battery.get_capacity() << endl;
    }
private:
    Battery battery;
};


#endif

//main.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,250,"250-kMh");
    newcar.update_odometers(25000);
    cout << "\n--------newcar's info--------\n";
    newcar.info();
}

task 4

//pets.hpp

#ifndef PETS_HPP
#define PETS_HPP

#include<iostream>
#include<string>

using namespace std;

class MachinePets {
public:
    MachinePets(const string s) :nickname(s) {};

    string get_nickname()
    {
        return nickname;
    }

    virtual string talk()
    {
        return "sdfaf";
    }
private:
    string nickname;
};

class PetCats :public MachinePets
{
public:
    PetCats(const string n) :MachinePets(n) {}
    string talk()
    {
        return "miao wu~ miao wu~";
    }
};


class PetDogs :public MachinePets 
{
public:
    PetDogs(const string n) :MachinePets(n) {}
    string talk()
    {
        return "wang~ wang~";
    }
};

#endif

//main.cpp

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

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

int main()
{
    PetCats cat("duo duo");

    PetDogs dog("da huang");

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

总结：

1. 类的继承：

　　构造函数直接写继承的类的名字

2. 类的组合：

　　在数据成员中增加别的类的类型的成员

3. 同名：

　　（1）如果派生类中声明了与基类成员函数同名的新函数，即使函数的参数表不同，从基类继承的同名函数的所有重载形式也会被隐藏。

　　（2）如果派生类的多个基类拥有同名的成员，同时，派生类又新增这样的同名成员，派生类将隐藏所有基类的同名成员。

　　　　唯一标识和访问派生类新增成员：

　　　　　　　对象名.派生类或对象指针名->成员名

　　使用继承的类的同名函数继承的类的名字::函数名

4.VS

　　VS中虚函数有返回值，则需要返回相应类型的一个值

标签：基类,string,继承,HPP,实验,派生类,include,public
来源： https://www.cnblogs.com/gujia/p/15601045.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

实验四 继承

实验四继承