精华内容
下载资源
问答
  • c++继承与派生练习题
    千次阅读
    2018-03-16 22:32:26
    #include <iostream>
    #include <string>
    #include <iomanip>
    using namespace std;
    class teacher
    {
    protected:
        int sum;
        string name;
        char sex;
    public:
        void input_A()
        {
            cout<<"Please input the teacher's sum,name and sex:";
            cin>>sum;
            cin>>name;
            cin>>sex;
        }
        void output_A()
        {
            cout<<"sum:"<<sum<<"name:"<<name<<"sex:"<<sex<<endl;
        }
    };
    class birthday
    {
    public:
        int year,month,day;
            void input_B()
            {
                cout<<"Please input the teacher's birthday:(year,month,day):";
                cin>>year;
                cin>>month;
                cin>>day;
            }
            void output_B()
            {
                cout<<year<<setw(2)<<setfill('0')<<month<<setw(2)<<setfill('0')<<day<<endl;
            }
    };
    class professor:public teacher
    {
    protected:
        int sum;
        string name;
        char sex;
        birthday n;
    public:
        void update(int y,int m,int d)
        {
            n.year=y;
            n.month=m;
            n.day=d;
        }
        void input_C()
        {
            input_A();
            n.input_B();
        }
        void output_C()
        {
            output_A();
            n.output_B();
        }
        friend istream& operator >>(istream& os,professor& a)
        {
            a.input_C();
            return os;
        }
        friend ostream& operator <<(ostream& os,professor a)
        {
            a.output_C();
            return os;
        }
    };
    int main()
    {
        professor p;
        int y,d,m;
        cin>>p;
            cin>>y>>d>>m;
        p.update(y,d,m);
        cout<<p;
        return 0;
    }
    更多相关内容
  • 2、共同派生类 3、人员类Person的派生(虚基类的使用)

    1、建筑物类Building的派生类

    #include<iostream>
    
    class Building
    {
    private:
        int N;//编号
        int floor;//层数
        int room;//房间数
        double area;//总面积
    public:
        Building(int n=1,int f=5,int r=20,double a=2000)
        {
            N=n,floor=f,room=r,area=a;
        }
    };
    class TeachBuilding:public Building
    {
        TeachBuilding(int n,int f,int r,double a):Building(n,f,r,a){}
    };
    class DormBuilding:public Building
    {
        int stuNum;//容纳学生总人数
        //默认实参要在形参列表的结尾
        DormBuilding(int n,int f,int r,double a,int stuNum=1000):Building(n,f,r,a)
        {
            this->stuNum=stuNum;
        }
    };
    

    2、共同派生类

    #include<iostream>
    
    class Table
    {
    private:
        double height;//高度
    public:
        Table(double h):height(h){}
    };
    class Circle
    {
    private:
        double area;//面积
    public:
        Circle(double a):area(a){}
    };
    //每一个父类前都要有继承方式
    class RoundTable:public Table,public Circle
    {
    public:
        RoundTable(double h,double a):Table(h),Circle(a){}
    };
    

    3、人员类Person的派生(虚基类的使用)

    #include<iostream>
    #include<string>
    using namespace std;
    #include<cstring>
    class Date
    {
    private:
        int year,month,day;//年月日
    public:
        Date(int y=1900,int m=1,int d=1)
        {
            year=y,month=m,day=d;
        }
        void show()
        {
            cout<<year<<"-"<<month<<"-"<<day<<endl;
        }
    };
    class Person
    {
    private:
        string name;//姓名
        string sex;//性别
        char id[25];//身份证号
        Date birthday;//出生年月
    public:
        Person(){}
        Person(string n,string s,const char i[],int y,int m,int d):birthday(y,m,d)//birthday要拆开来赋值 
        {
            name=n,sex=s;
            strcpy(id,i);
        }
        void show()
        {
            cout<<"name:"<<name<<endl;
            cout<<"sex:"<<sex<<endl;
            cout<<"id:"<<id<<endl;
            cout<<"birthday:";
            birthday.show();
        }
    };
    //菱形继承树,为消除间接二义性,使用虚基类 
    class Student:virtual public Person
    {
    private:
        char stuId[25];//学号
        double score;//成绩
    public:
    	//要传入const类型字符串,表示只读 
        Student(string name,string sex,const char id[],int y,int m,int d,const char stuid[],double sc):
        Person(name,sex,id,y,m,d)
        {
            strcpy(stuId,stuid);
            score=sc;
        }
        void show()
        {
        	Person::show();
            cout<<"stuId:"<<stuId<<endl;
            cout<<"score:"<<score<<endl;
        }
    };
    //菱形继承树,为消除间接二义性,使用虚基类 
    class Teacher:virtual public Person
    {
    private:
        string job;//教师职称
    public:
        Teacher(string name,string sex,const char id[],int y,int m,int d,string job):
        Person(name,sex,id,y,m,d)
        {
            this->job=job;
        }
        void show()
        {
            cout<<"job:"<<job<<endl;
        }
    };
    class StuTech:public Student,public Teacher
    {
    public:
    	//这个构造函数,要使用全部基类进行赋值,包括间接基类Person 
        StuTech(string name,string sex,const char id[],int y,int m,int d,const char stuId[],double score,string job):
        Person(name,sex,id,y,m,d),Student(name,sex,id,y,m,d,stuId,score),Teacher(name,sex,id,y,m,d,job){}
        void show()
        {
            Student::show();
            Teacher::show();
        }
    };
    
    int main()
    {
        StuTech st("zhangsan","man","123456789",2002,6,1,"001",95.5,"jiangshi");
        st.show();
        return 0;
    }
    

    在这里插入图片描述

    4、带AM,PM的时钟类Clock

    #include<iostream>
    #include<ctime>//可以获取当前时间
    #include<iomanip>
    using namespace std;
    
    class Clock
    {
    private:
    	int hour,minute,second;
    public:
    	//Clock();
    	Clock(int h=0,int m=0,int s=0)
    	{
    		hour=(h>=0&&h<24) ? h:0;
    		minute=(m>=0&&m<60) ? m:0;
    		second=(s>=0&&s<60) ? s:0;
    	}
    	int getHour()
    	{
    		return hour;	
    	}	
    	//24小时制
    	void showTime24()
    	{
    		cout<<setfill('0')<<setw(2)<<hour<<":"<<
    		setw(2)<<minute<<":"<<setw(2)<<second<<endl;
    	}
    	//12小时制上午
    	void showTimeAM()
    	{
    		if(hour==0)
    		{
    			cout<<setfill('0')<<setw(2)<<"12"<<":"<<
    			setw(2)<<minute<<":"<<setw(2)<<second<<endl;
    		}else{
    			cout<<setfill('0')<<setw(2)<<hour<<":"<<
    			setw(2)<<minute<<":"<<setw(2)<<second<<endl;
    		}
    	}
    	//12小时制下午
    	void showTimePM()
    	{
    		cout<<setfill('0')<<setw(2)<<(hour-12)<<":"<<
    		setw(2)<<minute<<":"<<setw(2)<<second<<endl;
    	}
    	//时间增加一秒
    	void timeAdd()
    	{
    		second=(second+1)%60;
    		if(second==0)
    		{
    			minute=(minute+1)%60;
    			if(minute==0)
    			{
    				hour=(hour+1)%24;
    			}
    		}
    	}
    }; 
    int main()
    {
    	int hour,minute,second;
    	double nowTime;
    	cout << "请设置当前时间(以24小时制按顺序输入时 分 秒):" << endl;
    	cin>>hour>>minute>>second;
    	cout<<"\t";
    	Clock clock(hour,minute,second);
    	int cnt=0;
    	while(cnt<5)
    	{
    		nowTime=time(0);
    		while(time(0)<(nowTime+1));
    		clock.timeAdd();
    		cout<<"\r";
    		cout<<"24小时制:";
    		clock.showTime24();
    		cout<<endl;
    		
    		cout<<"12小时制:";
    		if(clock.getHour()<12)
    		{
    			cout<<"AM ";
    			clock.showTimeAM();
    		}else{
    			cout<<"PM ";
    			clock.showTimePM();
    		}
    		cnt++;
    	}
    	return 0;
    }
    

    在这里插入图片描述

    在这里插入图片描述

    5、Employee类实现职员月工资管理

    #include<iostream>
    using namespace std;
    #include<string>
    const double sales = 200000;//销售额
    class Employee
    {
    private:
    	int id;//编号
    	string name;//姓名
    	string job;//岗位
    	double monthMoney;//月工资
    public:
    	Employee(int id, string name, string job)
    	{
    		this->id = id, this->name = name;
    		this->job = job;
    		monthMoney= getMonthMoney();
    	}
    	double getMonthMoney()
    	{
    		if (job.compare("manager") == 0)//使用string的compare函数比较字符串
    		{
    			monthMoney = 8000;
    		}
    		else if (job.compare("technician") == 0)
    		{
    			monthMoney = 100 * 8 * 30;
    		}
    		else if (job.compare("salesman") == 0)
    		{
    			monthMoney = sales * 0.04;
    		}
    		else if (job.compare("salesmanager") == 0)
    		{
    			monthMoney = 5000 + sales * 0.005;
    		}
    		return monthMoney;
    	}
    	void showInformation()
    	{
    		cout << "编号:" << id << endl;
    		cout << "姓名:" << name << endl;
    		cout << "岗位:" << job << endl;
    		cout << "月薪:" << monthMoney << endl;
    	}
    };
    int main()
    {
    	Employee p1(1, "zhangsan", "manager");
    	Employee p2(2, "lisi", "technician");
    	Employee p3(3, "wangwu", "salesman");
    	Employee p4(4, "zhaoliu", "salesmanager");
    	p1.showInformation();
    	cout << endl;
    	p2.showInformation();
    	cout << endl;
    	p3.showInformation();
    	cout << endl;
    	p4.showInformation();
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • c++继承与派生习题答案.doc
  • 第九章继承派生类 92 典型例题分析解答 例题 1下列对派生类的...答案D 分析一个派生类可以作为另一个派生类的基类无论是单继承还是多继承派生类至少有 一个基类派生类的成员除了它自己的成员外还包含了它的基类成员
  • c++继承与派生习题答案
  • 继承与派生练习题 C++

    千次阅读 2020-05-03 21:34:53
    1、编写一个面向对象的程序,要求: (1)定义一个基类Student, 类内有保护数据成员num (学号)、name (姓名),公有成员...(2)定义一一个派生类Student1, Student1公有继承自Student类。Student1类新增私有数据成员...

    1、编写一个面向对象的程序,要求:


    (1)定义一个基类Student, 类内有保护数据成员num (学号)、name (姓名),公有成员包括构造函数、show()函数。构造函数带2个参数用于定义对象时赋初值,show() 函数作用是显示学生信息,即num、name 的值。

    (2)定义一一个派生类Student1, Student1公有继承自Student类。Student1类新增私有数据成员age (年龄)、addr (地址)以及子对象monitor (班长,Student 类型),新增公有成员包括构造函数、show()函数。 构造函数带6个参数用于定义对象时赋初值,show() 函数作用是显示学生的所有信息,即本人的num、name、 age、addr 以及班长的num、name 。

    (3)在main()函数定义Student1类的对象stud1并赋初值,调用show()函数显示该学生的所有信息。
     

    #include <iostream>
    #include <string>
    using namespace std;
    class student
    {
    protected:
        string num, name;
    public:
        student(string s_num, string s_name);
        void show();
    };
    student::student(string s_num, string s_name): num(s_num),name(s_name){}
    void student::show()
    {
        cout << "num: " << num << endl << "name: " << name << endl;
    }
    
    class student1: public student
    {
    private:
        int age;
        string addr;
        student monitor;
    public:
        student1(string s_num, string s_name, int s_age, string s_addr, string m_num, string m_name);
        void show();
    };
    student1::student1(string s_num, string s_name, int s_age, string s_addr, string m_num, string m_name)
        :student(s_num, s_name), monitor(m_num, m_name)
    {//给monitor实例参数,令其调用构造函数
        age = s_age;
        addr = s_addr;
    }
    void student1::show()
    {
        cout << "This student is: " << endl;
        student::show();//调用其基类的show函数,输出自身的数据
        cout << "age: " << age << endl << "addr: " << addr << endl;
        cout << "Class monitor is:" << endl;
        monitor.show();//调用monitor实例的show函数
    }
    
    int main()
    {
        student1 stud1("10001", "LiMing", 20, "SD", "10001", "LiMing");
        stud1.show();
        return 0;
    }
    

     

    2、

    写一个面向对象的程序,定义抽象基类Shape,由它派生出2个类: Circle (圆形)、Rectangle (矩形),显示两个图形的面积。

    要求:
    (1)抽象基类Shape的公有成员有纯虚函数area()。
    (2) Circle类公有继承自Shape类,新增数据成员radius (半径),公有成员有构造函数和求圆面积的area()函数。
    (3) Rectangle 类公有继承自Shape 类,新增数据成员length (长)、width (宽),公有成员有构造函数和求矩形面积的area()函数。
    (4)在main()函数定义Circle类的对象circlel并赋初值,调用area()函数显示该圆面积;  定义Rectangle类的对象rectangle1并赋初值,调用area ()函数显示该矩形面积。
     

    #include <iostream>
    #include <string>
    using namespace std;
    class Shape
    {
    public:
        virtual double area() = 0;//创建纯虚函数
    };
    
    class Circle: public Shape
    {
    private:
        double radius;
    public:
        Circle(double c_radius): radius(c_radius){};
        virtual double area();
    };
    double Circle::area()
    {
        return (3.14159 * radius * radius);
    }
    
    class Rectangle: public Shape
    {
    private:
        int length, width;
    public:
        Rectangle(int r_length, int r_width): length(r_length), width(r_width){};
        virtual double area();
    };
    double Rectangle::area()
    {
        return (length * width);
    }
    
    int main()
    {
        Circle circle1(2);
        cout << "area of circle = " << circle1.area() << endl;
        Rectangle rectangle1(2, 4);
        cout << "area of rectangle = " << rectangle1.area() << endl;
        return 0;
    }
    

     

    展开全文
  • c++实验8 继承与派生上机练习题.doc
  • 实验四 C++中的继承与派生 一实验目的 理解C++继承与派生的概念 掌握C++中各种不同继承方式的访问属性差别 掌握单继承与继承的实现方法 掌握派生类构造函数析构函数的实现及调用顺序 掌握虚基类的使用方法 二...
  • c++实验8-继承与派生上机练习题.doc
  • c++实验8-继承与派生上机练习题 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 定义一个哺乳动物类Mammal并从中派生出一...
  • C++继承派生习题.doc
  • C++面向对象程序设计习题继承与派生.pdf
  • 继承与派生练习题

    千次阅读 多人点赞 2021-02-16 18:56:54
    我是计算机专业的一位大一本科生,C++小白,下面是我们学校在学习C++时用的基础练习题,我感觉这些题比较适合初学C++的码友,所以利用空闲时间将这些题整理出来,一是为了让初学C++的码友有所参考,二也是为了复习...

    继承与派生练习题

    在刚开始学习c++的时候刷了很多基础题,这些基础题比较适合初学C++的码友,所以在学完就立即进行了整理,一是为了让初学C++的码友有所参考,二也是为了复习一下所学过知识。
    但因为当时在整理时,时间有点紧促,可能会出现一些小错误,于是利用五一假期对之前的文章进行检查,修改了一些小错误,可能有些错误我还没有发现,欢迎码友们对其指正。

    以下八道题主要考查了类与对象中继承与派生的知识,适合初学继承与派生的码友进行练习。

    继承与派生 01

    请以点类Point为基类派生出一个圆类Circle。圆类Circle的数据成员为r(私有属性,存储圆的半径,圆心的点坐标通过继承点类Point加以实现),成员函数有构造函数Circle、计算圆的面积函数Area、计算圆的周长函数Perimeter和输出函数Display,其中构造函数实现基类和圆类的数据成员的初始化,Display函数实现圆心坐标(利用基类Point的Display实现)、圆的半径、圆的面积(利用Area函数实现)和圆的周长(利用Perimeter函数实现)的输出。请编写圆类的定义及成员函数实现,并在主函数中定义圆类对象,验证各个函数的正确性。
    说明:圆周率PI的取值为3.14

    //已知Point类的定义及main代码如下:(不允许改动)
    class Point
    { 
    public:
           Point(double xx,double yy); //constructor
           void Display();        //display point   
    private:
           double x,y;    //平面的点坐标x,y
    };
    int main()
    {
           double x,y,r;
           cin>>x>>y>>r; //圆心的点坐标及圆的半径
           Circle C(x,y,r);
           C.Display(); //输出圆心点坐标,圆的半径,圆的面积,圆的周长
           return 0;
    }
    

    Sample Input
    1.5 2.6 1.8
    Sample Output
    Center:Point(1.5,2.6)
    Radius:1.8
    Area:10.1736
    Perimeter:11.304

    #include<iostream>
    using namespace std;
    const double PI=3.14;
    //已知Point类的定义及main代码如下:(不允许改动)
    class Point
    {
    public:
           Point(double xx,double yy); //constructor
           void Display();        //display point
    private:
           double x,y;    //平面的点坐标x,y
    };
    Point::Point(double xx,double yy) //constructor
    {
        x=xx;
        y=yy;
    }
    void Point::Display()
    {
        cout<<"Point("<<x<<","<<y<<")"<<endl;
    }
    class Circle :public Point
    {
    public:
        Circle(double xx,double yy,double rr);
        double Area();
        double Perimeter();
        void Display();
    private:
        double r;
    };
    Circle::Circle(double xx,double yy,double rr) :Point(xx,yy)
    {
        r=rr;
    }
    double Circle::Area()
    {
        return PI*r*r;
    }
    double Circle::Perimeter()
    {
        return 2*PI*r;
    }
    void Circle::Display()
    {
        cout<<"Center:";
        Point::Display();
        cout<<"Radius:"<<r<<endl;
        cout<<"Area:"<<Area()<<endl;
        cout<<"Perimeter:"<<Perimeter()<<endl;
    }
    int main()
    {
           double x,y,r;
           cin>>x>>y>>r; //圆心的点坐标及圆的半径
           Circle C(x,y,r);
           C.Display(); //输出圆心点坐标,圆的半径,圆的面积,圆的周长
           return 0;
    }
    

    继承与派生 02

    Person类派生大学生CollegeStu类。设计一个Person类,其属性包括姓名name和身份证号id,其中name为指针类型,id为整型,编写成员函数:构造函数Person、Display函数(显示数据成员信息)和析构函数;由Person类派生出大学生类CollegeStu,其属性有专业major(指针类型),C++程序设计课程成绩score(double型),编写构造函数(实现数据初始化)、输出函数Display(包括name,id,major,score)。

    //main的代码如下:(不允许改动)
    int main()
    {
           char name[81],major[81];
           int id;
           double score;
           cin>>name>>id>>major>>score;
           CollegeStu cs(name,id,major,score);
           cs.Display();
           return 0;
    }
    

    Sample Input
    Zhangsan 2 Computer 89.5
    Sample Output
    Name:Zhangsan
    ID:2
    Major:Computer
    C++ Score:89.5

    #include<iostream>
    #include<cstring>
    using namespace std;
    class Person
    {
    public:
        Person(char*name,int id);
        void Display();
        ~Person();
    private:
        char *m_name;
        int m_id;
    };
    Person::Person(char*name,int id)
    {
        int len=strlen(name);
        m_name=new char[len+1];
        strcpy(m_name,name);
        m_id=id;
    }
    void Person::Display()
    {
        cout<<"Name:"<<m_name<<endl;
        cout<<"ID:"<<m_id<<endl;
    }
    Person::~Person()
    {
        delete []m_name;
    }
    class CollegeStu :public Person
    {
    public:
        CollegeStu(char *name,int id,char *major,double score);
        void Display();
        ~CollegeStu();
    private:
        char *m_major;
        double m_score;
    };
    CollegeStu::CollegeStu(char *name,int id,char *major,double score):Person(name,id)
    {
        int len=strlen(major);
        m_major=new char[len+1];
        strcpy(m_major,major);
        m_score=score;
    }
    void CollegeStu::Display()
    {
        Person::Display();
        cout<<"Major:"<<m_major<<endl;
        cout<<"C++ Score:"<<m_score<<endl;
    }
    CollegeStu::~CollegeStu()
    {
        delete []m_major;
    }
    //main的代码如下:(不允许改动)
    int main()
    {
           char name[81],major[81];
           int id;
           double score;
           cin>>name>>id>>major>>score;
           CollegeStu cs(name,id,major,score);
           cs.Display();
           return 0;
    }
    

    继承与派生 03

    Person类派生大学生CollegeStu类。设计一个Person类,其属性包括姓名name和身份证号id,其中name为指针类型,id为整型,编写成员函数:构造函数Person、Display函数(显示数据成员信息)和析构函数;由Person类派生出大学生类CollegeStu,其属性有专业major(指针类型),C++程序设计课程成绩score(double型),编写构造函数(实现数据初始化)、输出函数Display(只输出major,score)。

     //main的代码如下:(不允许改动)
    int main()
    {
           char name[81],major[81];
           int id;
           double score;
           cin>>name>>id>>major>>score;  //输入学生的姓名、id号、专业、成绩
           CollegeStu cs(name,id,major,score);
           cs.Person::Display();  //输出姓名,id
           cs.Display();    //输出专业、成绩
           return 0;
    }
    

    Sample Input
    Lixu 5 Software 87.5
    Sample Output
    Name:Lixu
    ID:5
    Major:Software
    C++ Score:87.5

    #include<iostream>
    #include<cstring>
    using namespace std;
    class Person
    {
    public:
        Person(char*name,int id);
        void Display();
        ~Person();
    private:
        char *m_name;
        int m_id;
    };
    Person::Person(char*name,int id)
    {
        int len=strlen(name);
        m_name=new char[len+1];
        strcpy(m_name,name);
        m_id=id;
    }
    void Person::Display()
    {
        cout<<"Name:"<<m_name<<endl;
        cout<<"ID:"<<m_id<<endl;
    }
    Person::~Person()
    {
        delete []m_name;
    }
    class CollegeStu :public Person
    {
    public:
        CollegeStu(char *name,int id,char *major,double score);
        void Display();
        ~CollegeStu();
    private:
        char *m_major;
        double m_score;
    };
    CollegeStu::CollegeStu(char *name,int id,char *major,double score):Person(name,id)
    {
        int len=strlen(major);
        m_major=new char[len+1];
        strcpy(m_major,major);
        m_score=score;
    }
    void CollegeStu::Display()
    {
        cout<<"Major:"<<m_major<<endl;
        cout<<"C++ Score:"<<m_score<<endl;
    }
    CollegeStu::~CollegeStu()
    {
        delete []m_major;
    }
    //main的代码如下:(不允许改动)
    int main()
    {
           char name[81],major[81];
           int id;
           double score;
           cin>>name>>id>>major>>score;  //输入学生的姓名、id号、专业、成绩
           CollegeStu cs(name,id,major,score);
           cs.Person::Display();  //输出姓名,id
           cs.Display();    //输出专业、成绩
           return 0;
    }
    

    继承与派生 04

    已知Base为基类,派生出Derived类,两个类的定义及main的代码如下(不允许改动),请完成Base类和Derived类的构造函数和析构函数,能够根据输入获取相应的输出。

    class Base
    {
    private:
           int b;
    public:
           Base(int);
           ~Base();
    };
    class Derived:public Base
    {
    private:
           int d;
    public:
           Derived(int,int);
           ~Derived();
    };
    int main()
    {
           int a,b;
           cin>>a>>b;
           Derived dr(a,b);    
           return 0;
    }
    

    Sample Input
    1 3
    Sample Output
    Base 1 says hello
    Derived 3 says hi
    Derived 3 says bye
    Base 1 says goodbye

    #include<iostream>
    using namespace std;
    class Base
    {
    private:
           int b;
    public:
           Base(int a);
           ~Base();
    };
    Base::Base(int a)
    {
        b=a;
        cout<<"Base "<<b<<" says hello"<<endl;
    }
    Base::~Base()
    {
        cout<<"Base "<<b<<" says goodbye"<<endl;
    }
    class Derived:public Base
    {
    private:
           int d;
    public:
           Derived(int a,int b);
           ~Derived();
    };
    Derived::Derived(int a,int b):Base(a)
    {
        d=b;
        cout<<"Derived "<<d<<" says hi"<<endl;
    }
    Derived::~Derived()
    {
        cout<<"Derived "<<d<<" says bye"<<endl;
    }
    int main()
    {
           int a,b;
           cin>>a>>b;
           Derived dr(a,b);
           return 0;
    }
    

    继承与派生 05

    由Array类派生出有序数组SortArray类,SortArray类中实现有序数组的插入。

    //已知Array类的定义如下(不允许增加成员函数):
    class Array
    {
    public:
           Array();    //构造函数,初始化为空数组(length置为0)
           int Length();   //获取数组的实际长度
           double Get(int pos);     //获取data中下标为pos的元素的值
           void Insert(int pos, double x); //在下标pos处插入x
           void Display();       //输出线性表        
    private:
           double data[MaxSize];  //存储元素(MaxSize为常量)
           int length;              //数组的实际长度
    };
    //SortArray类定义如下(不允许增加成员函数):
    class SortArray:private Array
    {
    public:
           SortArray();
           int Length();   //获取数组的实际长度
           double Get(int pos);     //获取data中下标为pos的元素的值
           void Display();       //输出线性表        
           void Insert(double x); //递增有序数组中插入x,使序列仍有序
    };
    

    请实现Array类和SortArray类的成员函数, main中输入若干个实数,以0结束,利用SortArray类中的Insert函数将它们插入data中,得到有序序列,再利用Display函数输出有序序列。

    //代码如下(不允许修改):
    int main()
    {
           SortArray sa;
           double num;
           while(1)
           {
                  cin>>num;
                  if(fabs(num)<=1e-6) break;
                  try
                  {
                         sa.Insert(num); //
                  }
                  catch(char* message)
                  {
                         cout <<message<<endl;    //如失败提示失败信息
                  }
           }
           sa.Display();
          
        return 0;
    }
    

    Sample Input
    2.5 6.7 8.3 2.8 6.53 6.82 7.33 0
    Sample Output
    The length:7
    The elements:2.5 2.8 6.53 6.7 6.82 7.33 8.3

    #include<iostream>
    #include<cmath>
    using namespace std;
    const int MaxSize=100;
    //已知Array类的定义如下(不允许增加成员函数):
    class Array
    {
    public:
           Array();    //构造函数,初始化为空数组(length置为0)
           int Length();   //获取数组的实际长度
           double Get(int pos);     //获取data中下标为pos的元素的值
           void Insert(int pos, double x); //在下标pos处插入x
           void Display();       //输出线性表
    private:
           double data[MaxSize];  //存储元素(MaxSize为常量)
           int length;              //数组的实际长度
    };
    Array::Array()    //构造函数,初始化为空数组(length置为0)
    {
        length=0;
    }
    int Array::Length()   //获取数组的实际长度
    {
        return length;
    }
    double Array::Get(int pos)     //获取data中下标为pos的元素的值
    {
        return data[pos];
    }
    void Array::Insert(int pos, double x) //在下标pos处插入x
    {
        for(int i=length-1;i>=pos;i--)
            data[i+1]=data[i];
        data[pos]=x;
        length++;
    }
    void Array::Display()      //输出线性表
    {
        cout<<"The length:"<<length<<endl;
        cout<<"The elements:";
        for(int i=0;i<length;i++)
            cout<<data[i]<<" ";
        cout<<endl;
    }
    //SortArray类定义如下(不允许增加成员函数):
    class SortArray:private Array
    {
    public:
           SortArray();
           int Length();   //获取数组的实际长度
           double Get(int pos);     //获取data中下标为pos的元素的值
           void Display();       //输出线性表
           void Insert(double x); //递增有序数组中插入x,使序列仍有序
    };
    SortArray::SortArray():Array(){}
    int SortArray::Length()   //获取数组的实际长度
    {
        return Array::Length();
    }
    double SortArray::Get(int pos)     //获取data中下标为pos的元素的值
    {
        return Array::Get(pos);
    }
    void SortArray::Display()      //输出线性表
    {
        Array::Display();
    }
    void SortArray::Insert(double x)//递增有序数组中插入x,使序列仍有序
    {
        int i;
        for(i=0;i<Length();i++)
            if(Get(i)>x)
               break;
        Array::Insert(i,x);
    }
    //代码如下(不允许修改):
    int main()
    {
           SortArray sa;
           double num;
           while(1)
           {
                  cin>>num;
                  if(fabs(num)<=1e-6) break;
                  try
                  {
                         sa.Insert(num); //
                  }
                  catch(char* message)
                  {
                         cout <<message<<endl;    //如失败提示失败信息
                  }
           }
           sa.Display();
          
        return 0;
    }
    

    继承与派生 06

    //已知Array类的定义如下(不允许增加成员函数):
    class Array
    {
    public:
           Array(int size); 
     //构造函数,初始化数据成员(为data分配内存,MaxSize置为size,length置为0)
           int Length();   //获取顺序表实际长度
           double Get(int pos);     //获取下标为pos的元素的值
           void Insert(int pos, double x); //在下标pos处插入x
           void Display();       //输出线性表  
          ~Array();  //destructor      
    private:
           double *data; //存储元素
        int MaxSize;  
           int length;              //数组的实际长度
    };
     
    //SortArray类定义如下(不允许增加其它成员函数):
    class SortArray:private Array
    {
    public:
           SortArray(int size);
           int Length();   //获取顺序表实际长度
           double Get(int pos);     //获取下标为pos的元素的值
           void Display();       //输出线性表        
           void Insert(double x); //递增有序数组中插入x,使序列仍有序
    };
    //main中的代码如下(不允许改动):
    int main()
    {
           int size;
           cin>>size;
           SortArray sa(size);
           double num;
           while(1)
           {
                  cin>>num;
                  if(fabs(num)<=1e-6) break;
                  try
                  {
                         sa.Insert(num);
                  }
                  catch(char* wrong)
                  {
                         cout <<wrong<<endl;    //如失败提示失败信息
                  }
           }
           sa.Display();  
        return 0;
    }
    

    请实现Array类和SortArray类的成员函数。
    Sample Input
    20 2.5 6.7 8.3 2.8 6.53 6.82 7.33 0
    Sample Output
    The length:7
    The elements:2.5 2.8 6.53 6.7 6.82 7.33 8.3

    #include<iostream>
    #include<cmath>
    using namespace std;
    //已知Array类的定义如下(不允许增加成员函数):
    class Array
    {
    public:
           Array(int size); 
     //构造函数,初始化数据成员(为data分配内存,MaxSize置为size,length置为0)
           int Length();   //获取顺序表实际长度
           double Get(int pos);     //获取下标为pos的元素的值
           void Insert(int pos, double x); //在下标pos处插入x
           void Display();       //输出线性表  
          ~Array();  //destructor      
    private:
           double *data; //存储元素
        int MaxSize;  
           int length;              //数组的实际长度
    };
    Array::Array(int size) 
     //构造函数,初始化数据成员(为data分配内存,MaxSize置为size,length置为0)
     {
         MaxSize=size;
         data=new double[MaxSize];
         length=0;
     }
    int Array::Length()   //获取顺序表实际长度
    {
        return length;
    }
    double Array::Get(int pos)    //获取下标为pos的元素的值
    {
        return data[pos];
    }
    void Array::Insert(int pos, double x) //在下标pos处插入x
    {
        for(int i=length-1;i>=pos;i--)
            data[i+1]=data[i];
        data[pos]=x;
        length++;
    }
    void Array::Display()       //输出线性表  
    {
        cout<<"The length:"<<length<<endl;
        cout<<"The elements:";
        for(int i=0;i<length;i++)
            cout<<data[i]<<" ";
        cout<<endl;
    }
    Array::~Array()  //destructor      
    {
        delete []data;
    }
    //SortArray类定义如下(不允许增加其它成员函数):
    class SortArray:private Array
    {
    public:
           SortArray(int size);
           int Length();   //获取顺序表实际长度
           double Get(int pos);     //获取下标为pos的元素的值
           void Display();       //输出线性表        
           void Insert(double x); //递增有序数组中插入x,使序列仍有序
    };
    SortArray::SortArray(int size):Array(size){}
    int SortArray::Length()   //获取顺序表实际长度
    {
        return Array::Length();
    }
    double SortArray::Get(int pos)    //获取下标为pos的元素的值
    {
        return Array::Get(pos);
    }
    void SortArray::Display()      //输出线性表        
    {
        Array::Display();
    }
    void SortArray::Insert(double x) //递增有序数组中插入x,使序列仍有序
    {
        int i;
        for(i=0;i<Length();i++)
            if(Get(i)>x)
               break;
        Array::Insert(i,x);
    }
    //main中的代码如下(不允许改动):
    int main()
    {
           int size;
           cin>>size;
           SortArray sa(size);
           double num;
           while(1)
           {
                  cin>>num;
                  if(fabs(num)<=1e-6) break;
                  try
                  {
                         sa.Insert(num);
                  }
                  catch(char* wrong)
                  {
                         cout <<wrong<<endl;    //如失败提示失败信息
                  }
           }
           sa.Display();  
        return 0;
    }
    

    继承与派生 07

    已知由Automobille类派生出Car类和Wagon类,而后两者共同派生出StationWagon类,各类的定义及main中的代码(不允许改动)如下,请实现各个类的成员函数,完成相应的输出:

    class Automobile              //汽车类
    {
    private:
       int power;   //马力
    public:
           Automobile(int p);
           void Display();
    };
    class Car:virtual  public Automobile   //小客车类
    {
    private:
          int seat;     //座位
    public:
           Car(int p,int s);
           void Display();
    };
    class Wagon:virtual  public Automobile //小货车类
    {
    private:
       int load;     //装载量
    public:
        Wagon(int p,int l);
     void Display();
    };
    class StationWagon :public Car, public Wagon  //客货两用车类
    {
    public:
           StationWagon(int p, int s,int l);
           void Display();
    };
    int main()
    {
           int power,load,seat;
           cin>>power>>seat>>load;
           StationWagon sw(power,seat,load);
           sw.Display();  
           return 0;
    }
    

    Sample Input
    108 3 10
    Sample Output
    StationWagon:
    Power:108
    Seat:3
    Load:10

    #include<iostream>
    using namespace std;
    class Automobile              //汽车类
    {
    private:
       int power;   //马力
    public:
           Automobile(int p);
           void Display();
    };
    Automobile::Automobile(int p)
    {
        power=p;
    }
    void Automobile::Display()
    {
        cout<<"Power:"<<power<<endl;
    }
    class Car:virtual  public Automobile   //小客车类
    {
    private:
          int seat;     //座位
    public:
           Car(int p,int s);
           void Display();
    };
    Car::Car(int p,int s):Automobile(p)
    {
        seat=s;
    }
    void Car::Display()
    {
        cout<<"Seat:"<<seat<<endl;
    }
    class Wagon:virtual  public Automobile //小货车类
    {
    private:
       int load;     //装载量
    public:
        Wagon(int p,int l);
        void Display();
    };
    Wagon::Wagon(int p,int l):Automobile(p)
    {
        load=l;
    }
    void Wagon::Display()
    {
        cout<<"Load:"<<load<<endl;
    }
    class StationWagon :public Car, public Wagon  //客货两用车类
    {
    public:
           StationWagon(int p, int s,int l);
           void Display();
    };
    StationWagon::StationWagon(int p, int s,int l) :Automobile(p),Car(p,s),Wagon(p,l){}
    void StationWagon::Display()
    {
        cout<<"StationWagon:"<<endl;
        Automobile::Display();
        Car::Display();
        Wagon::Display();
    }
    int main()
    {
           int power,load,seat;
           cin>>power>>seat>>load;
           StationWagon sw(power,seat,load);
           sw.Display();  
           return 0;
    }
    

    继承与派生 08

    Person类派生大学生CollegeStu类。设计一个Person类,其属性包括姓名name和身份证号id,其中name为string类型,id也为string型,编写成员函数:构造函数Person、Display函数(显示数据成员信息)和析构函数;由Person类派生出大学生类CollegeStu,其属性有专业major(string类型),C++程序设计课程成绩score(double型),编写构造函数(实现数据初始化)、输出函数Display(包括name,id,major,score)。

    //main的代码如下:(不允许改动)
    int main()
    {
           string name,major;
           string id;
           double score;
           cin>>name>>id>>major>>score;
           CollegeStu cs(name,id,major,score);
           cs.Display();
           return 0;
    }
    

    Sample Input
    Zhangsan 210302198909120938 Software 99.5
    Sample Output
    Name:Zhangsan
    ID:210302198909120938
    Major:Software
    C++ Score:99.5

    #include<iostream>
    //#include<string>
    using namespace std;
    class Person
    {
    public:
        Person(string name,string id);
        void Display();
        ~Person();
    private:
        string m_name;
        string m_id;
    };
    Person::Person(string name,string id)
    {
        m_name=name;
        m_id=id;
    }
    void Person::Display()
    {
        cout<<"Name:"<<m_name<<endl;
        cout<<"ID:"<<m_id<<endl;
    }
    Person::~Person(){}
    class CollegeStu :public Person
    {
    public:
        CollegeStu(string name,string id,string major,double score);
        void Display();
    private:
        string m_major;
        double m_score;
    };
    CollegeStu::CollegeStu(string name,string id,string major,double score):Person(name,id)
    {
        m_major=major;
        m_score=score;
    }
    void CollegeStu::Display()
    {
        Person::Display();
        cout<<"Major:"<<m_major<<endl;
        cout<<"C++ Score:"<<m_score<<endl;
    }
    //main的代码如下:(不允许改动)
    int main()
    {
           string name,major;
           string id;
           double score;
           cin>>name>>id>>major>>score;
           CollegeStu cs(name,id,major,score);
           cs.Display();
           return 0;
    }
    

    大家好,我是Lucky_追梦仔。一个正在学习编程的小白,希望我的博文,可以帮助到您学习,或者解决您遇到的问题。

    展开全文
  • C++第4章 派生与继承练习

    千次阅读 2022-04-26 18:56:04
    定义派生类student私有继承person,派生类中含有私有数据成员cridit和构造函数、成员函数setage_cre以及show函数。主函数中定义派生类对象stu1,初值为19和166。利用对象调用成员函数setage_cre,实参为20和168。输出...
  • c++课件 派生与继承

    2012-05-08 15:51:57
    c++课件 派生与继承
  • 熟练掌握三种继承以及虚继承的概念知识,概念填空 简答 派生类如何实现对基类私有成员的访问?什么是类型兼容规则?派生类的构造函数是怎样的执行顺序,析构函数的执行顺序是如何实现的?什么是虚基类?它有什么...
  • C++习题与解析-继承派生[借鉴].pdf
  • C++类的继承与派生归纳习题以及答案
  • C++习题(04)派生与继承

    千次阅读 2020-03-24 09:41:54
    继承与派生 银行存款类三.继承与派生 Person及其子类 一.根据给出的基类编程 题目描述 给出下面的基类: class AreaC1{ public: AreaC1(double h, double w) { height = h; width = w; } double area(){ ...
  • NEFU C++实验四派生与继承(锐格)

    千次阅读 2022-04-02 18:05:17
    下面的程序可以输出ASCII字符所对应的数字的对照表,修改下列程序,使其可以输出字母a到字母z。 输入输出说明: 输出:每隔12个字母换行,设置输出的域宽为4 ASCII value-char 97a 98b 99c 100d 101e 102f ...
  • 【C++】C++继承派生类、虚基类

    万次阅读 多人点赞 2018-06-07 18:46:17
    派生则是继承的直接产物,它通过继承已有的一个或多个类来产生一个新的类,通过派生可以创建一种类族。 继承 基本概念 在定义一个类A时,若它使用了一个已定义类B的部分或全部成员,则称类A继承了类...

空空如也

空空如也

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

c++继承与派生练习题