Accès à la classe interne

Question

Une classe écrite dans une méthode d'une autre classe (classe interne) peut-elle accéder aux variables de méthodes? Je veux dire dans le code ci-dessous:

class A 
{ 
    void methodA(int a) 
    { 
    class B 
    { 
     void processA() 
     { 
     a++; 
     } 
    }; 
    std::cout<<"Does this program compile?"; 
    std::cout<<"Does the value of the variable 'a' increments?"; 
    }; 

};

Est-ce légal? Est-ce que la valeur de 'a' augmente? S'il vous plaît suggérer comment.

Merci, Pavan.

Answer 1

Non, ce n'est pas légal
class B est une classe locale-methodA().

class B Impossible d'accéder aux variables locales "automatiques" non statiques de la fonction englobante. Mais il peut accéder aux variables statiques de la portée englobante.

Il existe plusieurs restrictions sur les classes locales auxquelles avoir accès.

est ici une référence de la norme C++:

9,8 déclarations de classe locales [class.local]

1. Une classe peut être définie dans une définition de fonction; une telle classe est appelée une classe locale. Le nom d'une classe locale est local à sa portée englobante. La classe locale est dans la portée de la portée englobante et a le même accès aux noms en dehors de la fonction que la fonction englobante. Les déclarations dans une classe locale peuvent utiliser uniquement des noms de type, des variables statiques, des variables et fonctions externes et des énumérateurs provenant de la portée englobante.

[Exemple:

int x; 
void f() 
{ 
    static int s ; 
    int x; 
    extern int g(); 

    struct local { 
     int g() { return x; } // error: x is auto 
     int h() { return s; } // OK 
     int k() { return ::x; } // OK 
     int l() { return g(); } // OK 
    }; 
// ... 
} 
local* p = 0; // error: local not in scope 

-fin exemple]

2. Une fonction d'enceinte n'a pas un accès privilégié à des membres de la classe locale; il obéit aux règles d'accès habituelles (article 11). Les fonctions membres d'une classe locale doivent être définies dans leur définition de classe, si elles sont définies. 3. Si la classe X est une classe locale, une classe emboîtée Y peut être déclarée dans la classe X et définie plus tard dans la définition de la classe X ou être définie plus tard dans la même portée que la définition de la classe X. La classe imbriquée dans une classe locale est une classe locale.

4. Une classe locale ne doit pas avoir de membres de données statiques.

Answer 2

Courte réponse, no. Les classes locales en C++ n'ont pas accès à leurs variables de fonction englobantes (avec quelques mises en garde). Vous pouvez en savoir plus sur les classes locales C++ here, et également voir nice SO answer. Pour souligner:

Une classe locale est déclarée dans une définition de fonction.Les déclarations dans une classe locale peuvent uniquement utiliser des noms de type, des énumérations, des variables statiques provenant de la portée englobante, ainsi que des variables et des fonctions externes.

int x;       // global variable 
void f()      // function definition 
{ 
     static int y;   // static variable y can be used by 
           // local class 
     int x;     // auto variable x cannot be used by 
           // local class 
     extern int g();   // extern function g can be used by 
           // local class 

     class local    // local class 
     { 
      int g() { return x; }  // error, local variable x 
             // cannot be used by g 
      int h() { return y; }  // valid,static variable y 
      int k() { return ::x; } // valid, global x 
      int l() { return g(); } // valid, extern function g 
     }; 
} 

int main() 
{ 
     local* z;    // error: the class local is not visible 
// ...}