C ++ Pragma uma vez

Hoje, aprendemos uma das diretivas da linguagem C ++ usada para especificar a compilação do arquivo de cabeçalho incluído uma vez. Mas antes de pular diretamente no tópico principal, vamos primeiro dar uma rápida olhada no básico da linguagem de programação C ++. Também aprenderemos o uso de arquivos de cabeçalho no programa C ++.

A linguagem C ++, às vezes conhecida como "C com classes", é uma linguagem de programação de uso geral que é uma extensão da linguagem do computador C. A linguagem C ++ se desenvolveu bastante ao longo do tempo. O C ++ atual contém recursos para gerenciamento de memória de baixo nível, juntamente com recursos orientados a objetos, generalizados e funcionais. Usamos as bibliotecas de cabeçalho na programação C ++ para evitar ter que criar o código para cada coisinha. As complexidades e o número de linhas de código são reduzidas. Além disso, permite que você reutilize os métodos definidos nos arquivos de cabeçalho para vários fins.

A diretiva de idioma C ++ lida com #Pragma uma vez que é usada para minimizar os erros de programação. Embora seja apoiado pela maioria dos tradutores proeminentes de C ou C ++, incluindo tradutores GCC e CLANG, não é um componente do padrão C ++. Se o tradutor não for fornecido, isso pode causar uma preocupação com a acessibilidade com base no seu programa. Ao usar o #Pragma uma vez, há um cenário excepcional em que existem muitos arquivos de cabeçalho com um nome de arquivo semelhante.

Vantagens do #pragma uma vez

Vamos discutir algumas das características importantes da diretiva pré -processadora C ++, que é a “#Pragma uma vez”:

• Como sabemos, o Pragma uma vez compila apenas uma vez no programa existente para que a implementação ou código do programa seja menos.
• Como sabemos que o processo de compilação de Pragma é uma vez, temos uma evitação de traços de nome.
• Em outros programas, quando compilamos o programa, leva muito tempo porque o compilador compila todos os arquivos do programa. Mas quando usamos o Pragma uma vez no programa, o código do programa é menos. É por isso que a velocidade de compilação do programa é rápida.

Implementação

Na programação C e C ++, às vezes encontramos uma das diretivas pré -processador que é “#Pragma uma vez”. Como o nome sugere, "uma vez" significa que permite ou faz com que um arquivo de origem atual seja incluído no programa existente apenas uma vez por vez, apenas em uma única compilação. Antes da diretiva pré -processadora "#Pragma ONE", há outra diretiva pré -processadora que usamos para superar esse problema que é "#include guardas" na linguagem de programação C ++. Mas Pragma uma vez permite apenas a compilação para um porque um programa que possui programa automático pode conter vários arquivos.

O arquivo C ++ pode incluir vários arquivos de cabeçalho. Isso significa que o primeiro arquivo C ++ e o segundo arquivo C ++ contêm arquivos de cabeçalho semelhantes. O compilador compila o primeiro arquivo de cabeçalho e depois o segundo arquivo de cabeçalho. Isso ocorre porque os dois arquivos de cabeçalho são compilados duas vezes. Usamos a diretiva Pragma quando o pré -processador, para que os arquivos de cabeçalho sejam compilados uma vez no programa existente.

Sintaxe:

Aqui está o estilo de escrita e a implementação da diretiva pré -processadora "#Pragma ONE" na linguagem de programação C ++. O pré -processador procura ao programa comandos específicos que ele pode compreender, chamando -os de instruções de pré -processador. O sinal # (hash) é usado no início de todas as diretivas pré -processador. Primeiro, antes que o tradutor encontre o programa, o pré -processador realiza atividades preparatórias, como executar implicitamente o código, incluindo os arquivos relacionados ao programa, etc.

Em seguida, escrevemos a palavra -chave "Pragma", que significa "informações pragmáticas". A diretiva Pragma está incluída nos padrões C ++, mas a interpretação de cada diretiva Pragma depende do programa que é usado para executar a biblioteca padrão. Uma técnica para pedir ao tradutor um comportamento exclusivo é com a diretiva #Pragma. Este comando é especialmente útil para programas que precisam usar determinados recursos de código compilados ou que são excepcionalmente grandes. E então, no final, escrevemos o comportamento do programa que queremos implementar no programa C ++ existente que é “uma vez”. Isso significa que, quando há muitos arquivos de cabeçalho com um nome de arquivo semelhante, isso compila o arquivo de cabeçalho apenas uma vez.

Exemplos:

Vamos dar um exemplo da diretiva pré -processadora “#Pragma uma vez” e entenderemos como essa diretiva funciona na linguagem C ++, para que a mente e a confusão do usuário sejam limpas sobre as duas diretivas do Pragma da linguagem C ++:

Externo.h

Para começar a escrever o programa, sempre precisamos de um compilador onde escrevemos e executamos o programa existente. Instale qualquer compilador C ++. Mais uma coisa é que a diretiva Pragma não é executada no compilador online. Este exemplo é implementado no compilador "Dev C ++". Depois de abrir o compilador, primeiro criamos o “externo.Arquivo H ”onde implementamos a diretiva Pragma.

externo.H:
#pragma uma vez
#ifndef external_h
#Define extern_h
#incluir
usando namespace std;
jogador de classe

público:
velocidade int;
Jogador()

velocidade = 10;

~ Player ()


;
impressão vazio ()

cout<< "Test" <
bool tocando = falso;
#fim se

Primeiro, declaramos a diretiva pré -processadora "#pragma uma vez" que diz ao compilador para incluir apenas o código no arquivo c ++ uma vez. Isso é útil se você tiver um arquivo de cabeçalho incluído em vários arquivos C ++. Em seguida, adicionamos o #include, que é um cabeçalho padrão incluído em todos os programas C ++. Na terceira linha do código é um #ifndef external_h. Esta é uma diretiva do compilador que é usada para criar um arquivo de cabeçalho externo. Então, implementamos o #Define extern_H novamente.

Depois disso, declaramos o nome da classe pública "Player", que diz ao compilador que a classe do jogador é pública. Em seguida, declaramos a variável do tipo inteiro "velocidade" e inicializamos o valor. Na próxima linha, criamos um construtor de jogador (). Agora, criamos a função de print () e passamos o método cout (). Declaramos uma variável do tipo bool tocando e inicializamos o valor falso. Esta é uma declaração de variável de membro para a variável de membro do jogo. No final, usamos o #endif porque é uma diretiva do compilador que é usada para encerrar a instrução #ifndef.

Principal.Arquivo CPP

Primeiro, incluímos o arquivo que já criamos - externo.arquivo h. Em seguida, incluímos o "#include" que é usado para obter os dados do usuário e exibir os dados para o usuário. Em seguida, criamos o objeto de jogador do tipo Player que já definimos no externo.arquivo h. Em seguida, chamamos o jogador e o concatamos com a variável de velocidade que inicializamos no arquivo externo e o imprimimos usando o método cout (). Usamos a estatura IF para verificar se o jogador está jogando. Se for verdade, exibe o jogador. Se for falso, não exibe nada. No final, retornamos 0 à função Main () para que possamos interromper a execução do programa.

principal.CPP:
#include "externo.h "
#incluir
usando namespace std;
int main ()

Jogador jogador;
cout<< "The speed of the player is: " <se (tocando)

Imprimir();

retornar 0;

Conclusão

Neste artigo, aprendemos sobre um dos pré -processadores importantes do C ++, que é “#Pragma uma vez”. Aprendemos por que usamos Pragma uma vez e também discutimos seus benefícios. Implementamos o exemplo de Pragma uma vez com uma explicação detalhada da Diretiva Pragma, uma vez que nenhum ponto de confusão é deixado para o usuário.