¿Variable miembro estática dentro de una clase local en c ++?

Sé que no podemos declarar una variable miembro estática dentro de una clase local … pero la razón no está clara.

Así que por favor, ¿alguien puede explicarlo?

Además, ¿por qué no podemos acceder a una variable no estática definida dentro de la función, dentro de la cual se ha definido la clase local, directamente en las funciones miembro de la clase local?

En el código que figura a continuación:

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

La variable estática staticValue es directamente accesible, mientras que, por otro lado, el argumento argc desde main no es …

  1. Variables / funciones estáticas de la clase local : intente imaginar la syntax, la definición de la vida útil y la implementación de la gestión de nombres. Me rendiría bastante rápido 🙂
  2. No hay acceso a las variables locales desde la clase local : porque la instancia de la clase podría sobrevivir al scope de la función. Ejemplo:
     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; } 

    La instancia de clase declarada localmente ahora existiría más allá de la vida útil de las variables locales de la función.

Las dos preguntas están relacionadas. Creo que la respuesta no es clara porque la palabra clave static en C ++ tiene significados sobrecargados.

Cuando define una variable estática dentro de la función, realmente le está diciendo al comstackdor que la inicie solo en la primera llamada (para que pueda usar el valor en varias llamadas). Este no es exactamente el mismo caso de una variable estática de ámbito de archivo o de clase.

Teniendo esto en cuenta, podría no tener sentido definir una variable estática dentro de una clase local, que a su vez se define dentro de una función.

Con respecto a la segunda pregunta, una clase local puede acceder a las variables estáticas definidas en su función de cierre. El código a continuación, por ejemplo, debe comstackr en un comstackdor compatible con los estándares.

 void f() { static int i; class local { int g() { return i; } }; local l; /* ... */ } int main() { f(); return 0; } 

Las clases locales no tienen acceso completo a su entorno (gracias Richard) … tienes que usar, por ejemplo, referencias o indicadores para solucionarlo:

 void f() { int i = 0; struct local { int& i; local(int& i) : i(i) {} void f() { i = 1; } }; local l(i); lf(); assert(i==1); } 

Otra razón por la que no puede examinar las variables de la stack en el ámbito de cierre es que una función en la clase local no se llama necesariamente directamente desde la función de cierre.

En el siguiente ejemplo, la vida sería fácil si hello() fuera la única función en la clase: para encontrar la variable stackValue , hello() simplemente tendría que mirar el marco de stack de la persona que llama. Pero aquí, he introducido Local::goodbye() , que puede o no invocar Local::hello . En este caso, ¿cómo sabría Local::hello() dónde encontrar el marco de stack de la función envolvente? (Necesitaríamos cierres para hacer que esto funcione. Me encantan los cierres, pero no puedo ver que eso suceda en 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; } 

Las variables estáticas se inicializan cuando se inicia el progtwig. Las clases locales se cargan cuando se llama al método. Y descargado cuando finaliza la llamada al método.

Segun wikipedia

En la progtwigción de computadoras, una variable estática es una variable que se ha asignado de forma estática, cuya vida útil se extiende a lo largo de toda la ejecución del progtwig.

Esto contrasta con la carga y descarga de clases locales que tienen variables estáticas declaradas

Creo que la razón por la que las clases locales no pueden tener miembros estáticos (o funciones definidas fuera de la clase) es más por razones sintácticas que por razones semánticas. Los miembros estáticos podrían implementarse igual que en las clases no locales: la estática tendría la vida útil comenzando en la primera llamada a una función, al igual que las variables estáticas declaradas dentro de una función. El comstackdor tendría que asegurarse de que los miembros estáticos se inicializaron cuando se creó la primera instancia de la clase.

Imagine el problema con la mutilación de nombres ahora que la firma de la función adjunta se convierte en parte del nombre. 😉

La razón por la que no puede acceder a las variables o parámetros locales de una función en una clase local es que complicaría el código requerido para implementar la clase con poca ganancia. A los miembros no estáticos de una clase se suele acceder mediante el puntero “this” o el puntero a la instancia específica. Para acceder a las variables y los parámetros locales de la función de encierro se requeriría algún mecanismo para hacerlos accesibles. Ese mecanismo podría ser bastante trivial si las funciones estuvieran en línea, pero ¿qué sucede cuando no lo están?