定义一个车(vehicle)基类，有虚函数run、stop等成员函数，由此派生出自行车（bicycle）类、汽车（motorcar）类，它们都有run、stop等成员函数。完成这些类使得主函数可以运行

### 回答1：
好的，以下是定义车(vehicle)基类，自行车（bicycle）类和汽车（motorcar）类的代码：

#include <iostream>
using namespace std;

class Vehicle {
public:
    virtual void run() {
        cout << "Vehicle is running." << endl;
    }
    virtual void stop() {
        cout << "Vehicle has stopped." << endl;
    }
};

class Bicycle : public Vehicle {
public:
    void run() {
        cout << "Bicycle is running." << endl;
    }
    void stop() {
        cout << "Bicycle has stopped." << endl;
    }
};

class Motorcar : public Vehicle {
public:
    void run() {
        cout << "Motorcar is running." << endl;
    }
    void stop() {
        cout << "Motorcar has stopped." << endl;
    }
};

int main() {
    Vehicle* v1 = new Bicycle();
    v1->run();
    v1->stop();

    Vehicle* v2 = new Motorcar();
    v2->run();
    v2->stop();

    delete v1;
    delete v2;

    return 0;
}

在这个代码中，我们定义了一个车(vehicle)基类，其中有虚函数run和stop等成员函数。然后我们派生出了自行车（bicycle）类和汽车（motorcar）类，它们都有自己的run和stop等成员函数。

在主函数中，我们创建了两个指向Vehicle类的指针v1和v2，分别指向一个自行车对象和一个汽车对象。然后我们调用它们的run和stop函数，输出它们各自的运行状态。最后我们释放了这两个对象的内存。

这样，我们就完成了这个题目的要求。

### 回答2：
车(vehicle)是一种交通工具，在程序设计中用面向对象的思想可以将其抽象为一个基类，定义一些基本的行为，有虚函数run、stop等成员函数，方便后续具体类的继承和重载这些行为。

自行车（bicycle）和汽车（motorcar）类可以从车(vehicle)基类继承这些行为，同时也可以定义自己独特的特性和行为。为了让主函数可以运行，这些类还需要具有特定的构造函数和析构函数来完成对象的创建和销毁。

下面是一个基于C++语言的实现示例：

#include <iostream>
using namespace std;

//定义车(vehicle)基类
class Vehicle {
public:
    //虚函数run
    virtual void run() = 0;
    //虚函数stop
    virtual void stop() = 0;
};

//自行车(bicycle)类
class Bicycle : public Vehicle {
public:
    //重载虚函数run和stop
    void run() {
        cout << "骑自行车前进" << endl;
    }
    void stop() {
        cout << "刹车停止自行车" << endl;
    }
};

//汽车(motorcar)类
class Motorcar : public Vehicle {
public:
    //重载虚函数run和stop
    void run() {
        cout << "驾驶汽车行驶" << endl;
    }
    void stop() {
        cout << "刹车停止汽车" << endl;
    }
};

//主函数
int main() {
    //定义自行车对象并调用方法
    Bicycle bike;
    bike.run();
    bike.stop();

    //定义汽车对象并调用方法
    Motorcar car;
    car.run();
    car.stop();

    return 0;
}

运行结果：

骑自行车前进
刹车停止自行车
驾驶汽车行驶
刹车停止汽车

在这个例子中，Vehicle是车的基类，Bicycle和Motorcar都从Vehicle类中继承了run和stop虚函数，并实现了自己独特的运输方式，可以在main函数中创建对象并调用对应方法。整个程序设计体现了面向对象的思想，具有扩展性和灵活性。

### 回答3：
车(vehicle)基类一般不用来实例化对象，而是作为派生类的基础，具备一些通用的属性和方法。对于车(vehicle)基类，我们可以定义以下成员函数：

1.虚函数run()：表示车辆行驶的方法。
2.虚函数stop()：表示车辆停止的方法。

通过这两个虚函数，我们可以在基类中定义车辆的基础行为，而具体的子类可以重写这些虚函数来定义自己的行为。

下面我们来看一下自行车和汽车派生类的实现：

1.自行车（bicycle）类：

自行车类可以继承车(vehicle)类的属性和方法。同时，由于自行车是一种没有引擎的交通工具，所以我们还可以在自行车类中添加额外的属性和方法，如pedal()，表示骑车时踩踏车踏板的方法。

class bicycle : public vehicle {
public:
void run() override { cout << "骑自行车"; }
void stop() override { cout << "停自行车"; }
void pedal() { cout << "踩踏车踏板"; }
};

2.汽车(motorcar)类：

汽车类同样可以继承车(vehicle)类的属性和方法。不同于自行车的是，汽车有更多的属性和方法，如加速（accelerate()）、刹车（brake()）等。

class motorcar : public vehicle{
public:
void run() override { cout << "开汽车"; }
void stop() override { cout << "停汽车"; }
void accelerate() { cout << "加速汽车"; }
void brake() { cout << "刹车汽车"; }
};

在主函数中，我们可以通过以下方式来实例化并调用自行车和汽车的方法：

int main() {
vehicle* v1 = new bicycle();
v1->run();
v1->stop();
delete v1;

vehicle* v2 = new motorcar();
v2->run();
v2->stop();
delete v2;

return 0;
}

通过这个实例，我们可以看到，通过基类车(vehicle)的虚函数run()和stop()，同时利用子类自行车(bicycle)和汽车(motorcar)类重写的run()和stop()，我们可以实现多态，实现了代码重用和扩展性。同时，我们可以在子类中添加更多的方法和属性，以满足具体的需求。