статическая переменная-член внутри локального класса в С++?

Два вопроса связаны. Я полагаю, что ответ вам не ясен, потому что ключевое слово static в C++ имеет перегруженные значения.

Когда вы определяете статическую переменную внутри функции, вы на самом деле говорите компилятору инициализировать ее только при первом вызове (чтобы вы могли использовать значение при нескольких вызовах). Это не совсем то же самое, что и в случае статической переменной области файла или области класса.

Имея это в виду, может не иметь смысла определять статическую переменную внутри локального класса, который, в свою очередь, определяется внутри функции.

Что касается вашего второго вопроса, локальный класс на самом деле может получить доступ к статическим переменным, определенным в его закрывающей функции. Приведенный ниже код, например, должен компилироваться в компиляторе, совместимом со стандартами.

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

  local l;
  /* ... */
}

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

Локальные классы не имеют полного доступа к своей среде (спасибо, Ричард)... вам нужно использовать, например. ссылки или указатели, чтобы обойти это:

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);
}

Другая причина, по которой вы не можете исследовать переменные стека в объемлющей области, заключается в том, что функция в локальном классе не обязательно вызывается непосредственно из объемлющей функции.

В приведенном ниже примере жизнь была бы проще, если бы hello() была единственной функцией в классе: чтобы найти переменную stackValue, hello() нужно было бы просто заглянуть во фрейм стека вызывающего объекта. Но здесь я представил Local::goodbye(), который может вызывать или не вызывать Local::hello. В этом случае, как Local::hello() узнать, где найти кадр стека закрывающей функции? (Для этого нам понадобятся замыкания. Мне нравятся замыкания, но я не вижу, чтобы это происходило в C++.)

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;
}

Статические переменные инициализируются при запуске программы. Локальные классы загружаются при вызове метода. И выгружается, когда заканчивается вызов метода.

Согласно Википедии

В компьютерном программировании статическая переменная — это переменная, которая была выделена статически, время жизни которой распространяется на весь запуск программы.

Это отличается от загрузки и выгрузки локальных классов с объявленными статическими переменными.

Я думаю, что причина того, что локальные классы не могут иметь статических членов (или функций, определенных вне класса), больше связана с синтаксисом, чем семантикой. Статические члены могут быть реализованы так же, как и в нелокальных классах: статические будут иметь время жизни, начинающееся с первого вызова функции, как и статические переменные, объявленные внутри функции. Компилятор должен убедиться, что статические члены были инициализированы при создании первого экземпляра класса.

Представьте себе проблему с искажением имени теперь, когда сигнатура закрывающей функции становится частью имени. ;-)

Причина, по которой вы не можете получить доступ к локальным переменным или параметрам функции в локальном классе, заключается в том, что это усложнит код, необходимый для реализации класса с небольшим выигрышем. Доступ к нестатическим членам класса обычно осуществляется через указатель this или указатель на конкретный экземпляр. Для доступа к переменным и параметрам, локальным для объемлющей функции, потребуется некоторый механизм, делающий их доступными. Этот механизм мог бы быть довольно тривиальным, если бы функции были встроенными, но что произойдет, если это не так?