Externo em C ++
int;
char fn (int itg, char ch);
it = 5;
char fn (int itg, char ch)
char var = 'O';
if (itg == 1 && CH == 'A')
var = 'z';
retornar var;
A primeira linha é uma declaração variável. A segunda linha teria sido uma assinatura de função se nunca tivesse terminado com um ponto e vírgula seguido por um corpo de função. Esta segunda linha que termina com um ponto de vírgula é um protótipo de função. Também é uma declaração de função. A terceira linha atribui valor à variável inteira: esta é uma inicialização da variável, mas ainda pode ser vista como uma definição variável. O restante do código é uma definição de função. Começa com a assinatura da função, seguida pelo corpo da função.
Há uma nuance em C ++ quando diz respeito à declaração e definição. A declaração a seguir é uma declaração variável:
int it = 5;
Uma declaração variável completa como essa, onde a variável é introduzida e depois atribuída um valor, ainda é uma declaração variável. Portanto, uma declaração variável pode estar apenas introduzindo a variável sozinha ou a introdução com a definição.
O código a seguir (copiado de cima) é uma declaração de função:
char fn (int itg, char ch)
char var = 'O';
if (itg == 1 && CH == 'A')
var = 'z';
retornar var;
Uma declaração de função completa como essa, onde sua assinatura apresenta a função e é seguida pelo corpo da função, ainda é uma declaração de função. Portanto, uma declaração de função pode ser apenas o protótipo de função sozinho, ou pode ser a assinatura da função junto com o corpo da função.
Portanto, uma declaração pode ser com ou sem uma definição. Uma definição é como uma sub-festa de uma declaração. Com a variável, atribuir um valor pela primeira vez é realmente inicialização e não é realmente definido. Quando uma variável é declarada pela primeira vez sem inicialização, sua localização na memória já é fornecida, mas está vazia. Ajustar em um valor no local é uma inicialização, que está concluindo a definição.
Tradicionalmente, um aplicativo C ++ simples possui três arquivos. Tem um arquivo principal que pode ser chamado de primeiro arquivo. Tem um segundo arquivo e um arquivo de cabeçalho. O uso do especificador externo pode reduzir o número de arquivos para dois (de três). Este artigo explica o uso do especificador externo com variáveis e funções para evitar o arquivo de cabeçalho. Nota: No vocabulário C ++, esses dois arquivos são chamados de unidades de tradução.
Conteúdo do artigo
- Arquivo de cabeçalho sem externo
- externo sem arquivo de cabeçalho
- Constante e externo
- externo e estático
- Conclusão
Arquivo de cabeçalho sem externo
Tradicionalmente, um aplicativo C ++ simples possui três arquivos: o arquivo principal com a função principal () que pode ser chamada de primeiro arquivo, um segundo arquivo e um arquivo de cabeçalho. O arquivo de cabeçalho deve ter as declarações de variáveis e funções sem suas definições. As definições das declarações do cabeçalho devem estar no segundo arquivo. No topo do primeiro arquivo, tem que haver,
#include "cabeça.hh "
Onde cabeça.HH é o nome do arquivo de cabeçalho e reside no diretório de usuário para casa. A diretiva inclui não termina com um ponto e vírgula. Nesta situação, as declarações variáveis sem definições e os protótipos de função sem definições de função no arquivo de cabeçalho não devem ser precedidos pelo especificador externo. E o aplicativo deve funcionar.
Ilustração
A variável e função acima são usadas para ilustração aqui.
Digite o seguinte código em um editor de texto e salve-o no diretório de usuário, com o nome, cabeça.HH:
int it = 5;
char fn (int itg, char ch);
Existem apenas duas declarações no cabeçalho. Em seguida, digite o seguinte em um documento sem título do editor de texto e salve no diretório do usuário, com o nome, segundo.CPP:
char fn (int itg, char ch)
char var = 'O';
if (itg == 1 && CH == 'A')
var = 'z';
retornar var;
E, em seguida, digite o seguinte código em outro documento sem título do editor de texto e salve-o no diretório-usuário, com o nome, primeiro.CPP:
#include "cabeça.hh "
#incluir
usando namespace std;
int main ()
cout << it << endl;
cout << fn(1, 'a') << endl;
retornar 0;
Compilar o aplicativo com o seguinte comando terminal:
G ++ primeiro.CPP Segundo.CPP -O completo.exe
Executar o aplicativo com,
./completo.exe
A saída é:
5
z
Infelizmente, o arquivo de cabeçalho não permite uma declaração simples de uma variável (e.g., ) sem inicialização. No entanto, esse problema pode ser resolvido como mostrado abaixo.
externo sem arquivo de cabeçalho
O arquivo de cabeçalho pode ser eliminado se o especificador externo for usado adequadamente. Haverá uma declaração para a variável e função nessa situação, cada uma sem definição no primeiro (principal) arquivo. Cada um será precedido por um externo.
Ilustração
Digite o seguinte código em um editor de texto e salve-o no diretório de usuário, com o nome, primeiro.CPP:
#incluir
usando namespace std;
extern int it;
extern char fn (int itg, char ch);
int main ()
cout << it << endl;
cout << fn(1, 'a') << endl;
retornar 0;
Em seguida, digite o seguinte em um documento sem título do editor de texto e salve no diretório do usuário com o nome, segundo.CPP:
int it = 5;
char fn (int itg, char ch)
char var = 'O';
if (itg == 1 && CH == 'A')
var = 'z';
retornar var;
A definição da variável e da função ocorreu no segundo arquivo. No primeiro arquivo aqui, eles foram declarados sem definição. Nenhum cabeçalho foi incluído neste novo aplicativo. Apenas dois arquivos estão envolvidos. Observe que a variável foi declarada completamente no segundo arquivo, mas sem a palavra extern. Até a função também foi declarada completamente sem a palavra externa. No entanto, a palavra "extern", deve preceder as declarações parciais no primeiro arquivo.
Compilar o aplicativo com o seguinte comando terminal:
G ++ primeiro.CPP Segundo.CPP -O completo.exe
Execute o aplicativo com,
./completo.exe
A saída é:
5
z
O mesmo de antes, mas sem nenhum arquivo de cabeçalho.
Portanto, o especificador externo vincula as declarações entre dois arquivos. Um arquivo deve fazer declaração sem definição e com externo. O outro arquivo deve fazer uma definição, que seria uma declaração completa, mas sem um externo.
Arquivo de cabeçalho e externo
O aplicativo acima teve o problema de que a variável precisava ser declarada completamente no arquivo de cabeçalho. Para ter a declaração de uma variável em um arquivo de cabeçalho sem a definição, a variável deve ser precedida por um externo. Então, se houver,
extern int it;
No arquivo de cabeçalho, haveria
int it = 5;
no segundo arquivo, e ainda haveria
#include "cabeça.hh "
Na parte superior do primeiro arquivo (arquivo principal).
Constante e externo
Em circunstâncias normais, uma constante deve ser inicializada. Por exemplo,
const char ch = 'e';
é permitido e
const char ch;
Não é permitido.
No entanto, com o especificador externo, uma constante pode ser declarada sem inicialização no primeiro e segundo arquivos. Então, se no primeiro arquivo, existe
extern const char ch;
No segundo arquivo, haverá
char ch = 'e';
Sem const no segundo arquivo. CH em ambos os arquivos é a mesma entidade.
Substitua o primeiro.Arquivo CPP com o seguinte conteúdo e salvar:
#incluir
usando namespace std;
extern const char ch;
int main ()
cout << ch << endl;
retornar 0;
Substitua o segundo.Arquivo CPP com o seguinte conteúdo e salvar:
char ch = 'e';
Compilar o aplicativo com o seguinte comando terminal:
G ++ primeiro.CPP Segundo.CPP -O completo.exe
Execute o aplicativo com,
./completo.exe
A saída deve ser, e.
externo e estático
Os especificadores da classe de armazenamento em C ++ são estáticos, Thread_local, extern, mutável. Não mais que um deles pode ser usado em uma determinada declaração. No entanto, em alguns casos, Thread_local e estático podem aparecer na frente de uma declaração de entidade, ou Thread_local e Extern podem aparecer na frente de uma declaração de entidade. Portanto, externo e estático nunca podem estar presentes como especificadores para uma declaração.
Conclusão
O especificador externo vincula duas declarações da mesma entidade, que estão em dois arquivos diferentes. A declaração com o especificador externo não deve ser inicializado ou definido. A declaração no outro arquivo que não possui o especificador externo deve ser inicializado ou definido. Este esquema se aplica a variáveis e funções. Elimina a necessidade de um arquivo de cabeçalho para as variáveis e funções de interesse. Ele permite que uma constante seja declarada sem inicialização em um arquivo e em outro arquivo. Se o programador quiser um arquivo de cabeçalho, para ter uma variável no arquivo de cabeçalho, sem inicialização, o programador deve usar externo para a variável no arquivo de cabeçalho.