Clases locales en C++

Una clase declarada dentro de una función se vuelve local para esa función y se llama Clase local en C++.

• Un nombre de clase local solo puede usarse localmente, es decir, dentro de la función y no fuera de ella.
• Los métodos de una clase local solo deben definirse dentro de ella.
• Una clase local puede tener funciones estáticas pero no miembros de datos estáticos.

Por ejemplo, en el siguiente programa, Test es una clase local en fun(). 

// C++ program without any compilation error
// to demonstrate a Local Class
#include <iostream>
using namespace std;
  
// Creating the class
void fun()
{
    // local to fun
    class Test {
        // members of Test class
    };
}
  
// Driver Code
int main() { return 0; }

Los siguientes son algunos datos interesantes sobre las clases locales en C++:

1) Un nombre de tipo de clase local solo se puede usar en la función envolvente.

Por ejemplo, en el siguiente programa, las declaraciones de t y tp son válidas en fun(), pero no válidas en main(). 

// A program without any compilation error to demonstrate
// that a local class type name can only be used
// in the enclosing function
  
#include <iostream>
using namespace std;
  
void fun()
{
    // Local class
    class Test {
        // Body
    };
  
    Test t; // Fine
    Test* tp; // Fine
}
  
int main()
{
    Test t; // Error
    Test* tp; // Error
    return 0;
}

2) Todos los métodos de las clases locales deben definirse solo dentro de la clase. Por ejemplo, el programa 1 funciona bien y el programa 2 falla en la compilación.

Programa 1:

// C++ program without any compilation error to demonstrate
// that all the methods of Local classes must be defined
// inside the class only
#include <iostream>
using namespace std;
  
void fun()
{
    class Test // local to fun
    {
    public:
        // Fine as the method is defined
        // inside the local class
        void method()
        {
            cout << "Local Class method() called";
        }
    };
  
    Test t;
    t.method();
}
  
int main()
{
    fun();
    return 0;
}

Local Class method() called

Programa 2:

// C++ program with compilation error to demonstrate that
// all the methods of Local classes must be defined inside
// the class only
#include <iostream>
using namespace std;
  
void fun()
{
    class Test // local to fun
    {
    public:
        void method();
    };
  
    // Error as the method is defined outside the local
    // class
    void Test::method() { cout << "Local Class method()"; }
}
  
int main() { return 0; }

Producción
 

Compiler Error:
 In function 'void fun()':
 error: a function-definition is not allowed here before '{' token

3) Una clase local no puede contener miembros de datos estáticos. Sin embargo, puede contener funciones estáticas. Por ejemplo, el programa 1 falla en la compilación, pero el programa 2 funciona bien. 

Programa 1:

// A program with compilation error to demonstrate that
// a Local class cannot contain static data members
#include <iostream>
using namespace std;
  
void fun()
{
    class Test // local to fun
    {
        static int i;
    };
}
  
int main() { return 0; }

Producción

Compiler Error:
 In function 'void fun()':
 error: local class 'class fun()::Test' shall not have static data member 'int fun()::Test::i'

Programa 2:

// C++ program without any compilation error to demonstrate
// that a Local class cannot contain static data members
#include <iostream>
using namespace std;
  
void fun()
{
    class Test // local to fun
    {
    public:
        static void method()
        {
            cout << "Local Class method() called";
        }
    };
  
    Test::method();
}
  
int main()
{
    fun();
    return 0;
}

Local Class method() called

4) Los métodos miembros de la clase local solo pueden acceder a las variables estáticas y de enumeración de la función adjunta. Las variables no estáticas de la función envolvente no son accesibles dentro de las clases locales. Por ejemplo, el programa 1 compila y funciona bien. Pero, el programa 2 falla en la compilación.

Programa 1:

// C++ program without any compilation error to demonstrate
// that member methods of local class can only access static
// and enum variables of the enclosing function
#include <iostream>
using namespace std;
  
void fun()
{
    static int x;
    enum { i = 1, j = 2 };
  
    // Local class
    class Test {
    public:
        void method()
        {
            cout << "x = " << x
                 << endl; // fine as x is static
            cout << "i = " << i
                 << endl; // fine as i is enum
        }
    };
  
    Test t;
    t.method();
}
  
int main()
{
    fun();
    return 0;
}

x = 0
i = 1

Programa 2:

// C++ program with compilation error to demonstrate that
// member methods of local class can only access static
// and enum variables of the enclosing function
#include <iostream>
using namespace std;
  
void fun()
{
    int x;
  
    // Local class
    class Test {
    public:
        void method() { cout << "x = " << x << endl; }
    };
  
    Test t;
    t.method();
}
  
int main()
{
    fun();
    return 0;
}

Error:

prog.cpp: En la función miembro ‘void fun()::Test::method()’:

prog.cpp:14:43: error: uso de variable local con almacenamiento automático de función contenedora

         método void() { cout << “x = ” << x << endl; }

                                           ^

prog.cpp:9:9: nota: ‘int x’ declarado aquí

     intx;

         ^

5) Las clases locales pueden acceder a tipos, variables y funciones globales. Además, las clases locales pueden acceder a otras clases locales de la misma función. Por ejemplo, el siguiente programa funciona bien.
 

// C++ program without any compilation error to demonstrate
// that Local classes can access global types, variables and
// functions
#include <iostream>
using namespace std;
  
int x;
  
void fun()
{
  
    // First Local class
    class Test1 {
    public:
        Test1() { cout << "Test1::Test1()" << endl; }
    };
  
    // Second Local class
    class Test2 {
        // Fine: A local class can use other local classes
        // of same function
        Test1 t1;
  
    public:
        void method()
        {
            // Fine: Local class member methods can access
            // global variables.
            cout << "x = " << x << endl;
        }
    };
  
    Test2 t;
    t.method();
}
  
int main()
{
    fun();
    return 0;
}

Test1::Test1()
x = 0

Debe leer: Clases anidadas en C++