C ++ Pragma una vez
El lenguaje C ++, a veces conocido como "C con clases", es un lenguaje de programación de uso general que es una extensión del lenguaje informático C. El lenguaje C ++ se ha desarrollado enormemente con el tiempo. El C ++ actual contiene capacidades para la gestión de memoria de bajo nivel junto con características orientadas a objetos, generalizadas y funcionales. Usamos las bibliotecas de encabezado en la programación de C ++ para evitar tener que crear el código para cada pequeña cosa. Las complejidades y el número de líneas de código se reducen. Además, le permite reutilizar los métodos definidos en los archivos de encabezado para diversos fines.
La Directiva de lenguaje C ++ maneja #Pragma una vez que se utiliza para minimizar los errores de programación. Aunque es compatible con la mayoría de los traductores prominentes de C o C ++, incluidos los traductores GCC y Clang, no es un componente del estándar C ++. Si no se proporciona el traductor, esto podría causar una preocupación por la accesibilidad basada en su programa. Al usar #Pragma una vez, hay un escenario excepcional en el que hay muchos archivos de encabezado con un nombre de archivo similar.
Ventajas de #Pragma una vez
Discutamos algunas de las características importantes de la Directiva del preprocesador C ++, que es la "#Pragma Once":
- Como sabemos, el Pragma una vez solo se compila una vez en el programa existente para que la implementación o el código del programa sea menor.
- Dado que sabemos que el proceso de compilación de Pragma es una vez, evitamos las guiones de los nombres.
- En otros programas, cuando compilamos el programa, lleva mucho tiempo porque el compilador compila cada archivo del programa. Pero cuando usamos el Pragma una vez en el programa, el código del programa es menos. Es por eso que la velocidad de compilación del programa es rápida.
Implementación
En la programación C y C ++, a veces nos encontramos con una de las directivas preprocesadoras que es "#Pragma Once". Como su nombre indica, "una vez" significa que permite o hace que un archivo fuente actual se incluya en el programa existente solo una vez a la vez, solo en una sola compilación. Antes de la Directiva del preprocesador "#Pragma Once", hay otra directiva preprocesadora que solíamos superar este problema que es "#Clude Guards" en el lenguaje de programación C ++. Pero Pragma una vez solo permite la compilación para uno porque un programa que tiene un programa automático puede contener varios archivos en él.
El archivo C ++ puede incluir varios archivos de encabezado. Esto significa que el primer archivo C ++ y el segundo archivo C ++ contienen archivos de encabezado similares. El compilador compila el primer archivo de encabezado y luego el segundo archivo de encabezado. Esto se debe a que ambos archivos de encabezado se compilan dos veces. Utilizamos la directiva Pragma una vez preprocesador para que los archivos de encabezado se compilarán una vez en el programa existente.
Sintaxis:
Aquí está el estilo de escritura y la implementación de la Directiva del preprocesador "#Pragma Once" en el lenguaje de programación C ++. El preprocesador busca en el programa comandos específicos que puede comprender llamándoles instrucciones del preprocesador. El signo # (hash) se usa al comienzo de cada directiva del preprocesador. Primero, antes de que el traductor incluso encuentre el programa, el preprocesador realiza actividades preparatorias como la ejecución implícita del código, incluidos los archivos relacionados con el programa, etc.
A continuación, escribimos la palabra clave "pragma" que significa "información pragmática". La Directiva Pragma se incluye en los estándares C ++, pero la interpretación de cada Directiva Pragma depende del programa que se utiliza para ejecutar la biblioteca estándar. Una técnica para pedirle al traductor un comportamiento único es con la directiva #pragma. Este comando es especialmente útil para los programas que necesitan utilizar ciertas funciones de código compilado o que son excepcionalmente grandes. Y luego, al final, escribimos el comportamiento del programa que queremos implementar en el programa C ++ existente que es "una vez". Esto significa que cuando hay muchos archivos de encabezado con un nombre de archivo similar, esto compila el archivo de encabezado solo una vez.
Ejemplos:
Tomemos un ejemplo de la Directiva del preprocesador "#Pragma Once" y comprenderemos cómo funciona esta directiva en el lenguaje C ++ para que la mente y la confusión del usuario se despeje sobre las directivas Pragma del lenguaje C ++:
Externo.H
Para comenzar a escribir el programa, siempre necesitamos primero un compilador donde escribamos y ejecutamos el programa existente. Instale cualquier compilador C ++. Una cosa más es que la Directiva Pragma no se ejecuta en el compilador en línea. Este ejemplo se implementa en el compilador "Dev C ++". Después de abrir el compilador, primero creamos el "externo.H ”Archivo donde implementamos la Directiva Pragma.
externo.H:#Pragma una vez
#ifndef externo_h
#define externo_h
#incluir
usando el espacio de nombres STD;
jugador de clase
público:
int velocidad;
Jugador()
velocidad = 10;
~ Jugador ()
;
imprime vacío ()
cout<< "Test" <
bool jugando = falso;
#terminara si
Primero, declaramos la directiva preprocesadora "#Pragma Once" que le dice al compilador que solo incluya el código en el archivo C ++ una vez. Esto es útil si tiene un archivo de encabezado que se incluye en múltiples archivos C ++. Luego, agregamos el #include, que es un encabezado estándar que se incluye en todos los programas de C ++. En la tercera línea del código está un #ifndef externo_h. Esta es una directiva del compilador que se utiliza para crear un archivo de encabezado externo. Luego, implementamos el #define external_h nuevamente.
Después de eso, declaramos el nombre de clase pública "Jugador" que le dice al compilador que la clase de jugadores es pública. Luego, declaramos la variable de tipo entero "velocidad" e inicializamos el valor. En la siguiente línea, creamos un constructor jugador (). Ahora, creamos la función de print () y pasamos el método cout () en él. Declaramos una variable de tipo bool jugando e inicializamos el valor falso para él. Esta es una declaración de variable miembro para la variable de miembro de juego. Al final, usamos el #Endif porque es una directiva de compilador que se utiliza para finalizar la declaración #IFNDEF.
Principal.Archivo CPP
Primero, incluimos el archivo que ya creamos:.hile h. Luego, incluimos el "#include" que se utiliza para obtener los datos del usuario y mostrar los datos al usuario. Luego, creamos el objeto de reproductor de jugador de tipo que ya definimos en el externo.hile h. Luego, llamamos al jugador y lo concatenamos con la variable de velocidad que inicializamos en el archivo externo e imprimimos usando el método Cout (). Usamos el estado if para que verifiquemos si el jugador está jugando. Si es cierto, muestra el jugador. Si es falso, no muestra nada. Al final, devolvemos 0 a la función main () para que podamos detener la ejecución del programa.
principal.CPP:#Include "Exterior.H "
#incluir
usando el espacio de nombres STD;
int main ()
Jugador jugador;
cout<< "The speed of the player is: " <
Imprimir();
regresar 0;
Conclusión
En este artículo, aprendimos sobre uno de los preprocesadores importantes de C ++, que es "#Pragma una vez". Aprendimos por qué usamos Pragma una vez y también discutimos sus beneficios. Implementamos el ejemplo de Pragma una vez con una explicación detallada de Pragma Once Directiva para que no quede ningún punto de confusión para el usuario.