c++ - 是否有没有前向声明的不完整嵌套类型的语法？

Question

以下程序产生诊断错误。

#include <memory>
class Containing {
    // class Nested;                 // [1]: This line seems required.
    typedef std::shared_ptr<class Nested> Ptr;
    class Nested {
        Ptr & ptr ();
        void foo (const Ptr &p) {
            p->ptr() = ptr()->ptr(); // [2]: Error here without [1]
        }
    };
};
int main () {}

生成的诊断是:

prog.cpp:8:14: error: invalid use of incomplete type 'class Nested'
             p->ptr() = ptr()->ptr();
              ^
prog.cpp:4:35: error: forward declaration of 'class Nested'`
     typedef std::shared_ptr<class Nested> Ptr;
                                   ^

但是，如果我取消注释前向声明，编译就会成功。我相信原因是Nested当它用于 shared_ptr<> 时假定为不嵌套.如果是这样，是否有一种语法可以用来让 shared_ptr<>知道Nested嵌套没有前向声明？像这样的东西:

class Containing {
    typedef std::shared_ptr<class Containing::Nested> Ptr;
    //...

---

这个问题用一个最小的例子来说明问题。实际结构如下:

class Containing {
    typedef std::shared_ptr<class NestedInterface> Ptr;
    class NestedObject {
        Ptr ptr_;
        //...
    };
    class NestedInterface {
        virtual NestedObject & object () = 0;
        void foo (const Ptr &p) {
            // ...
        }
        //...
    };
    class NestedType1 : NestedInterface {
        NestedObject obj_;
        NestedObject & object () { return obj_; }
        //...
    };
    class NestedType2 : NestedInterface {
        Containing &c_;
        NestedObject & object () { return c_.nested_object_; }
        //...
    };
    //...

Answer 1

不，没有。

但是，您根本不需要避免前向声明。这有效:

class Containing {
    class NestedInterface;
    typedef std::shared_ptr<NestedInterface> Ptr;
    class NestedObject {
        Ptr ptr_;
        //...
    };
    class NestedInterface {
        // ...
    };
};

有时类内部的交叉依赖性可能会使这很难做到。在这种情况下，您需要做的就是避免定义内联引用类，而是声明其他 类外联，如下所示:

class Containing {
    class NestedInterface;
    class NestedObject;
    typedef std::shared_ptr<NestedInterface> Ptr;
};
class Containing::NestedObject {
    Ptr ptr_;
    //...
};
class Containing::NestedInterface {
};

请注意，一般来说，在 C++ 中，嵌套类不能像在其他语言中那样随心所欲地使用——您通常可以使用外部类实现相同的效果，而且它们在这种情况下表现得更好。 (它们不需要外部类的定义。)只有在少数情况下它们才是绝对必要的。 (想到 std::allocator<T>::rebind<U>。)