Clases de almacenamiento en C++ con ejemplos

Las clases de almacenamiento se utilizan para describir las características de una variable/función. Estas características incluyen básicamente el alcance, la visibilidad y el tiempo de vida que nos ayudan a rastrear la existencia de una variable en particular durante el tiempo de ejecución de un programa. Para especificar la clase de almacenamiento para una variable, se debe seguir la siguiente sintaxis:

Sintaxis: 

storage_class var_data_type var_name; 

C++ utiliza 5 clases de almacenamiento, a saber: 

1. auto
2. Registrarse
3. externo
4. estático
5. mudable

A continuación se muestra la explicación detallada de cada clase de almacenamiento: 

• auto : la palabra clave auto proporciona capacidades de inferencia de tipo, mediante las cuales se puede realizar la deducción automática del tipo de datos de una expresión en un lenguaje de programación. Esto consume menos tiempo al tener que escribir cosas que el compilador ya sabe. Como todos los tipos se deducen solo en la fase de compilación, el tiempo de compilación aumenta ligeramente pero no afecta el tiempo de ejecución del programa. Esta característica también se extiende a funciones y parámetros de plantilla que no son de tipo. Desde C++14 para funciones, el tipo de devolución se deducirá de sus declaraciones de devolución. Desde C++17, para los parámetros de plantilla que no son de tipo, el tipo se deducirá del argumento.

Ejemplo: 

#include <iostream>
using namespace std;
 
void autoStorageClass()
{
 
    cout << "Demonstrating auto class\n";
 
    // Declaring an auto variable
    // No data-type declaration needed
    auto a = 32;
    auto b = 3.2;
    auto c = "GeeksforGeeks";
    auto d = 'G';
 
    // printing the auto variables
    cout << a << " \n";
    cout << b << " \n";
    cout << c << " \n";
    cout << d << " \n";
}
 
int main()
{
 
    // To demonstrate auto Storage Class
    autoStorageClass();
 
    return 0;
}

Demonstrating auto class
32 
3.2 
GeeksforGeeks 
G

• externo: la clase de almacenamiento externo simplemente nos dice que la variable está definida en otro lugar y no dentro del mismo bloque donde se usa. Básicamente, el valor se le asigna en un bloque diferente y esto también se puede sobrescribir/cambiar en un bloque diferente. Entonces, una variable externa no es más que una variable global inicializada con un valor legal donde se declara para usarse en otro lugar. Se puede acceder desde cualquier función/bloque. Además, una variable global normal también se puede convertir en externa colocando la palabra clave ‘externa’ antes de su declaración/definición en cualquier función/bloque. Básicamente, esto significa que no estamos inicializando una nueva variable, sino que estamos usando/accediendo solo a la variable global. El objetivo principal de usar variables externas es que se puede acceder a ellas entre dos archivos diferentes que forman parte de un programa grande.enlace _

Ejemplo: 

#include <iostream>
using namespace std;
 
// declaring the variable which is to
// be made extern an initial value can
// also be initialized to x
int x;
void externStorageClass()
{
 
    cout << "Demonstrating extern class\n";
 
    // telling the compiler that the variable
    // x is an extern variable and has been
    // defined elsewhere (above the main
    // function)
    extern int x;
 
    // printing the extern variables 'x'
    cout << "Value of the variable 'x'"
         << "declared, as extern: " << x << "\n";
 
    // value of extern variable x modified
    x = 2;
 
    // printing the modified values of
    // extern variables 'x'
    cout
        << "Modified value of the variable 'x'"
        << " declared as extern: \n"
        << x;
}
 
int main()
{
 
    // To demonstrate extern Storage Class
    externStorageClass();
 
    return 0;
}

Demonstrating extern class
Value of the variable 'x'declared, as extern: 0
Modified value of the variable 'x' declared as extern: 
2

• static : esta clase de almacenamiento se usa para declarar variables estáticas que se usan popularmente al escribir programas en lenguaje C++. ¡Las variables estáticas tienen la propiedad de preservar su valor incluso después de que estén fuera de su alcance! Por lo tanto, las variables estáticas conservan el valor de su último uso en su alcance. Entonces podemos decir que se inicializan solo una vez y existen hasta la terminación del programa. Por lo tanto, no se asigna memoria nueva porque no se vuelven a declarar. Su alcance es local a la función para la que fueron definidos. Se puede acceder a las variables estáticas globales desde cualquier parte del programa. Por defecto, el compilador les asigna el valor 0.

#include <iostream>
using namespace std;
 
// Function containing static variables
// memory is retained during execution
int staticFun()
{
    cout << "For static variables: ";
    static int count = 0;
    count++;
    return count;
}
 
// Function containing non-static variables
// memory is destroyed
int nonStaticFun()
{
    cout << "For Non-Static variables: ";
 
    int count = 0;
    count++;
    return count;
}
 
int main()
{
 
    // Calling the static parts
    cout << staticFun() << "\n";
    cout << staticFun() << "\n";
    ;
 
    // Calling the non-static parts
 
    cout << nonStaticFun() << "\n";
    ;
    cout << nonStaticFun() << "\n";
    ;
    return 0;
}

For static variables: 1
For static variables: 2
For Non-Static variables: 1
For Non-Static variables: 1

• registro : esta clase de almacenamiento declara variables de registro que tienen la misma funcionalidad que las variables automáticas. La única diferencia es que el compilador intenta almacenar estas variables en el registro del microprocesador si se dispone de un registro libre. Esto hace que el uso de las variables de registro sea mucho más rápido que el de las variables almacenadas en la memoria durante el tiempo de ejecución del programa. Si no hay un registro libre disponible, estos se almacenan solo en la memoria. Por lo general, algunas variables a las que se accede con mucha frecuencia en un programa se declaran con la palabra clave de registro, lo que mejora el tiempo de ejecución del programa. Un punto importante e interesante a tener en cuenta aquí es que no podemos obtener la dirección de una variable de registro usando punteros.

Ejemplo: 

#include <iostream>
using namespace std;
 
void registerStorageClass()
{
 
    cout << "Demonstrating register class\n";
 
    // declaring a register variable
    register char b = 'G';
 
    // printing the register variable 'b'
    cout << "Value of the variable 'b'"
         << " declared as register: " << b;
}
int main()
{
 
    // To demonstrate register Storage Class
    registerStorageClass();
    return 0;
}

Demonstrating register class
Value of the variable 'b' declared as register: G

• mutable: a veces existe el requisito de modificar uno o más miembros de datos de la clase/estructura a través de la función const aunque no desee que la función actualice otros miembros de la clase/estructura. Esta tarea se puede realizar fácilmente utilizando la palabra clave mutable. La palabra clave mutable se usa principalmente para permitir que se modifique un miembro de datos particular del objeto const. Cuando declaramos una función como const, este puntero pasado a función se convierte en const. Agregar mutable a una variable permite que un puntero constante cambie los miembros.

Ejemplo: 

#include <iostream>
using std::cout;
 
class Test {
public:
    int x;
 
    // defining mutable variable y
    // now this can be modified
    mutable int y;
 
    Test()
    {
        x = 4;
        y = 10;
    }
};
 
int main()
{
    // t1 is set to constant
    const Test t1;
 
    // trying to change the value
    t1.y = 20;
    cout << t1.y;
 
    // Uncommenting below lines
    // will throw error
    // t1.x = 8;
    // cout << t1.x;
    return 0;
}

20