C++ c+；中局部类内的静态成员变量+；？

我知道我们不能在本地类中声明

静态
成员变量。。。但原因尚不清楚

有人能解释一下吗

另外，为什么我们不能直接在本地类成员函数中访问在函数中定义的非
静态

变量，在该变量中定义了本地类

在下面给出的代码中：

int main(int argc, char *argv[])
{
    static size_t staticValue = 0;

    class Local
    {
         int d_argc; // non-static data members OK
         public:
         enum // enums OK
         {
             value = 5
         };
         Local(int argc) // constructors and member functions OK
         : // in-class implementation required
          d_argc(argc)
         {
               // global data: accessible
               cout << "Local constructor\n";
               // static function variables: accessible
               staticValue += 5;
         }
         static void hello() // static member functions: OK
         { 
            cout << "hello world\n";
         }
   };
   Local::hello(); // call Local static member
   Local loc(argc); // define object of a local class.
   return 0;
}

intmain（intargc，char*argv[]）
{
静态大小\u t staticValue=0；
本地类
{
int d_argc；//非静态数据成员正常
公众：
枚举//枚举正常
{
值=5
};
Local（int argc）//构造函数和成员函数正常
：//需要类内实现
d_argc（argc）
{
//全球数据：可访问
cout本地类无法完全访问其环境（谢谢Richard）…您必须使用引用或指针来解决此问题：

void f() {
    int i = 0;

    struct local {
        int& i;
        local(int& i) : i(i) {}
        void f() { i = 1; }
    };

    local l(i);
    l.f();
    assert(i==1);
}

静态变量在程序启动时初始化。本地类在调用方法时加载。在方法调用结束时卸载

根据维基百科

在计算机程序设计中，一种静态
variable是一个已修改的变量
静态分配-谁的生存期
扩展到整个系统的整个运行
节目

<>这是与静态变量声明为
的局部类的加载和卸载的对比。这两个问题是相关的。我相信答案不清楚，因为C++中的<代码>静态< /Cord>关键字具有超载意义。< /P>
当您在函数中定义静态变量时，实际上是在告诉编译器仅在第一次调用中初始化它（这样您可以在多个调用中使用该值）。这与文件范围或类范围静态变量的情况不完全相同

考虑到这一点，在局部类中定义静态变量可能没有意义，而局部类又是在函数中定义的

关于第二个问题，本地类实际上可以访问其封闭函数中定义的静态变量


void f()
{
  static int i;
  class local
  {
    int g() { return i; }
  };

  local l;
  /* ... */
}

int main()
{
  f();
  return 0;
}

我认为本地类不能有静态成员（或在类之外定义的函数）的原因更多的是出于语法而非语义原因。静态成员可以像在非本地类中一样实现：静态成员的生存期从第一次调用函数时开始，就像在函数中声明的静态变量一样。编译器必须确保在第一次调用函数时初始化静态成员创建了e类

想象一下，既然封闭函数签名成为名称的一部分，那么名称损坏的问题就出现了。；-）

无法访问局部类中函数的局部变量或参数的原因是，这会使实现该类所需的代码复杂化，但增益很小。类的非静态成员通常通过“this”访问指向特定实例的指针或指针。要访问封闭函数的本地变量和参数，需要某种机制使其可访问。如果函数是内联的，则该机制可能相当简单，但如果函数不是内联的，会发生什么

本地类的静态变量/函数：试着想象一下语法、生命周期定义和名称混乱的实现。我很快就会放弃：）
无法从本地类访问本地变量：因为类实例可能超出函数范围。示例：
class interface; // base class declared somewhere

// creates specific implementations
interface* factory( int arg ) // arg is a local variable
{
  struct impl0: interface { /* ... */ }; // local class
  struct impl1: interface { /* ... */ }; // local class
  // ...

  switch ( arg )
  {
    case 0: return new impl0;
    case 1: return new impl1;
    // ...
  }

  return 0;
}
局部声明的类实例现在将在函数局部变量的生命周期之外存在。
无法检查封闭作用域中堆栈变量的另一个原因是，本地类中的函数不一定直接从封闭函数调用

在下面的示例中，如果
hello（）
是类中唯一的函数，那么生活就会很简单：要查找变量
stackValue
，
hello（）
只需查看调用方的堆栈帧即可<或代码>，它可能或可能不调用“代码>本地：：hello /c>”。在这种情况下，<>代码>本地：：HeloLo（）/Cord>知道在哪里找到封闭函数的堆栈框架？（我们需要闭包来实现这一工作。我喜欢闭包，但我不能看到C++中发生的事情）

intmain（intargc，char*argv[]）
{
静态大小\u t staticValue=0；
int size\u t stackValue=argc；
本地类
{
void hello（）
{ 
难道我不明白你的意思吗？你想在你的本地类函数中做什么？你能举个例子吗？如果没有代码示例，我们无法真正说出你在问什么，你的问题是不清楚的。我从来没有见过使用过本地类。在任何情况下，我也想不到它们会是一个有用的工具。我错误地表达了这个问题，很抱歉。我想问的是关于无法在本地类中直接访问的非静态成员的问题。本地类确实可以访问函数中的静态变量。您不需要引用。谢谢，出于某种原因，我从来没有意识到。@Dan：我同意本地变量访问（见我的第三段），我说的是本地静态成员。本地对象可以在函数体中定义，但它们不能将函数作为自己类型的对象离开。也就是说，本地类名不能用于返回类型或其周围函数的参数类型。但是，作为继承的前奏，可以使用本地类从一个现有类开始，允许周围的函数返回一个动态分配的本地构造的类对象，指针或引用可以通过基类指针或引用返回
int main(int argc, char *argv[])
{
    static size_t staticValue = 0;
    int size_t stackValue = argc;

    class Local
    {
         void hello() 
         { 
            cout << "stackValue is " << stackValue << "\n";
         }
         void goodbye()
         {
            if (stackValue == 42) {
                hello();
            }
            else {
                cout << "Goodbye!\n";
            }
         }
   };
   Local loc;
   loc.hello();
   stackValue = 42;
   loc.goodbye();
   return 0;
}