#include <iostream> using namespace std; class B{ public: virtual void foo(){ cout << "Base::foo()\n"; } }; class C:public B{ public: void foo() {cout << "Derived::foo()\n"; } }; int main() { C c; B b, &p = c; c.foo(); b.foo(); p.foo(); return 0; }

这段代码定义了一个基类 `B` 和一个派生类 `C`，并在 `main()` 函数中分别创建了 `C` 类和 `B` 类的对象，以及一个指向 `C` 对象的基类指针 `p`。

在 `B` 类中定义了一个虚函数 `foo()`，并在 `C` 类中覆盖了该函数。在 `main()` 函数中，依次调用了 `c.foo()`、`b.foo()`、`p.foo()`。

由于 `C` 类继承自 `B` 类，并覆盖了 `foo()` 函数，因此调用 `c.foo()` 时输出的是 "Derived::foo()"。而由于 `b` 对象是 `B` 类型的，因此调用 `b.foo()` 时输出的是 "Base::foo()"。而 `p` 指向的是 `C` 对象，因此在调用 `p.foo()` 时，会根据动态绑定的规则调用 `C` 类中的 `foo()` 函数，输出的是 "Derived::foo()"。因此该代码的输出结果为：

Derived::foo()
Base::foo()
Derived::foo()

需要注意的是，由于 `B` 类中的 `foo()` 函数是虚函数，因此可以在派生类中覆盖它。在这种情况下，如果通过基类指针或引用调用虚函数，会根据对象的实际类型来选择调用哪个函数，这就是多态的实现机制。

相关问题

#include <iostream> #include <memory> class Foo { public: void Show() { std::cout << data; } private: int data{1}; }; int main() { std::unique_ptr<Foo> tom = std::make_unique<Foo>(); std::unique_ptr<Foo> jerry = std::move(tom);

这段代码是使用 C++11 中的 unique_ptr 实现了动态内存管理。其中，Foo 是一个简单的类，拥有一个数据成员 data 和一个成员函数 Show，用于打印该数据成员的值。

在 main 函数中，首先使用 std::make_unique 创建了一个名为 tom 的 unique_ptr 对象，该对象指向一个新创建的 Foo 对象。然后，使用 std::move 将 tom 的所有权转移给了 jerry，此时 jerry 指向的是之前由 tom 所指向的 Foo 对象。最后，程序结束时会自动调用 unique_ptr 的析构函数，释放所持有的内存。

unique_ptr 是一种独占式智能指针，它确保了动态分配的内存只有一个智能指针可以拥有。这种智能指针禁止了复制和赋值操作，但允许移动语义，因此可以用来管理动态分配的对象。

下列代码哪里有错误#include <iostream> using namespace std; class A { public: A() { cout << "A构造"; foo(); } virtual~A() { cout << "A析构"; foo(); } virtual void foo() { cout << "A foo ln"<<endl; } }; class B : public A { public: void foo(int i) { foo(); cout << "B foo \n"; } B() { cout << "B构造"; foo(); } virtual ~B() { cout << "B析构"; foo(); } };

代码中的错误在于：

1. 在 class B 中，foo 函数的重载与虚函数 A::foo 不匹配，应该保持函数签名一致。
2. 在 class A 中，foo 函数应该是纯虚函数，以实现多态。

修改后的代码如下：

#include <iostream> 
using namespace std; 

class A { 
public: 
    A() { 
        cout << "A构造"; 
        foo(); 
    } 
    virtual ~A() { 
        cout << "A析构"; 
        foo(); 
    } 
    virtual void foo() = 0; // 纯虚函数
}; 

class B : public A { 
public: 
    void foo() override { // 保持函数签名一致，并使用 override 关键字
        cout << "A foo ln" << endl; 
    }
    void foo(int i) { 
        foo(); 
        cout << "B foo \n"; 
    } 
    B() { 
        cout << "B构造"; 
        foo(); 
    } 
    virtual ~B() { 
        cout << "B析构"; 
        foo(); 
    } 
};