C ++ Pragma una volta
Il linguaggio C ++, a volte noto come "C con le classi", è un linguaggio di programmazione per uso generale che è un'estensione del linguaggio del computer C. Il linguaggio C ++ si è sviluppato molto nel tempo. L'attuale C ++ contiene capacità per la gestione della memoria di basso livello insieme a caratteristiche orientate agli oggetti, generalizzati e funzionali. Usiamo le librerie di intestazione nella programmazione C ++ per evitare di dover creare il codice per ogni piccola cosa. Le complessità e il numero di righe di codice sono entrambe ridotte. Inoltre, ti consente di riutilizzare i metodi definiti nei file di intestazione per vari scopi.
La direttiva del linguaggio C ++ gestisce #Pragma una volta che viene utilizzata per ridurre al minimo gli errori di programmazione. Sebbene sia supportato dalla maggior parte dei principali traduttori C o C ++ inclusi i traduttori GCC e Clang, non è un componente dello standard C ++. Se il traduttore non viene fornito, ciò potrebbe causare preoccupazione per l'accessibilità in base al programma. Quando si utilizza #pragma una volta, esiste uno scenario eccezionale in cui ci sono molti file di intestazione con un nome file simile.
Vantaggi di #pragma una volta
Discutiamo alcune delle caratteristiche importanti della direttiva preprocessore C ++ che è la "#pragma una volta":
- Come sappiamo, il pragma una volta si compila solo una volta nel programma esistente in modo che l'implementazione o il codice del programma sia inferiore.
- Dal momento che sappiamo che il processo di compilation di Pragma è una volta, abbiamo un evitamento dei trattini del nome.
- In altri programmi, quando compiliamo il programma, ci vuole molto tempo perché il compilatore compila ogni file del programma. Ma quando usiamo il pragma una volta nel programma, il codice del programma è inferiore. Ecco perché la velocità di compilazione del programma è veloce.
Implementazione
Nella programmazione C e C ++, a volte ci imbattiamo in una delle direttive preprocessore che è "#pragma una volta". Come suggerisce il nome, "una volta" significa che consente o fa incluso un file di origine corrente nel programma esistente solo una volta alla volta, solo in una singola compilation. Prima della direttiva preprocessore "#pragma una volta", esiste un'altra direttiva preprocessore che abbiamo usato per superare questo problema che è "#include Guards" nel linguaggio di programmazione C ++. Ma Pragma una volta consente la compilazione solo per uno perché un programma che ha un programma automatico può contenere diversi file in esso.
Il file C ++ può includere diversi file di intestazione. Ciò significa che il primo file C ++ e il secondo file C ++ contengono file di intestazione simili. Il compilatore compila il primo file di intestazione e quindi il secondo file di intestazione. Questo perché entrambi i file di intestazione vengono compilati due volte. Usiamo la direttiva preprocessore Pragma una volta che i file di intestazione si compili una volta nel programma esistente.
Sintassi:
Ecco lo stile di scrittura e l'implementazione della direttiva preprocessore "#pragma una volta" nel linguaggio di programmazione C ++. Il preprocessore cerca il programma per comandi specifici che può comprendere chiamandoli istruzioni preprocessore. Il segno # (hash) viene utilizzato all'inizio di ogni direttiva preprocessore. In primo luogo, prima ancora che il traduttore incontri il programma, il preprocessore svolge attività preparatorie come l'esecuzione implicitamente del codice, inclusi i file relativi al programma, ecc.
Successivamente, scriviamo la parola chiave "pragma" che significa "informazioni pragmatiche". La direttiva Pragma è inclusa negli standard C ++, ma l'interpretazione di ogni direttiva Pragma dipende dal programma che viene utilizzato per eseguire la libreria standard. Una tecnica per chiedere al traduttore un comportamento unico è con la direttiva #pragma. Questo comando è particolarmente utile per i programmi che devono utilizzare alcune funzionalità del codice compilato o che sono eccezionalmente grandi. E poi, alla fine, scriviamo il comportamento del programma che vogliamo implementare sul programma C ++ esistente che è "una volta". Ciò significa che quando ci sono molti file di intestazione con un nome file simile, compila il file di intestazione solo una volta.
Esempi:
Facciamo un esempio della direttiva preprocessore "#pragma una volta" e capiremo come questa direttiva funziona in linguaggio C ++ in modo che la mente e la confusione dell'utente vengano cancellate su entrambe le direttive Pragma del linguaggio C ++:
Esterno.H
Per iniziare a scrivere il programma, abbiamo sempre bisogno di un compilatore in cui scriviamo ed eseguiamo il programma esistente. Installa qualsiasi compilatore C ++. Un'altra cosa è che la direttiva Pragma non viene eseguita sul compilatore online. Questo esempio è implementato sul compilatore "Dev C ++". Dopo aver aperto il compilatore, creiamo prima il "esterno.file h "in cui implementiamo la direttiva Pragma.
esterno.H:#pragma una volta
#ifndef esterno_h
#define esterno_h
#includere
Utilizzo dello spazio dei nomi std;
Giocatore di classe
pubblico:
INT Speed;
Giocatore()
velocità = 10;
~ Giocatore ()
;
void print ()
cout<< "Test" <
bool che gioca = false;
#finisci se
Innanzitutto, dichiariamo la direttiva preprocessore "#pragma una volta" che dice al compilatore di includere il codice solo nel file C ++ una volta. Questo è utile se si dispone di un file di intestazione incluso in più file C ++. Quindi, aggiungiamo #Include che è un'intestazione standard che è inclusa in tutti i programmi C ++. Nella terza riga del codice è un #ifndef esterno_h. Questa è una direttiva del compilatore che viene utilizzata per creare un file di intestazione esterno. Quindi, implementiamo di nuovo #define esterno_h.
Successivamente, dichiariamo il nome della classe pubblica "giocatore" che dice al compilatore che la classe dei giocatori è pubblica. Quindi, dichiariamo la variabile tipo "velocità" del tipo intero e inizializziamo il valore ad esso. Nella riga successiva, creiamo un costruttore di giocatore (). Ora creiamo la funzione di print () e passiamo il metodo cout () in esso. Dichiariamo una variabile di tipo bool e inizializziamo il falso valore ad esso. Questa è una dichiarazione variabile membro per la variabile del membro della riproduzione. Alla fine, utilizziamo #endif perché è una direttiva del compilatore che viene utilizzata per terminare l'istruzione #ifndef.
Principale.File CPP
Innanzitutto, includiamo il file che abbiamo già creato - esterno.file h. Quindi, includiamo il "#include" utilizzato per ottenere i dati dall'utente e visualizzare i dati all'utente. Quindi, creiamo l'oggetto giocatore di tipo giocatore che abbiamo già definito nell'esterno.file h. Quindi, chiamiamo il giocatore e lo contaghiamo con la variabile di velocità che abbiamo inizializzato nel file esterno e lo stampiamo usando il metodo Cout (). Usiamo l'If-Statement in modo da verificare se il giocatore sta giocando. Se è vero, mostra il giocatore. Se è falso, non mostra nulla. Alla fine, torniamo 0 alla funzione principale () in modo da poter fermare l'esecuzione del programma.
principale.CPP:#include "esterno.H"
#includere
Utilizzo dello spazio dei nomi std;
int main ()
Giocatore giocatore;
cout<< "The speed of the player is: " <
Stampa();
restituzione 0;
Conclusione
In questo articolo, abbiamo appreso uno dei preprocessori importanti di C ++ che è "#pragma una volta". Abbiamo imparato perché usiamo Pragma una volta e abbiamo anche discusso dei suoi benefici. Abbiamo implementato l'esempio di Pragma una volta con una spiegazione dettagliata di Pragma una volta direttiva in modo che non venga lasciato nessun punto di confusione per l'utente.