精华内容
下载资源
问答
  • c++实验5继承与派生
    2021-11-07 19:22:58

    [实验任务五]附加题

    以实例验证公有继承,保护继承,私有继承的不同

    实验要求:

    1.注意加上必要的输入输出提示;

    2.注意开头的标注部分,加上自己的姓名以及修改日期;

    3.针对以下两种情况进行测试:(1)派生类中的新增成员访问从基类继承的成员(2)通过派生类对象访问从基类继承的成员。

    源程序清单及结果截图:

    #include <iostream>
    using namespace std;
    
    class Base         
    {
    public: 
        Base(int nId) {mId = nId;}
        int GetId() {mId++;cout<< mId<<endl;return mId;}
    protected:
        int GetNum() {cout<< 0 <<endl;return 0;}
    private: 
        int mId; 
    };
    
    class Child : public Base
    {
    public:
        Child() : Base(7) {;}
        int GetCId() {return GetId();}    //新增成员可以访问公有成员
        int GetCNum() {return GetNum();} //新增成员可以访问保护成员无法访问基类的私有成员
                                          
    protected:
        int y;
    private:
        int x;
    };
    
    int main() 
    { 
        Child child;
        child.GetId();        //派生类的对象可以访问派生类继承下来的公有成员
        //child.GetNum();     //无法访问继承下来的保护成员
        child.GetCId();   
        child.GetCNum();      //派生类对象可以访问派生类的公有成员
        //child.x;
        //child.y;            //无法访问派生类的保护成员y和私有成员x
        return 0;
    }
    
    class Child : protected Base
    {
    public:
        Child() : Base(7) {;}
        int GetCId() {return GetId();}   //可以访问基类的公有成员和保护成员
        int GetCNum() {return GetNum();}
    protected:
        int y;
    private:
        int x;
    };
    
    int main() 
    { 
        Child child;
        //child.GetId();//派生类对象访问不了继承的公有成员
        //child.GetNum(); //无法访问
        child.GetCId();
        child.GetCNum();
        return 0;
    }
    class Child : private Base
    {
    public:    
    Child() : Base(7) {;}
        int GetCId() {return GetId();}   //可以访问基类的公有成员和保护成员
        int GetCNum() {return GetNum();}
    protected:
        int y;
    private:
        int x;
    };
    
    int main() 
    { 
        Child child;
        //child.GetId();//派生类对象访问不了继承的公有成员
        //child.GetNum(); //派生类对象访问不了继承的保护成员 
        child.GetCId();
        child.GetCNum();
        return 0;
    }
    

    public继承方式

    基类中所有public成员在派生类中为public属性;

    基类中所有protected成员在派生类中为protected属性;

    基类中所有private成员在派生类中不可访问。

    2) protected继承方式

    基类中的所有public成员在派生类中为protected属性;

    基类中的所有protected成员在派生类中为protected属性;

    基类中的所有private成员在派生类中仍然不可访问。

    3) private继承方式

    基类中的所有public成员在派生类中均为private属性;

    基类中的所有protected成员在派生类中均为private属性;

    基类中的所有private成员在派生类中均不可访问

    更多相关内容
  • 实验C++中的继承与派生实验目的 理解C++继承与派生的概念 掌握C++中各种不同继承方式的访问属性差别 掌握单继承与继承的实现方法 掌握派生类构造函数析构函数的实现及调用顺序 掌握虚基类的使用方法 二...
  • C++实验7 继承与派生

    千次阅读 多人点赞 2020-04-11 11:19:10
    实验继承与派生 1 实验目的 学习继承与派生的相关理论,熟悉不同继承方式下对基类成员的访问方式,包括以下几个方面: (1)学习声明和使用类的继承关系,声明派生类; (2)熟悉不同继承方式下,对基类成员的...

    实验七 继承与派生

    1 实验目的

    学习继承与派生的相关理论,熟悉不同继承方式下对基类成员的访问方式,包括以下几个方面:
    (1)学习声明和使用类的继承关系,声明派生类;
    (2)熟悉不同继承方式下,对基类成员的访问控制;

    2 实验内容

    2.1 停车场程序

    (1)问题描述

    请根据题目要求完成简单的停车场管理程序。
    1.停车场(Park)有 N 个停车位(space),每个停车位可以停放不同类型的
    汽车(Automobile),包括卡车(Truck)、轿车(Car)、公交车(Bus),但同一时刻一个停车位只能停放 0 或 1 辆汽车。如果没有空余停车位,显示提示信息,但不会为车辆安排停车位。
    2.程序模拟车辆停车的情况:新来车辆时如果有空位,按顺序为该车分配停车位;车辆开走时,应交纳停车费。
    3.停车场可以显示当前停放的车辆的车牌号码,以及当前的全部停车费收入(income)。
    4.定义汽车基类 Automobile,包括车牌号码(字符串)成员数据。
    5.定义派生类 Truck、Car、Bus。这些车辆除了拥有车牌号码之外,还各自
    拥有不同的属性。Truck 还包括载重量属性(浮点数,单位吨);Car 还拥有品牌属性(字符串),Bus 还包括核定载员数量(整型)。此外,每个派生类中要实现 pay()函数,用于显示车辆信息并交纳停车费。其中,Truck 收费 3 元/次,Car 收费 1 元/次,Bus 收费 2 元/次。

    (2)问题要求

    编写程序,测试上述所要求的各种功能。要求创建新的工程项目 ParkManager,
    添加必要的源文件和头文件,并在程序适当的位置中编写注释。

    class Automobile {}; // 汽车类
    class Park {}; // 停车场类
    int main() {
    cout << "请输入停车位数量:";
    cin >> N;// 输入停车位数量,此处输入2
    Park *park = new Park(N);// 创建一个停车场对象
    Car car1("鲁B-12345","奥迪A6"); // 创建轿车对象
    car1.enter(park); // car1进入停车场,分配停车位
    Truck truck("鲁B-23456", 15); // 创建卡车对象
    truck.enter(park); // truck进入停车场,分配车位
    car1.leave(park); // car1离开停车场,缴纳停车费
    Bus bus("鲁B-34567", 50); // 创建公交车对象
    bus.enter(park); // bus进入停车场,分配车位
    /* 显示当前停放的车辆的车牌号码,以及当前的全部停车费收入*/
    park->showInfo();
    Car car2("鲁B-45678","宝马320"); // 创建轿车对象
    car2.enter(park); 
    // car2进入停车场,分配停车位。因为没有空余停车位,所以无法分配
    bus.leave(park); // bus离开停车场,缴纳停车费
    truck.leave(park); // truck离开停车场,缴纳停车费
    /* 显示当前停放的车辆的车牌号码,以及当前的全部停车费收入*/
    park->showInfo();
    delete park;
    return 0;
    } 
    

    (3)程序执行结果

    程序执行结果如下:
    请输入停车位数量:2 鲁B-12345进入停车场,分配停车位
    鲁B-23456进入停车场,分配停车位
    鲁B-12345离开停车场,缴纳停车费1元
    鲁B-34567进入停车场,分配停车位
    停车场目前停放了2辆汽车:鲁B-23456,鲁B-34567,共收入1元停车费
    无法为鲁B-45678分配停车位
    鲁B-34567离开停车场,缴纳停车费2元
    鲁B-23456离开停车场,缴纳停车费3元
    停车场目前停放了0辆汽车,共收入6元停车费

    提示:停车场的停车位要用Automobile的指针数组表示。

    Automobile **spaces;
    spaces = new Automobile*[N];
    spaces[i] = &car1;
    delete[] spaces;
    

    源代码

    #include <iostream>
    #include <string>
    
    using namespace std;
    
    class Automobile;
    
    class Park {
    public:
    	Park(int N);
    	~Park();
    	void showInfo();
    	bool assignSpace(Automobile *pa);
    	bool reclaimSpace(Automobile *pa, int fee);
    private:
    	Automobile **spaces;
    	int income;
    	int N;
    	int numAuto;
    };
    
    class Automobile {
    public:
    	Automobile(string plateNO);
    	void enter(Park &park);
    	void leave(Park &park);
    	string getPlateNO();
    
    protected:
    	string plateNO;
    };
    
    Park::Park(int N) {
    	spaces = new Automobile*[N];
    	for (int i = 0; i < N; i++)
    		spaces[i] = NULL;
    	income = 0;
    	this->N = N;
    	numAuto = 0;
    }
    
    Park::~Park() {
    	delete[] spaces;
    }
    
    void Park::showInfo() {
    	if (numAuto == 0)
    		cout << "停车场目前停放了" << numAuto << "辆汽车,共收入" << income << "元停车费";
    	else {
    		cout << "停车场目前停放了" << numAuto << "辆汽车:";
    		for (int i = 0; i < N; i++)
    			if (spaces[i] != NULL)
    				cout << spaces[i]->getPlateNO() << ",";
    
    		cout << "共收入" << income << "元停车费" << endl;
    	}
    }
    
    bool Park::assignSpace(Automobile *pa) {
    	for (int i = 0; i < N; i++) {
    		if (spaces[i] == NULL) {
    			spaces[i] = pa;
    			numAuto++;
    			cout << pa->getPlateNO() << "进入停车场,分配停车位" << endl;
    			return true;
    		}
    	}
    	cout << "无法为" << pa->getPlateNO() << "分配停车位" << endl;
    	return false;
    }
    
    bool Park::reclaimSpace(Automobile *pa, int fee) {
    	for (int i = 0; i < N; i++) {
    		if (spaces[i] == pa) {
    			spaces[i] = NULL;
    			numAuto--;
    			income += fee;
    			cout << pa->getPlateNO() << "离开停车场,缴纳停车费" << fee << "元" << endl;
    			return true;
    		}
    	}
    	cout << "停车场中没有车牌为" << pa->getPlateNO() << "的汽车";
    	return false;
    }
    
    Automobile::Automobile(string plateNO) :
    		plateNO(plateNO) {
    }
    
    void Automobile::enter(Park &park) {
    	park.assignSpace(this);
    }
    
    void Automobile::leave(Park &park) {
    
    }
    
    string Automobile::getPlateNO() {
    	return plateNO;
    }
    
    class Truck: public Automobile {
    public:
    	Truck(string plateNO, double capacity) :
    			Automobile(plateNO), capacity(capacity) {
    	}
    	void leave(Park &park);
    protected:
    	double capacity;
    };
    
    void Truck::leave(Park &park) {
    	park.reclaimSpace(this, 3);
    }
    
    class Car: public Automobile {
    public:
    	Car(string plateNO, string brand) :
    			Automobile(plateNO), brand(brand) {
    	}
    	void leave(Park &park);
    protected:
    	string brand;
    };
    
    void Car::leave(Park &park) {
    	park.reclaimSpace(this, 1);
    }
    
    class Bus: public Automobile {
    public:
    	Bus(string plateNO, int numPassengers) :
    			Automobile(plateNO), numPassengers(numPassengers) {
    	}
    	void leave(Park &park);
    protected:
    	int numPassengers;
    };
    
    void Bus::leave(Park &park) {
    	park.reclaimSpace(this, 2);
    }
    
    int main() {
    	int N = 0;
    	cout << "请输入停车位数量:";
    	cin >> N; // 输入停b车位数量,此处输入2
    
    	Park park(N); // 创建一个停车场对象
    
    	Car car1("鲁B-12345", "奥迪A6"); // 创建轿车对象
    	car1.enter(park); // car1进入停车场,分配停车位
    
    	Truck truck("鲁B-23456", 15); // 创建卡车对象
    	truck.enter(park); // truck进入停车场,分配车位
    
    	car1.leave(park); // car1离开停车场,缴纳停车费
    
    	Bus bus("鲁B-34567", 50); // 创建公交车对象
    	bus.enter(park); // bus进入停车场,分配车位
    
    	/* 显示当前停放的车辆的车牌号码,以及当前的全部停车费收入*/
    	park.showInfo();
    
    	Car car2("鲁B-45678", "宝马320"); // 创建轿车对象
    	car2.enter(park);
    	// car2进入停车场,分配停车位。因为没有空余停车位,所以无法分配
    
    	bus.leave(park); // bus离开停车场,缴纳停车费
    	truck.leave(park); // truck离开停车场,缴纳停车费
    
    	/* 显示当前停放的车辆的车牌号码,以及当前的全部停车费收入*/
    	park.showInfo();
    
    	return 0;
    }
    
    
    展开全文
  • c++程序设计 继承与派生实验(二) 1. 进一步掌握类的派生与继承的概念、应用方法 2. 掌握继承方式对成员访问权限的影响 3. 掌握虚基类的用法
  • c++实验8 继承与派生上机练习题.doc
  • C++实验继承与派生

    千次阅读 2020-08-27 11:12:30
    C++实验: 继承派生 1. 实验目的 (1) 了解继承在面向对象程序设计中的重要作用。 (2) 进一步掌握继承派生的概念。 (3) 掌握通过继承派生出一个新的类的方法。 (4) 了解虚基类的作用方法。 2. 实验内容...

    C++实验: 继承与派生

    1. 实验目的

    (1) 了解继承在面向对象程序设计中的重要作用。

    (2) 进一步掌握继承与派生的概念。

    (3) 掌握通过继承派生出一个新的类的方法。

    (4) 了解虚基类的作用与方法。

    2. 实验内容

    (1) 将程序片段用公用继承的方式补充和改写完整;

    (2) 将程序片段用保护继承的方式补充和改写完整;

    (3) 比较两种继承方式,考虑二者在什么情况下不能替代;

    (4) 使用多重继承方式派生出新类。

    3.源代码

    #include "pch.h"
    #include<iostream>
    using namespace std;
    class Student
    { public:
        void get_value()
          {
    cin >> num >> name >> sex;
    }
    
    void display()
      {
    cout << "num:" << num << endl;
    cout << "name:"<< name << endl;
    cout << "sex:"<< sex << endl;
    }
    
    private:
        int num;
        char name[10];
        char sex;
    };
    
    class Student1 :public Student
    {
    public:
        void get_value_1()
        {
             get_value();
             cin>> age >> addr;
        }
    
        void display_1()
        {
             cout<< "age:" << age << endl;
             cout<< "address:" << addr << endl;
        }
    private:
        int age;
        char addr[30];
    };
    
    int main()
    {
        Student1 stud1;
        stud1.get_value_1();
        stud1.display();
        stud1.display_1();
        return 0;
    }
    #include "pch.h"
    #include<iostream>
    using namespace std;
    
    class Student
    {
    public:
        void get_value();
        void display();
    protected:
       int num;
       char name[10];
       char sex;
    };
    
    void Student::get_value()
    {
        cin >> num >> name >> sex;
    }
    
    void Student::display()
    {
        cout<< "num:" << num << endl;
        cout<< "name:" << name << endl;
        cout<< "sex:" << sex << endl;
    }
    
    class Student1 :protected Student
    {
    public:
        void get_value_1();
        void display1();
    private:
        int age;
        char addr[30];
    };
    
    void Student1::get_value_1()
    {
        get_value();
        cin>>age>>addr;
    }
    
    void Student1::display1()
    {
        cout<< "num:" << num << endl;
        cout<<"name:"<< name << endl;
        cout<< "sex:" << sex << endl;
        cout<<"age:"<< age << endl;
        cout<<"address:" << addr << endl;
    }
    
    int main()
    {
        Student1 stud1;
        stud1.get_value_1();
        stud1.display1();
        return 0;
    }
    #include "pch.h"
    #include<iostream>
    using namespace std;
    
    class Student
    {public:
        void get_value();
        void display();
    protected:
        int num;
        char name[10];
        char sex;
    };
    
    void Student::get_value()
    {
        cin >> num >> name >> sex;
    }
    
    void Student::display()
    
    {
        cout<< "num:" << num << endl;
        cout<< "name:" << name << endl;
        cout<< "sex:"<< sex << endl;
    }
    
    class Student1:public Student
    {public:
        void get_value_1();
        void display1();
    private:
        int age;
        char addr[30];
    };
    
    void Student1::get_value_1()
    {
        get_value();
        cin >> age >> addr;
    }
    
    void Student1::display1()
    {
        cout<< "num:"<<num<< endl;
        cout<< "name:"<<name<< endl;
        cout<< "sex:"<<sex<< endl;
        cout<< "age:"<<age<< endl;
        cout<< "address:"<<addr<< endl;
    }
    
    int main()
    {
        Student1 stud1;
        stud1.get_value_1();
        stud1.display1();
        return 0;
    }
    #include "pch.h"
    #include<string>
    #include <iostream>
    using namespace std;
    
    class Teacher
    {public:
        Teacher(string nam, int a, char s, string tit, string ad, string t);
    
        void display();
    protected:
        string name;
        int age;
        char sex;
       string title;
        string addr;
        string tel;
    };
    
    Teacher::Teacher(string nam,int a,char s, string tit,string ad,string t):name(nam),age(a),sex(s),title(tit),addr(ad),tel(t){}
    
    void Teacher::display()
    {
        cout<< "name:" << name << endl;
        cout<< "age:" << age << endl;
        cout<< "sex:" << sex << endl;
        cout<< "title:" << title << endl;
        cout<< "address:" << addr << endl;
        cout<< "tel:" << tel << endl;
    }
    
    class Cadre
    {public:
        Cadre(string nam, int a, char s, string p, string ad, string t);
        void display();
    protected:
        string name;
        int age;
        char sex;
       string post;
       string addr;
       string tel;
    };
    Cadre::Cadre(string nam, int a,char s,string p,string ad,string t):name(nam),age(a),sex(s),post(p),addr(ad),tel(t){}
    
    void Cadre::display()
    {
        cout<< "name:" << name << endl;
        cout<< "age:" << age << endl;
        cout<< "sex:" << sex << endl;
        cout<< "post:" << post<< endl;
        cout<< "address:" << addr << endl;
        cout<< "tel:" << tel << endl;
    }
    
    class Person:public Teacher,public Cadre
    {public:
        Person(string nam, int a, char s, string tit, string p, string ad, string t, float w);
        void show();
    private:
        float wage;
    };
    Person::Person(string nam,int a,char s,string t,string p,string ad,string tel,float w):Teacher(nam,a,s,t,ad,tel),Cadre(nam, a, s, t, ad, tel),wage(w){}
    
    void Person::show()
    {
        Teacher::display();
        cout<< "post:" << Cadre::post << endl;
        cout<< "wage:" << wage << endl;
    }
    
    int main()
    {
       Person person1("xaiocong", 10, 'M', "prof.", "president", "135 Beijing
    Road,Shanghai", "(021)34567891", 1534.5);
        person1.show();
        return 0;
    }

    4.运行结果

    (1)
    在这里插入图片描述
    (2)

    在这里插入图片描述
    (3)
    在这里插入图片描述
    (4)

    在这里插入图片描述

    5.实验总结

    1.公用继承是指在定义一个派生类时将基类的继承方式指定为public的;

    2.保护继承是指在定义一个派生类时将基类的继承方式指定为protected的;

    3.公用继承和保护继承的执行过程相同的时候,其运行结果也相同;

    4.不同的继承方式使派生类的成员具有不同的特性,会对程序的执行产生不同的影响。

    展开全文
  • C++实验继承与派生的应用 课程 实验报告 作业参考的良品!
  • C++实验继承与派生

    千次阅读 2020-11-07 12:42:24
    实验名称 继承与派生 日期 2019年 05 月05 日 一、实验目的: 1. 学习定义和使用类的继承关系,定义派生类。 2. 理解类的访问控制类的成员访问的关系。 3. 熟悉不同继承方式下对基类成员的访问控制。 4. 学习...

    桂 林 理 工 大 学
    实 验 报 告
    实验名称 继承与派生 日期 2019年 05 月05 日
    一、实验目的:
    1. 学习定义和使用类的继承关系,定义派生类。
    2. 理解类的访问控制与类的成员访问的关系。
    3. 熟悉不同继承方式下对基类成员的访问控制。
    4. 学习利用虚基类解决二义性问题。
    二、实验环境:
    Visual C++

    三、实验内容:
    (写出主要的内容)
    1. 定义一个基类Animal,有私有整形成员变量age,构造其派生类dog,在其成员函数SetAge(int n)中直接给age赋值,看看会有什么问题,把age改为公有成员变量,还会有问题吗?改为保护类型呢?改变继承方式呢?

    #include<iostream>
    using namespace std;
    class Animal
    {
    	protected:
    		int age;
    	public:
    		Animal();
    		~Animal();
    };
    Animal::Animal()
    {
    	cout<<"构造了一个Animal!"<<endl;
    }
    Animal::~Animal()
    {
    	cout<<"析构了一个Animal!"<<endl;
     }
    class Dog:public Animal
    {
    	public:
    	Dog();
    	~Dog();
    	void SetAge(int n);	
     };
    Dog::Dog()
    {
    	cout<<"构造了一个Dog!"<<endl;	
     } 
    Dog::~Dog() 
    {
    	cout<<"析构了一个Dog!"<<endl;
    }
    void Dog::SetAge(int n)
    {
    	age=n;
    	cout<<"The Dog's age:"<<n<<endl;
     }
    int main()
    {
    	Dog a;
    	a.SetAge(5); 
     }
    

    输出结果:构造了一个Animal!
    构造了一个Dog!
    The Dog’s age:5
    析构了一个Dog!
    析构了一个Animal!
    2. 通过在上例的构成函数、析构函数中添加提示信息,或用debug调试功能观察构造函数和析构函数的执行情况,并分析原因。

     #include<iostream>
    using namespace std;
    class Animal
    {
    	protected:
    		int age;
    	public:
    		Animal();
    		~Animal();
    };
    Animal::Animal()
    {
    	cout<<"构造了一个Animal!"<<endl;
    }
    Animal::~Animal()
    {
    	cout<<"析构了一个Animal!"<<endl;
     }
    class Dog:public Animal
    {
    	public:
    	Dog();
    	~Dog();
    	int SetAge();
    	void PutAge();	
     };
    Dog::Dog()
    {
    	cout<<"构造了一个Dog!"<<endl;	
     } 
    Dog::~Dog() 
    {
    	cout<<"析构了一个Dog!"<<endl;
    }
    int Dog::SetAge()
    {
    	int n;
    	cout<<"Please input the Dog's age:";
    	cin>>n;
    	age=n;	
    	return age;
     }
     void Dog::PutAge()
     {
     	cout<<"The Dog's age:"<<age<<endl;
     }
    int main()
    {
    	Dog a;
    	a.SetAge();
    	a.PutAge(); 
     }
    

    输出结果:构造了一个Animal!
    构造了一个Dog!
    Please input the Dog’s age:6
    The Dog’s age:6
    析构了一个Dog!
    析构了一个Animal!
    3. 定义一个车(vehicle)基类,具有MaxSpeed、Weight等成员变量,Run、Stop等成员函数,由此派生出自行车(bicycl)类、汽车(motorcar)类。自行车类有高度(Height)等属性,汽车类有座位数(SeatNum)等属性。从和派生出摩托车(motorcycle)类,在继承过程中注意把设置为虚基类。如果不把vehice设置为虚基类,会有什么问题?并分析原因。
    Motorcycle无法运行,因为产生了二义性

     #include<iostream>
    using namespace std;
    class Vehicle
    {
    private:
    	int MaxSpeed;
    	int Weigth;
    public:
    	Vehicle();
    	~Vehicle();
    	void Run();
    	void Stop();
    		
    };
    Vehicle::Vehicle()
    {
    	MaxSpeed=0;
    	Weigth=0;
    	cout<<"构造了一个Vehicle"<<endl;	
    }
    Vehicle::~Vehicle()
    {
    	cout<<"析构了一个Vehicle"<<endl;
    }
    void Vehicle::Run()
    {
    	cout<<"Vehicle开始运行!"<<endl;
    }
    void Vehicle::Stop()
    {
    	cout<<"Vehicle停止运行!"<<endl;
    }
    
    class bicycle:virtual public Vehicle
    {
    private:
    	int Height;
    public:
    	bicycle();
    	~bicycle();	
    };
    bicycle::bicycle()
    {
    	cout<<"构造了一个bicycle"<<endl;	
    }
    bicycle::~bicycle()
    {
    	cout<<"析构了一个bicycle"<<endl;
    }
    
    class motocar:virtual public Vehicle
    {
    private:
    	int SetNumber;
    public:
    	motocar();
    	~motocar();
    	 
    };
    motocar::motocar()
    {
    	cout<<"构造了一个motocar"<<endl;	
    }
    motocar::~motocar()
    {
    	cout<<"析构了一个motocar"<<endl;
    }
    
    class motorcycle:public bicycle,public motocar
    {
    public:
    	motorcycle();
    	~motorcycle();	
    };
    motorcycle::motorcycle()
    {
    	cout<<"构造了一个motorcycle"<<endl;
    }
    motorcycle::~motorcycle()
    {
    	cout<<"析构了一个motorcycle"<<endl;
    }  
    
    int main()
    {
    	Vehicle a;
    	bicycle b;
    	motocar c;
    	motorcycle d;
    	a.Run() ;
    	a.Stop() ;
    	b.Run() ;
    	b.Stop() ;
    	c.Run() ;
    	c.Stop() ;
    	d.Run() ;
    	d.Stop() ;	
    }
    

    输出结果:
    构造了一个Vehicle
    构造了一个Vehicle
    构造了一个bicycle
    构造了一个Vehicle
    构造了一个motocar
    构造了一个Vehicle
    构造了一个bicycle
    构造了一个motocar
    构造了一个motorcycle
    Vehicle开始运行!
    Vehicle停止运行!
    Vehicle开始运行!
    Vehicle停止运行!
    Vehicle开始运行!
    Vehicle停止运行!
    Vehicle开始运行!
    Vehicle停止运行!
    析构了一个motorcycle
    析构了一个motocar
    析构了一个bicycle
    析构了一个Vehicle
    析构了一个motocar
    析构了一个Vehicle
    析构了一个bicycle
    析构了一个Vehicle
    析构了一个Vehicle
    四、 心得体会:
    1、学会了如何定义和使用类的继承关系,定义派生类。
    2、理解了类的访问控制与类的成员访问的关系。
    3、熟悉了不同继承方式下对基类成员的访问控制。
    4、学会了如何利用虚基类解决二义性问题。

    展开全文
  • C++实验6 继承与派生(一)

    千次阅读 2019-05-17 16:49:48
    实验名称:实验6 继承与派生(一) 所使用的开发工具及环境:PC机一套 Visual Studio 2010 实验要求: 1.硬件基本配置:Intel PentiumIII以上级别的CPU,大于64MB的内存。 2.软件要求:Window 2000操作系统,Visual ...
  • c++实验8继承派生上机练习题集.pdf
  • 继承与派生总结

    2018-06-19 18:07:34
    c++继承与派生总结 面向对象的程序设计中提供了类的继承机制,允许程序员在保持原有类特性的基础上,进行更具体、更详细的类的定义。以原有的类为基础产生新的类,我们就说新类继承了原有类的特征,也就是说从原有类...
  • C++实验继承派生[借鉴].pdf
  • C++实验继承派生类附答案.doc
  • 本资源是C++继承与派生实验报告,欢迎大家下载阿!
  • 实验派生与继承 班级123班 姓名朱广金 学号122536 一实验目的 1学习类的继承能够定义和使用类的继承关系 2学习派生类的声明定义方法 3掌握类的定义和对象的声明 4熟悉公有派生和私有派生的访问特性 5掌握派生...
  • c++类的继承与派生--实验报告.doc
  • 文章目录一、要求二、分析三、代码四、 结果 ...分别定义Circle类,Ball类,Cylinder类,Cone类,并让Ball类,Cylinder类,Cone类分别继承Circle类,在Circle类中定义纯虚函数virtual void show() = 0,之后
  • C++ 实验七 类的继承与派生

    千次阅读 2018-05-22 16:31:40
    5.定义派生类 Truck、Car、Bus。这些车辆除了拥有车牌号码之外,还各自不同的属性。Truck  还包括载重量属性(浮点数,单位吨); Car  还拥有品牌 属性(字符串),Bus  还包括核定载员数量(整型)。 此外,...
  • 以此雇员类为基类,从中派生实验员类,其中要求在实验员类中加入一个计算实验员工资的方法,实验员工资=基本工资(800)+实验室补助(150)+值班时间(月工作量)×5。以此雇员类为基类,从中派生出行政人员类,...
  • 实验5继承与派生.pdf

    2020-11-26 18:48:46
    北京电子科技学院BESTI 实 验 报 告 课程 面向对象程序设计 班级 1243 姓名 孟愫愫 学号 124308 成绩...5 实验名称 继承与派生 实验目的要求 1. 使学生掌握 C++语言类的继承派生的基础编程 2. 培养学生具有运用 C++
  • c++实验8-继承与派生上机练习题.doc
  • 继承与派生C++实验

    2014-04-06 23:15:45
    继承与派生 C++实验 沈阳工程学院 1.理解继承与派生、单继承与继承的概念; 2.理解基类与派生类的定义及使用方法,派生类对象及初始化方法; 3.理解继承与派生过程中,把派生类作为基类构成类族的概念及虚基类...
  • 实验 07 继承与派生4 学时;派生出 teacher教师类添加属性职务 char principalship[11]部门 char department[21] 从 student 类中派生出 graduate研究生类添加属性专业 char subject[21]导师 teacher adviser 从 ...
  • c++上机实验四:继承与派生

    千次阅读 2018-08-18 00:19:04
    2. 掌握派生类的声明定义方法。 3. 熟悉够有派生和私有派生的访问特性。 4. 掌握虚基类在解决二义性问题中的作用。 实验内容: 1. 定义一个存放一组整数的基类。 2. 定义三个派生类,其中的成员函数分别实现...
  • c++实验8-继承与派生上机练习题 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 定义一个哺乳动物类Mammal并从中派生出一...
  • 实验8 继承与派生.doc

    2020-12-20 17:45:15
    继承与派生
  • 实验继承与派生

    2021-07-05 20:06:23
    实验继承与派生 1 实验目的 学习继承与派生的相关理论,熟悉不同继承方式下对基类成员的访问方式,包括以下几个方面: (1)学习声明和使用类的继承关系,声明派生类; (2)熟悉不同继承方式下,对基类成员的...
  • 以Point为基类,派生出一个Circle(圆)类,增加数据成员r(半径),以及求面积的成员函数area,实现其他需要的成员函数,设计main函数完成测试 再以Circle类为直接基类,派生出一个Cylinder(圆柱体)类,再增
  • C++实验2:继承派生

    2011-12-11 15:01:12
    实验内容 编写一个学生和教师相关数据的输入和显示程序。 学生数据有学号、姓名、性别、年龄、班级和期末3门课程成绩。教师数据有职工号、姓名、性别、年龄、职称和所属系别。 设计4个类 person类,姓名、性别和年龄...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,836
精华内容 1,934
热门标签
关键字:

c++实验5继承与派生