编写程序声明一个车（Vehicle）基类，由此派生出自行车（Bicycle）类、汽车（Motorcar）类，注意把 Vehicle 派生为虚基类，Bicycle 类的 Run 函数输出“Bicycle run”，Motorcar 的 Stop 函数输出“Motorcar stop”。再从 Bicycle 和 Motorcar 派生出摩托车（Motorcycle）类，在 main()函数中测试这个类。 编译成功后，把 Vehicle 设置为非虚基类，再编译一次，此时系统报错，无法编译成功。这是因为若不把 Vehicle 设置为虚基类，会出现二义性错误，程序不能成功编译。 根据提示，在右侧编辑器补充代码，并输出正确的值。 测试说明 平台会对你编写的代码进行测试： 测试输入： 预期输出： Bicycle run Motorcar stop

#include<iostream>
using namespace std;

class Vehicle{
public:
    virtual void Run(){}
    virtual void Stop(){}
};

class Bicycle:virtual public Vehicle{
public:
    void Run(){
        cout << "Bicycle run" << endl;
    }
};

class Motorcar:virtual public Vehicle{
public:
    void Stop(){
        cout << "Motorcar stop" << endl;
    }
};

class Motorcycle:public Bicycle,public Motorcar{
};

int main(){
    Motorcycle m;
    m.Run();
    m.Stop();
    return 0;
}

相关问题

声明一个车(vehicle)基类，具有MaxSpeed、weight等成员变量，Run、Stop等成员函数，由此派生出自行车(bicycle)类、汽车(motorcar)类。自行车(bicycle)和有高度(Height)等属性，汽车(motocar)类有座位数(S编写程序声明一个车(vehicle)基类，由此派生出自行车(bicycle)类、汽车(motocar)，注意把vehicle基类派生为虚基类。再从bicycle和motocar派生出摩托车(motocycle)类，在main()函数中执行这个类

的示例代码。

以下是代码实现：

#include <iostream>
using namespace std;

class vehicle {
public:
    float MaxSpeed;
    float weight;
    virtual void Run() {
        cout << "Vehicle is running." << endl;
    }
    virtual void Stop() {
        cout << "Vehicle has stopped." << endl;
    }
};

class bicycle : virtual public vehicle {
public:
    float Height;
};

class motorcar : virtual public vehicle {
public:
    int Seats;
};

class motorcycle : public bicycle, public motorcar {
public:
    void Run() {
        cout << "Motorcycle is running." << endl;
    }
    void Stop() {
        cout << "Motorcycle has stopped." << endl;
    }
};

int main() {
    motorcycle m;
    m.MaxSpeed = 100;
    m.weight = 150;
    m.Height = 1.2;
    m.Seats = 2;
    m.Run();
    m.Stop();
    return 0;
}

这个程序声明了一个车(vehicle)基类，具有MaxSpeed、weight等成员变量，Run、Stop等成员函数，并把vehicle基类派生为虚基类。然后派生出自行车(bicycle)类和汽车(motorcar)类，并从它们派生出摩托车(motorcycle)类。

在main()函数中，创建了一个摩托车对象m，并设置了它的各种属性。然后调用了它的Run()和Stop()函数，输出了相应的信息。

由于vehicle基类被派生为虚基类，摩托车类中继承的vehicle成员不会有多个拷贝，避免了多重继承的问题。

编写程序声明一个车(vehicle)基类,有run,stop等成员函数,由此派生出自行车(bicycle)类,汽车(motorcar)类,由bicycle和motorcar派生出摩托车(motorcy

### 回答1：
编写程序声明一个车(vehicle)基类，有run, stop等成员函数，由此派生出自行车(bicycle)类，汽车(motorcar)类，由bicycle和motorcar派生出摩托车(motorcycle)类。

### 回答2：
本题需求是编写程序声明一个车(vehicle)基类，有run，stop等成员函数，由此派生出自行车(bicycle)类，汽车(motorcar)类，由bicycle和motorcar派生出摩托车(motorcycle)类。给定基类和子类的设计要求和继承关系，需要我们按照要求设计并实现类的定义和成员函数，以下是本人编写的程序。

首先，我们需要定义车(vehicle)基类，包含成员函数run和stop，如下所示：

class vehicle {
public:
    void run() { cout << "The vehicle is running." << endl; }
    void stop() { cout << "The vehicle is stopped." << endl; }
};

接着，我们需要定义自行车(bicycle)类和汽车(motorcar)类，它们都是车(vehicle)类的子类，并继承了其基本属性和成员函数，只是它们有自己特定的属性和行为。自行车(bicycle)类继承了车(vehicle)类，并定义一个新成员函数ringBell，如下所示：

class bicycle : public vehicle {
public:
    void ringBell() { cout << "The bicycle is ringing bell." << endl; }
};

汽车(motorcar)类也继承了车(vehicle)类，并定义一个新成员函数refuel，如下所示：

class motorcar : public vehicle {
public:
    void refuel() { cout << "The motorcar is refueling." << endl; }
};

最后，我们需要定义一个摩托车(motorcycle)类，它既继承了自行车(bicycle)类的ringBell函数，又继承了汽车(motorcar)类的refuel函数，实现多重继承，如下所示：

class motorcycle : public bicycle, public motorcar {
public:
    void accelerate() { cout << "The motorcycle is accelerating." << endl; }
};

到这里，我们就完成了基类车(vehicle)和子类自行车(bicycle)，汽车(motorcar)和摩托车(motorcycle)的定义，完整程序如下所示：

#include <iostream>
using namespace std;

class vehicle {
public:
    void run() { cout << "The vehicle is running." << endl; }
    void stop() { cout << "The vehicle is stopped." << endl; }
};

class bicycle : public vehicle {
public:
    void ringBell() { cout << "The bicycle is ringing bell." << endl; }
};

class motorcar : public vehicle {
public:
    void refuel() { cout << "The motorcar is refueling." << endl; }
};

class motorcycle : public bicycle, public motorcar {
public:
    void accelerate() { cout << "The motorcycle is accelerating." << endl; }
};

int main() {
    motorcycle m;
    m.accelerate();
    m.ringBell();
    m.refuel();
    m.run();
    m.stop();

    return 0;
}

运行结果如下所示：

The motorcycle is accelerating.
The bicycle is ringing bell.
The motorcar is refueling.
The vehicle is running.
The vehicle is stopped.

同时需要注意的是，由于摩托车(motorcycle)类实现了多重继承，即继承了自行车(bicycle)类和汽车(motorcar)类的所有函数和属性，因此如果自行车类和汽车类中有同名的函数或属性，可能会引起命名冲突或二义性，需要特别注意。

### 回答3：
车)类。并对派生类添加相应成员函数和成员变量。

编写程序如下：

首先，将车(vehicle)类的基本属性和行为定义好，作为一个基类。其中，车(vehicle)的属性可以包括品牌、颜色、价格等。而车(vehicle)的行为则包括run，stop等成员函数。这些函数可以通过调用车(vehicle)类中的属性来实现其具体功能。代码如下：

class Vehicle {
protected:
    string brand;  // 品牌
    string color;  // 颜色
    double price;  // 价格

public:
    void run() {
        cout << "车正在行驶..." << endl;
    }

    void stop() {
        cout << "车已停止行驶..." << endl;
    }
};

然后，根据车(vehicle)类，我们派生出了自行车(bicycle)类和汽车(motorcar)类，这两个类都继承了车(vehicle)类中的属性和行为。自行车(bicycle)类可能只需要增加一个车轮数(wheels)属性，并重载run，stop两个方法即可，在这里我们默认自行车为两轮车。汽车(motorcar)类则需要增加引擎(emission)、油箱(capacity)等属性，并重载run，stop两个方法。代码如下：

class Bicycle : public Vehicle {
protected:
    int wheels;  // 车轮数

public:
    Bicycle() { Wheels = 2; }

    void run() {
        cout << "自行车正在行驶，快蹬..." << endl;
    }

    void stop() {
        cout << "自行车已经停下来了..." << endl;
    }
};

class Motorcar : public Vehicle {
protected:
    double emission;  // 排量

    double capacity;  // 油箱容量

public:
    void run() {
        cout << "汽车正在行驶，发动机轰鸣..." << endl;
    }

    void stop() {
        cout << "汽车已经停下来了..." << endl;
    }

    double get_emission() const { return emission; }

    void set_emission(double e) { emission = e; }

    double get_capacity() const { return capacity; }

    void set_capacity(double c) { capacity = c; }
};

最后，我们再根据自行车(bicycle)类和汽车(motorcar)类，派生出摩托车(motorcycle)类。摩托车(motorcycle)类同样继承了车(vehicle)类中的属性和行为。但是，由于摩托车(motorcycle)类有自己独特的属性，如驾驶方式(method)、最大速度(max_speed)等，因此需要增加这些新的属性。代码如下：

class Motorcycle : public Bicycle, public Motorcar {
protected:
    string method;  // 驾驶方式

    double max_speed;  // 最大速度

public:
    double get_max_speed() const { return max_speed; }

    void set_max_speed(double s) { max_speed = s; }

    string get_method() const { return method; }

    void set_method(string m) { method = m; }
};

通过上面的代码，我们已经实现了一个车(vehicle)基类，并通过派生类的方式，定义出了自行车(bicycle)类、汽车(motorcar)类和摩托车(motorcycle)类。派生类同时进行了相应的属性和行为的拓展，实现了对车(vehicle)基类的继承和拓展。这样，在后续实例化对象时，就可以轻松地根据需求来选用不同的类了。