覆盖中的几个基本问​​题

Question

我的基本功能没有什么问题，如果有人能解决这个问题，我将不胜感激。

1：当我说 base *b 时是什么意思 =新派生；为什么要这么做呢？我们很好分开 为类基创建对象并 派生类，然后调用 相应地发挥作用。我知道 这个基 *b = 新派生的；是 称为对象切片，但为什么和 人们什么时候会这样做呢？

2：我知道 为什么不建议转换 要派生的基类对象 类对象（因为基类是 不知道派生类 成员和方法）。我什至读过 其他 StackOverflow 线程，如果 那么我们就会这样 必须改变/重新访问我们的设计。 我明白这一切，但是，我 只是好奇，有什么办法吗 这？

    class base
    {
    public:
        void f(){cout << "In Base";}
    };

    class derived:public base
    {
    public:
        void f(){cout << "In Derived";}
    };

    int _tmain(int argc, _TCHAR* argv[])
    {
        base b1, b2;
        derived d1, d2;
        b2 = d1;
        d2 = reinterpret_cast<derived*>(b1); //gives error C2440
        b1.f(); // Prints In Base
        d1.f(); // Prints In Derived
        b2.f(); // Prints In Base
        d1.base::f(); //Prints In Base
        d2.f();
        getch();
        return 0;
    }

3：在上面的示例中，有什么方法可以使用派生类对象调用基类 f() 吗？我使用 d1.base()::f() 我只是想知道是否有任何方法不使用范围解析运算符？

非常感谢您花时间帮助我！

Answer 1

1.这不是对象切片：

base *b = new derived;

这是将base类型的指针分配给衍生的实例。

一个（非常常见的）例子是回调。考虑一下：

class Observer
{
public:
    virtual void OnEvent() = 0;
};

class Subject
{
public:
    Subject() : observer(0) {}
    void SetObserver(Observer* o) { observer = o; }
    void FireEvent() { if(observer != 0) observer->OnEvent(); }
private:
    Observer* observer;
};

class MyObserver : public Observer
{
public:
    void OnEvent() { ::printf("Hi there!\n"); }
};

int main()
{
    Subject s;
    MyObserver o;
    s.SetObserver(&o);
    s.FireEvent();
    return 0;
}

这应该是预期的输出：

你好！

注意这里发生了什么。我们将一个指向 MyObserver 实例的指针传递给 SetObserver()，即使该函数只接受 Observer 类型的指针。这是有效的，因为 MyObserver（公开）派生自 Observer。在这种情况下，我们说 MyObserver is-an Observer。

Observer 类型定义一个纯虚函数（=0 表示该函数是纯函数；它必须由派生类实现）。 virtual 关键字告诉编译器调用该函数应该导致执行最接近的派生函数。 MyObserver 中的 OnEvent() 函数是最派生的，因此，即使我们在以下位置调用 OnEvent()，也会调用该版本： Observer 类型的指针。

我们经历了所有这一切的麻烦，因为在这段代码中，Subject 不必知道其观察者的确切类型 - 观察者只需要从 Observer 派生并且Subject 实例将调用 OnEvent() 的最派生类型的实现。这允许代码解耦 - Subject 不依赖于 MyObserver，并且 MyObserver 不依赖于 Subject 。

2.将指针从基类转换为派生类型本身并没有什么问题。以下内容实际上是合法的，并且保证可以工作：

class Base {};
class Derived : public Base {};

int main()
{
    Derived d;
    Base* bp = &d;
    Derived* dp = static_cast<Derived*>(bp);
    return 0;
}

但是，此代码片段中的 return 语句之前的行是未定义的：

class Base {};
class Derived1 : public Base {};
class Derived2 : public Base {};

int main()
{
    Derived1 d1;
    Base* bp = &d1;
    Derived2* d2p = static_cast<Derived2*>(bp); // WTF?!
    return 0;
}

d2p 指针的值是没有意义的，尝试访问其中的任何内容都会肯定会导致崩溃，因为 bp 指针实际上并不指向 Derived2 实例，它指向 Derived1 实例。编译器无法在编译时捕获这一点，因为 Derived1 和 Derived2 都继承自 Base，因此强制转换可以成功编译。这是从基类型转换为派生类型的主要危险 - 直到运行时您才会知道转换是否实际上返回有意义的结果。

当然，除非您使用dynamic_cast<>()，但强制转换会导致运行时损失。 static_cast<>() 最多涉及指针运算。 reinterpret_cast<>() 强制指针采用不同的（可能不相关的）类型，而不执行任何指针算术。这使得reinterpret_cast<>()成为更危险的强制转换之一，并且应该仅在必要时使用，特别是当static_cast<>()可以完成这项工作时。

3. 考虑以下事项：

class Base
{
public:
    void Foobar() { ::printf("In Base!\n"); }
};

class Derived : public Base
{
public:
    void Foobar() { ::printf("In Derived!\n"); }
};

int main()
{
    Derived d;
    Derived* dp = &d;
    Base* bp = dp;
    dp->Foobar();
    bp->Foobar();
    return 0;
}

如果 Foobar() 函数不是虚拟的，那么您将得到以下输出：

In Derived!
In Base!

否则，如果 Foobar() > 函数是虚拟的，那么您将得到以下输出：

In Derived!
In Derived!

为了保证对虚拟函数 Foobar() 的调用通过基指针调用基本实现，您必须使用作用域解析运算符：

// Prints "In Base!", even if bp actually points
// to an instance of Derived overriding Foobar().
bp->Base::Foobar();

Answer 2

是和不是。你可以走了
派生类：公共基础{
公共：无效f（）{基点：：f（）; }
不过，

我在全球范围内不太确定。

Answer 3

问题 1：为什么要这样做：您可能不会直接这样做。发生这种情况的情况是，例如，您有一个返回“某种基数*”的函数，而您不关心是哪种类型。

问题2：在派生类中，您需要使用范围解析运算符来指定您要使用基类的实现。

注意：您还没有将函数声明为虚拟的，因此您实际上不会获得您期望的行为。

Answer 4

base *b = new derived

创建指向派生类对象的基类指针。这允许您创建is-a关系。派生类是基类。请参阅继承了解更多详细信息。

2<代码>。 d2=reinterpret_cast<衍生*>(b1);
您正在尝试将基类对象转换为派生类对象。但使用的强制转换操作是 .这是不正确的。

如果您计划调用基类方法，则使用基类指针。

Base* ptr = &b1;
ptr->f();

我建议您参考FAQ Lite。

Answer 5

base *b = new derived;

(1) 您有一个指向派生类对象的基类指针。在实现多态性时使用此方法，其中您有多个从公共基类继承的派生类。然后，您可以根据基类指针的类型调用正确的派生类函数，前提是该函数是虚拟的。

class base
{
    public:
        virtual void f(){ cout << "In Base" << endl; }
};

class derived:public base
{
    public:
        void f(){ cout << "In Derived" << endl; }
};

class derived2: public derived
{
public:
    void f() { cout << "In Derived2" << endl; }
};

int _tmain(int argc, _TCHAR* argv[])
{
    derived d1;
    derived2 d2;
    base* b;
    b = &d1;
    b->f();   // calls derived::f();
    b = &d2;
    b->f();   // calls derived2::f();
    return 0;
}

而且它不称为对象切片。对象切片是指将派生类对象分配给基类对象（而不是指针），其中派生类对象的成员被切片（保留）。因此，您无法从基类对象访问这些切片成员。

(2) 除了使用reinterpret_cast 的行之外，其他语句都可以。

(3) 如果您使用对象或重写派生类函数来调用基类版本（如其他答案中提到的），则必须使用范围解析运算符。但是，您可以使用指针：

derived *d = static_cast( &b1 );
d->f();