C++ 创建嵌套类的实例

我有这样的代码：

class outer{
   int x;
   class inner{
     int y;
   }

   void print(int t_x){
     std::cout << t_x;
   }
}

类外部{
int x；
班级内部{
int-y；
}
无效打印（int t_x）{
标准：：cout
有没有办法只创建类内部的实例

是的，您可以让
外部
创建任意多个
内部
的实例独立实例（例如，作为
静态
成员函数中的静态成员或局部变量）

如果这是可能的，这个对象是否可以访问
outer:：print
函数

否。
outer:：print（）
仅适用于
outer
的实例，因此至少需要
outer
的参数或本地实例


外部
和
内部
类声明在实例化方面是完全独立的。它只涉及范围：


内部
类型仅在
私有
外部
类范围内可见（可以使用通过函数接收的
外部
之外的匿名
自动
类型规避）
内部
可以访问
外部
的任何
公共
、
受保护
和
私有
成员（特殊范围特权）
外部
可以像往常一样访问
内部
的任何
公共
成员（无特殊特权）
这称为嵌套类，而不是内部类。
嵌套类最常见的用例是标准库的迭代器。它们的模板在相关的容器模板中声明

要创建嵌套类的实例，应该有权访问其声明。它只能从
外部
类或该类的朋友处实例化

class outer{
   int x;   

   class inner;
public:
   void doThings();
};

   class outer::inner
   {
   public:    
     void print(class outer *p)
     {
       std::cout << "x=" << p->x;
     }
   };

 void outer::doThings()
 {
    outer::inner a;
    a. print(this);
 }

int main()
{
    outer a;

    a.doThings();
    return 0;
}

2嵌套类的成员函数和静态数据成员可以
在包含其类定义的命名空间范围中定义

3如果在命名空间范围中定义了类X，则可以在类X中声明嵌套类Y，然后在类X的定义中定义嵌套类Y
或者稍后在包含
第十类

4与成员函数一样，在
嵌套类位于该类的词法范围内；它遵循相同的
将名称绑定为该类的静态成员函数的规则
（9.4），但它对封闭系统的成员没有特殊访问权
班级

如果你从来没有创建一个“外”的实例，那么“内部”如何访问外部的？？？代码>内码>代码，它的工作方式与你在代码外定义的一样。但是它的范围仅限于<代码>外< />代码。（java中的“内部类”概念在C++中不存在）。
internal
是私有的，你不能在
outer
之外创建它的实例。还有
outer
的
朋友可以创建
internal
的实例。我怀疑OPs无意只询问
private
internal
。如果是
public
的话，任何人都可以访问
inner
你所说的“至少需要一个参数”是什么意思？你确定你的最后一句话吗？这对我来说是出乎意料的。看起来你是对的：我会更正我的答案。@user0042参见标准的9.7。好吧，你看到了代码，其中
外部：：内部：：打印
访问私有成员变量。
int x;
int y;
struct enclose {
    int x;
    static int s;
    struct inner {
        void f(int i) {
            int a = sizeof(x); // OK: operand of sizeof is an unevaluated operand
            x = i; // error: assign to enclose::x
            s = i; // OK: assign to enclose::s
            ::x = i; // OK: assign to global x
            y = i; // OK: assign to global y
        }
        void g(enclose* p, int i) {
            p->x = i; // OK: assign to enclose::x
        }
    };
};
inner* p = 0; // error: inner not in scope

struct enclose {
    struct inner {
        static int x;
        void f(int i);
    };
};
int enclose::inner::x = 1;
void enclose::inner::f(int i) { / ... / }

class E {
    class I1; // forward declaration of nested class
    class I2;
    class I1 { }; // definition of nested class
};
class E::I2 { }; // definition of nested class