Calificadores de C ++ y especificadores de clase de almacenamiento

CV significa Volátil constante. La declaración de un objeto que no está precedido por const y/o volátil es un tipo cv-no calificado. Por otro lado, la declaración de un objeto precedido por const y/o volátil es un tipo calificado por CV. Si un objeto se declara const, el valor en su ubicación no se puede cambiar. Una variable volátil es una variable cuyo valor está bajo la influencia del programador y, por lo tanto, el compilador no puede cambiar por.Los especificadores de clase de almacenamiento se refieren a la vida, el lugar y la forma en que existe un tipo. Los especificadores de clase de almacenamiento son estáticos, mutables, hilt_local y extern.

Este artículo explica los calificadores de C ++ y los especificadores de clase de almacenamiento. Por lo tanto, algún conocimiento preliminar en C ++ es útil para apreciar realmente el artículo.

Contenido del artículo:

• Calificadores
• Especificadores de clase de almacenamiento
• Conclusión

Calificadores:

estúpido

Un objeto declarado constante es un objeto el almacenamiento (ubicación) de cuyo valor no se puede cambiar. Por ejemplo, en la declaración:

int const Theint = 5;

El valor de 5 en el almacenamiento para elint no se puede cambiar.

volátil

Considere la siguiente declaración:

int portval = 26904873;

Los compiladores a veces interfieren con el valor de una variable con la esperanza de optimizar el programa. El compilador puede mantener el valor de una variable como constante cuando se supone que no es constante. El compilador puede interferir los valores de objetos que tienen que ver con los puertos IO mapeados de memoria, o las rutinas de servicio de interrupción de los dispositivos periféricos. Para evitar tal interferencia, haga que la variable sea volátil, como:

int volátil portval;
Portval = 26904873;
O como:
int volátil portval = 26904873;

Combinando const y volátiles:

const y volátiles pueden ocurrir en una declaración de la siguiente manera:

int const volátiles portval = 26904873;

calificadores CV

Una variable precedida con const y/o volátil es un tipo calificado por CV. Una variable no precedida con const o volátil o ambas veces es un tipo CV no calificado.

Ordenar:

Un tipo puede estar más calificado por CV que otro:

• Ningún calificador CV es menor que un calificador de constante
• Ningún calificador de CV también es menor que un calificador volátil
• Ningún calificador CV es menor que un calificador constante
• El calificador constante es menos que un calificador constante
• El calificador volátil es menos que un calificador constante

Todavía no se ha concluido si const y volátiles son del mismo rango.

Matriz y objeto instanciado:

Cuando una matriz se declara constante, como en la siguiente declaración, significa que el valor de cada elemento de la matriz no se puede cambiar:

const char arr [] = 'a', 'b', 'c', 'd';

Ya sea un 'a', 'b', 'c' o 'd', todavía no se puede cambiar a algún otro valor (carácter).

Una situación similar se aplica a un objeto instanciado de una clase. Considere el siguiente programa:

#incluir
usando el espacio de nombres STD;
Clase CLA

público:
char ch0 = 'a';
char ch1 = 'b';
char ch2 = 'c';
char ch3 = 'd';
;
int main ()

const cla obj;
regresar 0;

Debido a la declaración "const cla obj;" con const en la función main (), ni 'a' ni 'b' ni 'c' ni 'd' se pueden cambiar a algún otro valor.

Especificadores de clase de almacenamiento:

Los especificadores de clase de almacenamiento son estáticos, mutables, hilt_local y extern.

El Especificador de clase de almacenamiento estático

El especificador de clase de almacenamiento estático permite que la variable viva después de que su alcance haya pasado, pero no se puede acceder directamente a la que se puede acceder.

El siguiente programa ilustra esto, con una función recursiva:

#incluir
usando el espacio de nombres STD;
int Funct ()

static int stac = 10;
cout << stac < 50)

cout << '\n';
regresar 0;

funct ();

int main ()

funct ();
regresar 0;

La salida es:

10 20 30 40 50

Si una variable estática no se inicializa en su primera declaración, supone el valor predeterminado para su tipo.

El especificador estático también se puede usar con miembros de una clase; El uso aquí es diferente. Aquí, permite que se acceda al miembro sin instanciación para el objeto.

El siguiente programa ilustra esto para un miembro de datos:

#incluir
usando el espacio de nombres STD;
Clase CLA

público:
estatic const int num = 8;
;
int main ()

cout << Cla::num << '\n';
regresar 0;

La salida es:

8

El miembro de datos estáticos debe ser constante. Tenga en cuenta que el uso del operador de resolución de alcance para acceder a la variable estática fuera de su alcance (en la función principal).

El siguiente programa ilustra el uso de "estática" para una función miembro:

#incluir
usando el espacio de nombres STD;
Clase CLA

público:
Método vacío estático ()

cout << "Of static member function!" << '\n';

;
int main ()

Cla :: Method ();
regresar 0;

La salida es:

De la función de miembro estático!

Tenga en cuenta que el uso del operador de resolución de alcance para acceder a la función de miembro estático fuera de su alcance (en la función principal).

El especificador mutable

Recuerde, desde arriba, que si un objeto instanciado comienza con const, el valor de cualquiera de sus miembros de datos normales no se puede cambiar. Y para que cualquier miembro de datos se cambie, debe declararse, mutable.

El siguiente programa ilustra esto:

#incluir
usando el espacio de nombres STD;
Clase CLA

público:
char ch0 = 'a';
char ch1 = 'b';
char ch2 = 'c';
char ch3 = 'd';
;
int main ()

const cla obj;
obj.ch2 = 'z';
cout << obj.ch0 << " << obj.ch1 << " << obj.ch2 << " << obj.ch3 << " << '\n';
regresar 0;

La salida es:

'A "B" Z "D'

El especificador thread_local

En la ejecución normal de un programa, se ejecuta un segmento de código, luego el siguiente segmento de código, seguido de otro segmento de código después de eso, y así sucesivamente. Ese es un hilo; el hilo principal. Si se ejecutan dos segmentos de código al mismo tiempo (la misma duración), entonces se necesita un segundo hilo. El resultado del segundo hilo puede incluso estar listo antes del hilo principal.

La función principal () es como el hilo principal. Un programa puede tener más de dos hilos para un comportamiento tan asíncrono.

El segundo hilo necesita un alcance (alcance de bloque) para operar. Esto suele ser proporcionado por el alcance de la función, una función. Una variable en un alcance externo que se puede ver en el alcance del segundo hilo.

El siguiente programa corto ilustra el uso del especificador Thread_Local:

#incluir
#incluir
usando el espacio de nombres STD;
Thread_local int inter = 1;
Void thread_function ()

inter = inter + 1;
cout << inter << "nd thread\n";

int main ()

Thread Thr (& Thread_Function); // thr comienza a correr
cout << inter << "st or main thread\n";
thr.unirse(); // El hilo principal espera el hilo, THR finaliza
regresar 0;

La salida es:

1er o hilo principal
Segundo hilo

La variable, Inter, precedida por Thread_Local, significa que Inter tiene una instancia separada en cada hilo. Y que se puede modificar en diferentes hilos para tener diferentes valores. En este programa, se le asigna el valor, 1 en el hilo principal, y se modifica al valor, 2 en el segundo hilo.

Un hilo necesita un objeto especial para operar. Para este programa, la biblioteca incluida por "#include" tiene una clase llamada hilo, desde el cual el objeto se ha instanciado. El constructor para este objeto toma una referencia a la función de subproceso como argumento. El nombre de la función de subproceso en este programa es thread_function ().

La función miembro de unión () para el objeto especial, en su posición empleada, hace que el hilo principal espere que el segundo hilo termine de ejecutarse antes de que continúe ejecutándose, de lo contrario, la función main () puede salir sin el hilo (segundo) que tiene Produjo su resultado.

El especificador externo

En términos simples, para una declaración, la memoria no se asigna para la variable o la función, mientras que para una definición, la memoria se asigna. La palabra reservada externa permite declarar una variable o función global en un archivo pero definida en otro. Dichos archivos se denominan unidades de traducción para la aplicación C ++ completa.

Escriba el siguiente programa y guárdelo con el nombre de archivo, MainFile:

#incluir
usando el espacio de nombres STD;
int myint;
const char ch;
nulo myfn ();
int main ()

myfn ();
regresar 0;

La variable, myint, la variable constante, ch y la función, myfn (), se han declarado sin definirse.

Escriba el siguiente programa con las definiciones y guárdelo con el nombre de archivo, otrofile, en el mismo directorio:

#incluir
usando el espacio de nombres STD;
int myint = 10;
const char ch = 'c';
nulo myfn ()

cout << "myFn() says " << myInt << " and " << ch <<'\n';

Intente compilar la aplicación en el terminal (símbolo del sistema DOS) con el siguiente comando y observe que no puede compilar:

G ++ Mainfile.CPP OTROFILE.CPP -O completo.exe

Ahora, precede a las tres declaraciones en el archivo principal con la palabra "extern", como sigue:

extern int myint;
EXTER CONST CHAR CH;
extern void myfn ();

Volver a salvar el archivo principal. Compilar la aplicación con:

G ++ Mainfile.CPP OTROFILE.CPP -O completo.exe

(Así es como se compilan los archivos separados para la misma aplicación en C ++)

Y debería compilar. Ahora, ejecute la solicitud, complete.exe, y la salida debe ser:

myfn () dice 10 y c

Tenga en cuenta que con el uso de "extern", se puede declarar una variable constante en un archivo pero definirse en otro. Al tratar con la declaración de funciones y la definición en diferentes archivos, el uso de extern es opcional.

Cuando usar extern? Úselo cuando no tenga archivos de encabezado con declaraciones globales.

"Extern" también se usa con declaraciones de plantilla; ver más tarde.

Conclusión:

Una variable precedida con const y/o volátil es un tipo calificado por CV. Una variable, no precedida con const o volátil o ambas, es un tipo de CV no calificado.

Los especificadores de clase de almacenamiento son estáticos, mutables, hilt_local y extern. Estos afectan la vida útil (duración), el lugar y la forma de empleo de las variables en una aplicación.