Esterno in C ++
int esso;
char fn (int itg, char ch);
It = 5;
char fn (int itg, char ch)
char var = 'o';
if (itg == 1 && ch == 'a')
var = 'z';
restituire var;
La prima riga è una dichiarazione variabile. La seconda riga sarebbe stata una firma della funzione se non si fosse mai concluso con un punto e virgola seguito da una funzione corpo. Questa seconda riga che termina con un punto e virgola è un prototipo di funzione. È anche una dichiarazione di funzione. La terza riga assegna il valore alla variabile intera: questa è un'inizializzazione variabile ma può comunque essere vista approssimativamente come una definizione variabile. Il resto del codice è una definizione di funzione. Inizia con la firma della funzione, seguita dal corpo della funzione.
C'è una sfumatura in C ++ quando riguarda la dichiarazione e la definizione. La seguente dichiarazione è una dichiarazione variabile:
int it = 5;
Una dichiarazione variabile completa come questa, in cui viene introdotta la variabile e quindi assegnata un valore, è ancora una dichiarazione variabile. Quindi, una dichiarazione variabile può semplicemente introdurre la variabile da sola o l'introduzione con la definizione.
Il seguente codice (copiato dall'alto) è una dichiarazione di funzione:
char fn (int itg, char ch)
char var = 'o';
if (itg == 1 && ch == 'a')
var = 'z';
restituire var;
Una dichiarazione completa della funzione come questa, in cui la sua firma introduce la funzione e viene quindi seguita dal corpo della funzione, è ancora una dichiarazione di funzione. Quindi, una dichiarazione di funzione può essere solo il prototipo di funzione da solo, oppure può essere la firma della funzione insieme al corpo della funzione.
Quindi, una dichiarazione può essere con o senza una definizione. Una definizione è come una parte secondaria di una dichiarazione. Con la variabile, l'assegnazione di un valore per la prima volta è effettivamente inizializzazione e non veramente definita. Quando una variabile viene dichiarata per la prima volta senza inizializzazione, la sua posizione in memoria è già fornita, ma è vuota. Il montaggio in un valore nella posizione è un'inizializzazione, che sta completando la definizione.
Tradizionalmente, una semplice applicazione C ++ ha tre file. Ha un file principale che può essere chiamato il primo file. Ha un secondo file e un file di intestazione. L'uso dello specificatore esterno può ridurre il numero di file a due (da tre). Questo articolo spiega l'uso dello specificatore esterno con variabili e funzioni per evitare il file di intestazione. Nota: nel vocabolario C ++, tali due file sono chiamati unità di traduzione.
Contenuto dell'articolo
- File di intestazione senza esterno
- esterno senza file di intestazione
- Costante ed esterno
- esterno e statico
- Conclusione
File di intestazione senza esterno
Tradizionalmente, una semplice applicazione C ++ ha tre file: il file principale con la funzione principale () che può essere chiamato il primo file, un secondo file e un file di intestazione. Il file di intestazione dovrebbe avere le dichiarazioni di variabili e funzioni senza le loro definizioni. Le definizioni delle dichiarazioni di intestazione dovrebbero essere nel secondo file. Nella parte superiore del primo file, ci deve essere,
#include "testa.HH "
Dove testa.HH è il nome del file di intestazione e risiede nella directory della casa utente. La direttiva Include non finisce con un punto e virgola. In questa situazione, le dichiarazioni variabili senza definizioni e i prototipi di funzione senza definizioni di funzione nel file di intestazione, non devono essere precedute dallo specificatore esterno. E l'applicazione dovrebbe funzionare.
Illustrazione
La variabile e la funzione sopra sono utilizzate per illustrazione qui.
Digita il seguente codice in un editor di testo e salvalo nella directory della casa utente, con il nome, testa.HH:
int it = 5;
char fn (int itg, char ch);
Ci sono solo due affermazioni nell'intestazione. Digitare successivo quanto segue in un documento senza titolo dell'editor di testo e salva nella directory utente-casa, con il nome, secondo.CPP:
char fn (int itg, char ch)
char var = 'o';
if (itg == 1 && ch == 'a')
var = 'z';
restituire var;
E poi, digita il seguente codice in un altro documento senza titolo dell'editor di testo e salvalo nella directory della casa utente, con il nome, prima.CPP:
#include "testa.HH "
#includere
Utilizzo dello spazio dei nomi std;
int main ()
cout << it << endl;
cout << fn(1, 'a') << endl;
restituzione 0;
Compilare l'applicazione con il seguente comando terminale:
G ++ prima.CPP secondo.CPP -O completo.exe
Eseguire l'applicazione con,
./completare.exe
L'output è:
5
z
Sfortunatamente, il file di intestazione non consente una semplice dichiarazione di una variabile (E.G., It) senza inizializzazione. Tuttavia, questo problema può essere risolto come mostrato di seguito.
esterno senza file di intestazione
Il file di intestazione può essere eliminato se lo specificatore esterno viene utilizzato in modo appropriato. Ci sarà una dichiarazione per la variabile e la funzione in questa situazione, ognuna senza definizione nel primo file (principale). Ognuno sarà preceduto da un esterno.
Illustrazione
Digita il seguente codice in un editor di testo e salvalo nella directory della casa utente, con il nome, prima.CPP:
#includere
Utilizzo dello spazio dei nomi std;
esterno int it;
esterno char fn (int itg, char ch);
int main ()
cout << it << endl;
cout << fn(1, 'a') << endl;
restituzione 0;
Successivamente, digita quanto segue in un documento senza titolo dell'editor di testo e salva nella directory utente-casa con il nome, secondo.CPP:
int it = 5;
char fn (int itg, char ch)
char var = 'o';
if (itg == 1 && ch == 'a')
var = 'z';
restituire var;
La definizione della variabile e della funzione ha avuto luogo nel secondo file. Nel primo file qui, sono stati dichiarati senza definizione. Nessuna intestazione è stata inclusa in questa nuova applicazione. Sono coinvolti solo due file. Si noti che la variabile è stata dichiarata completamente nel secondo file ma senza la parola esterna. Anche anche la funzione è stata dichiarata completamente senza la parola esterna. Tuttavia, la parola "esterno", deve precedere le dichiarazioni parziali nel primo file.
Compilare l'applicazione con il seguente comando terminale:
G ++ prima.CPP secondo.CPP -O completo.exe
Eseguire l'applicazione con,
./completare.exe
L'output è:
5
z
Come prima, ma senza alcun file di intestazione.
Quindi, il specificatore esterno collega le dichiarazioni tra due file. Un file dovrebbe fare una dichiarazione senza definizione e con esterno. L'altro file dovrebbe fare una definizione, che sarebbe una dichiarazione completa, ma senza un esterno.
File di intestazione ed esterno
L'applicazione di cui sopra aveva il problema che la variabile doveva essere dichiarata completamente nel file di intestazione. Per avere la dichiarazione di una variabile in un file di intestazione senza la definizione, la variabile deve essere preceduta da un esterno. Quindi, se c'è,
esterno int it;
Nel file di intestazione, ci sarebbe
int it = 5;
nel secondo file, e ci sarebbe ancora
#include "testa.HH "
Nella parte superiore del primo file (file principale).
Costante ed esterno
In circostanze normali, una costante deve essere inizializzata. Per esempio,
const char ch = 'e';
è consentito e
const char ch;
Non è permesso.
Tuttavia, con lo specificatore esterno, una costante può essere dichiarata senza inizializzazione nel primo e nel secondo file. Quindi, se nel primo file, c'è
esterno const char ch;
Nel secondo file, ci sarà
char ch = 'e';
Senza const nel secondo file. CH in entrambi i file è la stessa entità.
Sostituire il primo.file CPP con i seguenti contenuti e salva:
#includere
Utilizzo dello spazio dei nomi std;
esterno const char ch;
int main ()
cout << ch << endl;
restituzione 0;
Sostituire il secondo.file CPP con i seguenti contenuti e salva:
char ch = 'e';
Compilare l'applicazione con il seguente comando terminale:
G ++ prima.CPP secondo.CPP -O completo.exe
Eseguire l'applicazione con,
./completare.exe
L'output dovrebbe essere, E.
esterno e statico
Gli specificatori di classe di archiviazione in C ++ sono statici, thread_local, esterni, mutabili. Non più di uno di questi può essere usato in una data dichiarazione. Tuttavia, in alcuni casi, thread_local e statico può apparire di fronte a una dichiarazione di entità, o thread_local ed esterno può apparire di fronte a una dichiarazione di entità. Quindi, esterno e statico non possono mai essere presenti come specificatori per una dichiarazione.
Conclusione
Lo specificatore esterno collega due dichiarazioni della stessa entità, che si trovano in due file diversi. La dichiarazione che ha lo specificatore esterno non deve essere inizializzata o definita. La dichiarazione nell'altro file che non ha lo specificatore esterno deve essere inizializzata o definita. Questo schema si applica alle variabili e alle funzioni. Elimina la necessità di un file di intestazione per le variabili e le funzioni di interesse. Consente di dichiarare una costante senza inizializzazione in un file e nell'altro file. Se il programmatore desidera un file di intestazione, per avere una variabile nel file di intestazione, senza inizializzazione, il programmatore deve utilizzare esterno per la variabile nel file di intestazione.