Question

我想要一个模板父类（虚拟）。子类继承自父类，并在其自身内定义类型。

// PARENT
template <typename A, typename B>
class Parent 
{
public:
    Parent();
    virtual ~Parent();
    // ...
};

// CHILD
class Child : public Parent<SomeStruct , AnotherStruct>
{
public:
    struct SomeStruct 
    {/*...*/};

    struct AnotherStruct
    {/*...*/};

    Child();
    ~Child();
    // ...
};

很明显，编译器会抱怨尚未定义的＆＃34; SomeStruct＆＃34;。问题是如何实现类似的东西。一种简单的方法是在类外定义结构，但这会使事情变得更加丑陋。

Answer 1

它是鸡肉和鸡蛋的情况。编译器需要来查看声明的结构，以便它可以实例化Parent。

您可以尝试以下内容：

template <typename A, typename B>
class Parent 
{
public:
    Parent();
    virtual ~Parent();
    // ...
};

// CHILD
class ChildBase
{
    public:
    struct SomeStruct 
    {/*...*/};

    struct AnotherStruct
    {/*...*/};
};

class Child : public ChildBase, public Parent<ChildBase::SomeStruct, ChildBase::AnotherStruct>
{
public:
    using ChildBase::SomeStruct;
    using ChildBase::AnotherStruct;

    Child();
    ~Child();
    // ...
};

这是多重继承路由。或者，您可以将结构声明放在命名空间而不是基类中，而不会让它们位于全局命名空间中。

如果您想要Child :: SomeStruct类型的语法，那么这两种方式都不是您想要的，但不会污染全局命名空间并使类型在Child上可见。

Answer 2

你无法做你想做的事。

您可以转发声明一个类，但不能转发声明一个嵌套类。你必须重新考虑你的设计。

Answer 3

有一种解决方案可以帮助您。它并不完全像你在做，但它实现了同样的事情。它是使用“政策”idom完成的看看这个：

// PARENT
template <typename Policy>
struct Parent : Policy {
    Parent();
    virtual ~Parent();
    // ...
};

// CHILD POLICY
struct ChildPolicy {
    struct SomeStruct 
    {/*...*/};

    struct AnotherStruct
    {/*...*/};
}

// CHILD
struct Child : public Parent<ChildPolicy> {
    Child();
    ~Child();

    // Here you can use your two types 
    // ...
};

或者，如果您在Child中使用的类型在该类别的所有子级中具有完善的类型名称，则可以像这样声明父级：

template <typename Policy>
struct Parent {

    using typename Policy::SomeStruct;
    using typename Policy::AnotherStruct;

    Parent();
    virtual ~Parent();
    // ...
};

我强烈推荐父母的第二个解决方案

继承自模板类，在子类中声明类型

3 个答案: