MyInnerClass.h

namespace inner{
class MyInnerClass
{
    public:
    MyInnerClass();
    virtual ~MyInnerClass();
};

};

MyInnerClass.cpp

#include "MyInnerClass.h"
namespace inner
{

MyInnerClass::MyInnerClass()
{
}

MyInnerClass::~MyInnerClass()
{
}

}

MyOuterClass.h

#include "MyInnerClass.h"

namespace inner{
    class MyInnerClass;
};

class MyOuterClass
{
    public:
        MyOuterClass();
        virtual ~MyOuterClass();

    private:
        inner::MyInnerClass* ptrMyInnerClass;
};

MyOuterClass.cpp

#include "MyOuterClass.h"

MyOuterClass::MyOuterClass()
{
    ptrMyInnerClass= new inner::MyInnerClass();
}

MyOuterClass::~MyOuterClass()
{
}

方法2：实现为真正的内部类

class MyOuterClass
{
/*  Inner Class */
    public:
        class MyInnerClass
        {
            public:
                MyInnerClass() {}
                virtual ~MyInnerClass() {}
        };

    public:
        MyOuterClass();
        virtual ~MyOuterClass();

    private:
        MyInnerClass* ptrMyInnerClass;
};

Answer 1

在较大的项目中，否则会有障碍，将相似的对象或类归类到相应的名称空间中，以便于重构和可读性。

通常，一个仅对另一个对象是内在的对象，否则很少会被使用为私有内部类。这样，由于隐藏了实现且内部对象没有暴露，因此意图更加清晰。

Answer 2

我只知道名称空间方案的一个优点。使用命名空间，您可以转发声明的类，而如果外部类定义不可用，则可以对内部类进行相同的处理。因此，使用命名空间，您可以执行以下操作：

namespace Outer {
class Inner;
}

但是，如果Outer的定义不可用，则无法对内部类执行相同的操作：

class Outer; // we forward declare Outer
class Outer::Inner; // this doesn't compile

以同样的方式，如果没有定义Outer::Inner，就无法定义Outer。

因此，我几乎从不使用内部类（我只使用小型内部类，当我100％确定不需要前向声明时，通常是内部类不公开的情况）。

请注意，我通常使用第三个解决方案：我将“内部”类命名为OuterInner。

例如，如果您有一个名为SomeManager的外部类，并且有一个名为Node的公共内部类，那么我将使用class SomeManagerNode：

class SomeManager;
class SomeManagerNode;

我对此方法唯一了解的区别是SomeManagerNode无法访问SomeManager的非公共成员（如果Node是SomeManager的内部类，则可以访问它的所有成员）。但这在某些情况下可能是理想的，因此这并不是真正的缺点。但是，如果需要访问，则可以将SomeManagerNode声明为friend的{{1}}。

使用内部类的唯一原因是内部类是私有实现细节，而该类之外的任何地方都没有使用

。

在C ++中将内部类实现为具有名称空间的单独类的优势是什么？

MyInnerClass.h

MyInnerClass.cpp

MyOuterClass.h

MyOuterClass.cpp

2 个答案: