#include <iostream> using namespace std; class vehicle { ....... }; class bicycle....... { float Height; public: ....... }; class motorcar...... { int SeatNum; public: ....... }; class motorcycle...... { public: ...... }; //fun函数实现 ...... int main() { vehicle v; bicycle by; motorcar mc; motorcycle mcy; fun(&v); fun(&by); fun(&mc); fun(&mcy); return 0; }

好的，以下是一个基本的 C++ 实现：

#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:
    float Height;

    void run() override {
        cout << "Bicycle is running." << endl;
    }

    void stop() override {
        cout << "Bicycle has stopped." << endl;
    }
};

class Motorcar : public Vehicle {
public:
    int SeatNum;

    void run() override {
        cout << "Motorcar is running." << endl;
    }

    void stop() override {
        cout << "Motorcar has stopped." << endl;
    }
};

class Motorcycle : public Bicycle, public Motorcar {
public:
    void run() override {
        cout << "Motorcycle is running." << endl;
    }

    void stop() override {
        cout << "Motorcycle has stopped." << endl;
    }
};

void fun(Vehicle* v) {
    v->run();
    v->stop();
}

int main() {
    Vehicle v;
    Bicycle by;
    Motorcar mc;
    Motorcycle mcy;

    fun(&v);
    fun(&by);
    fun(&mc);
    fun(&mcy);

    return 0;
}

在这个实现中，我们定义了一个基类 `Vehicle`，它有 `run` 和 `stop` 两个虚函数。然后我们分别定义了 `Bicycle` 和 `Motorcar` 两个子类，它们都继承了 `Vehicle`。在 `Bicycle` 类中，我们增加了 `Height` 属性，并重写了 `run` 和 `stop` 函数。在 `Motorcar` 类中，我们增加了 `SeatNum` 属性，并重写了 `run` 和 `stop` 函数。

最后，我们定义了一个 `Motorcycle` 类，它同时继承了 `Bicycle` 和 `Motorcar`。这个类也重写了 `run` 和 `stop` 函数。注意，在这个实现中，我们使用了 `override` 关键字来明确表示这些函数是重写基类的虚函数。

在 `main` 函数中，我们定义了一个 `Vehicle` 对象、一个 `Bicycle` 对象、一个 `Motorcar` 对象和一个 `Motorcycle` 对象，并分别调用了 `fun` 函数来测试它们的 `run` 和 `stop` 函数。请注意，在 `fun` 函数中，我们使用了基类的指针来接收这些对象，这样可以实现多态性。