class Bed:virtual public Furniture{ public: void sleep(){ cout<<"Sleeping"<<endl; } }; class Sofa:virtual public Furniture{ public: void watchTV(){ cout<<"Watching TV"<<endl; } };

这段代码是一个简单的面向对象程序，其中 `Bed` 和 `Sofa` 类都继承了 `Furniture` 类，且都使用了虚继承，这是为了避免在多重继承时出现重复继承同一个基类的情况。

`Bed` 类中定义了一个 `sleep()` 方法，表示在床上睡觉。`Sofa` 类中定义了一个 `watchTV()` 方法，表示在沙发上看电视。

`Furniture` 类是一个基类，用于表示一种家具，其中包含了一些基本属性和方法。由于 `Bed` 和 `Sofa` 类都继承了 `Furniture` 类，因此它们都具有了 `Furniture` 类中定义的属性和方法。

虚继承是 C++ 中的一个特殊机制，用于解决多重继承时的问题。在多重继承中，如果两个或多个基类都继承了同一个基类，那么在派生类中就会出现多个相同基类的实例，这会导致内存浪费和程序错误。使用虚继承可以避免这种情况的发生，保证每个基类只有一个实例。

相关问题

#include <iostream> using namespace std; class A { private: int nVal; public: void Fun(){ cout << "A::Fun"<<endl;} void Do(){ cout << "A::Do"<<endl;} }; class B:public A{ public: virtual void Do(){ cout << "B::Do"<<endl;} }; class C:public B { public: void Do(){ cout << "C::Do"<<endl;} void Fun() { cout << "C::Fun"<<endl;} }; void Call( ){ p->Fun(); p->Do(); } int main(){ Call(new A()); ; return 0; }

这段代码存在一些问题，无法通过编译。主要问题如下：

1. `Call` 函数中使用了指针 `p`，但没有对其进行声明或初始化，会导致编译错误。可以将其声明为基类 A 的指针，如下所示：

void Call(A* p){
    p->Fun();
    p->Do();
}

2. `Call` 函数中调用了函数 `p->Do()`，由于 `Do` 函数被声明为虚函数，因此会根据指针所指向的对象类型来动态绑定对应的函数。但是，在本例中，由于 `Call` 函数的参数类型为 `A*`，因此无论传递的是 `A`、`B` 还是 `C` 类型的对象，都将调用基类 `A` 中的 `Do` 函数，而不是子类 `B` 或 `C` 中的函数。可以将参数类型改为 `B*` 或 `C*`，这样就能够正确地调用对应的函数，如下所示：

void Call(B* p){
    p->Fun();
    p->Do();
}

3. 在 `main` 函数中，调用了 `Call` 函数，并传递了一个 `A` 类型的对象指针。由于 `A` 类型没有继承关系，因此无法将其转换为 `B` 或 `C` 类型的指针。可以将其改为传递一个 `B` 或 `C` 类型的对象指针，例如：

Call(new B());
Call(new C());

修改后的代码如下所示：

#include <iostream>
using namespace std;

class A {
private:
    int nVal;
public:
    void Fun(){ cout << "A::Fun" << endl; }
    void Do(){ cout << "A::Do" << endl; }
};

class B:public A {
public:
    virtual void Do(){ cout << "B::Do" << endl; }
};

class C:public B {
public:
    void Do(){ cout << "C::Do" << endl; }
    void Fun(){ cout << "C::Fun" << endl; }
};

void Call(B* p){
    p->Fun();
    p->Do();
}

int main(){
    Call(new B());
    Call(new C());

    return 0;
}

输出结果为：

A::Fun
B::Do
A::Fun
C::Do

#include <iostream> #include <string> using namespace std; class Animal{ public: //(1)定义纯虚函数实现多态，eat、run、sleep三个函数 12分 }; class Dog: public Animal{ public: virtual void eat() { cout << "狗吃骨头" << endl; } virtual void run() { cout << "狗奔跑" << endl; } virtual void sleep() {cout << "狗睡觉" << endl; } }; class Cat : public Animal{ public: virtual void eat() { cout << "猫吃鱼" << endl; } virtual void run() { cout << "猫走路" << endl; } virtual void sleep() {cout << "猫睡觉" << endl; } }; class Feeder{ public: void feed() { a.eat(); a.run();a.sleep()}//(2)补充形参 6分 }; int main(void) { Dog d; Cat c; Feeder f; f.feed(d) _________//（3）补全语句，完成动态多态 6分 return 0; }

补充内容如下：

(1) Animal 类中定义纯虚函数实现多态，eat、run、sleep 三个函数。

class Animal {
public:
virtual void eat() = 0;
virtual void run() = 0;
virtual void sleep() = 0;
};

(2) Feeder 类中的 feed 函数需要接收一个 Animal 类型的参数，因为它需要调用该参数的 eat、run、sleep 函数。

class Feeder{
public:
void feed(Animal &a) {
a.eat();
a.run();
a.sleep();
}
};

(3) main 函数中调用 feed 函数时需要传入一个 Animal 的子类，这里可以传入 Dog 或 Cat 的对象，实现动态多态。

int main(void) {
Dog d;
Cat c;
Feeder f;
f.feed(d); // 调用 feed 函数，传入 Dog 对象
f.feed(c); // 调用 feed 函数，传入 Cat 对象
return 0;
}