C++抽象类型初始化

发布于 2024-10-12 04:48:43 字数 598 浏览 4 评论 0原文

我有一个类接口，它有纯虚方法。在另一个类中，我有一个继承自 Interface 的嵌套类型，并使其成为非抽象的。我使用 Interface 作为类型并使用函数来初始化类型，但我得到的是，由于抽象类型而无法编译。

接口：

struct Interface
{
   virtual void something() = 0;
}

实现：

class AnotherClass
{
    struct DeriveInterface : public Interface
    {
        void something() {}
    }

    Interface interface() const
    {
        DeriveInterface i;
        return i;
    }
}

用法：

struct Usage : public AnotherClass
{
    void called()
    {
        Interface i = interface(); //causes error
    }
}

原文

I have a class Interface, that has pure virtual methods. In another class I have a nested type that inherits from Interface and makes it non-abstract. I use Interface as a type and use the function to initialise the type, but I am getting, cannot compile because of abstract type.

Interface:

struct Interface
{
   virtual void something() = 0;
}

Implementation:

class AnotherClass
{
    struct DeriveInterface : public Interface
    {
        void something() {}
    }

    Interface interface() const
    {
        DeriveInterface i;
        return i;
    }
}

Usage:

struct Usage : public AnotherClass
{
    void called()
    {
        Interface i = interface(); //causes error
    }
}

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

往昔成烟 2024-10-19 04:48:43

您使用抽象类作为指针和引用，因此您需要

class AnotherClass
{
    struct DeriveInterface : public Interface
    {
        void something() {}
    }

    DeriveInterface m_intf;

    Interface &interface() const
    {
        return m_intf;
    }
}

struct Usage : public AnotherClass
{
    void called()
    {
        Interface &i = interface();
    }
}

加上几个分号，这样就可以正常工作。请注意，在 C++ 中只有指针和引用是多态的，因此即使 Interface 不是抽象的，由于所谓的切片，代码也会不正确。

struct Base { virtual int f(); }
struct Der: public Base { 
   int f(); // override
};

...
Der d;
Base b=d; // this object will only have B's behaviour, b.f() would not call Der::f

You use abstract classes as pointer and references, so you'd do

class AnotherClass
{
    struct DeriveInterface : public Interface
    {
        void something() {}
    }

    DeriveInterface m_intf;

    Interface &interface() const
    {
        return m_intf;
    }
}

struct Usage : public AnotherClass
{
    void called()
    {
        Interface &i = interface();
    }
}

plus a couple of semicolons and it will work fine. Note that only pointers and references are polymorphic in C++, so even if Interface were not abstract, the code would be incorrect because of so-called slicing.

struct Base { virtual int f(); }
struct Der: public Base { 
   int f(); // override
};

...
Der d;
Base b=d; // this object will only have B's behaviour, b.f() would not call Der::f

回复收藏 0 原文