Declarações e definições (C++)

Um programa C++ consiste em várias entidades, como variáveis, funções, tipos e namespaces. Cada uma destas entidades deve ser declarada antes de poder ser utilizada. Uma declaração especifica um nome exclusivo para a entidade, juntamente com informações sobre seu tipo e outras características. Em C++, o ponto em que um nome é declarado é o ponto em que ele se torna visível para o compilador. Você não pode se referir a uma função ou classe que é declarada em algum ponto posterior na unidade de compilação. As variáveis devem ser declaradas o mais próximo possível antes do ponto em que são usadas.

O exemplo a seguir mostra algumas declarações:

#include <string>

int f(int i); // forward declaration

int main()
{
    const double pi = 3.14; //OK
    int i = f(2); //OK. f is forward-declared
    C obj; // error! C not yet declared.
    std::string str; // OK std::string is declared in <string> header
    j = 0; // error! No type specified.
    auto k = 0; // OK. type inferred as int by compiler.
}

int f(int i)
{
    return i + 42;
}

namespace N {
   class C{/*...*/};
}

Na linha 5, a main função é declarada. Na linha 7, uma const variável chamada pi é declarada e inicializada. Na linha 8, um inteiro i é declarado e inicializado com o valor produzido pela função f. O nome f é visível para o compilador devido à declaração forward na linha 3.

Na linha 9, uma variável chamada obj de tipo C é declarada. No entanto, essa declaração gera um erro porque C não é declarada até mais tarde no programa e não é declarada para frente. Para corrigir o erro, você pode mover toda a definição de antes main ou então adicionar uma declaração de C encaminhamento para ele. Esse comportamento é diferente de outras linguagens, como C#. Nessas línguas, as funções e as classes podem ser utilizadas antes do seu ponto de declaração num ficheiro de origem.

Na linha 10, uma variável chamada str de tipo std::string é declarada. O nome std::string é visível porque é introduzido no stringarquivo de cabeçalho, que é mesclado no arquivo de origem na linha 1. std é o namespace no qual a string classe é declarada.

Na linha 11, um erro é gerado porque o nome j não foi declarado. Uma declaração deve fornecer um tipo, ao contrário de outras linguagens, como JavaScript. Na linha 12, a auto palavra-chave é usada, que diz ao compilador para inferir o tipo de k com base no valor com o qual ele foi inicializado. O compilador, neste caso, escolhe int para o tipo.

Âmbito da declaração

O nome introduzido por uma declaração é válido no âmbito em que a declaração ocorre. No exemplo anterior, as variáveis que são declaradas dentro da main função são variáveis locais. Você poderia declarar outra variável nomeada i fora da principal, no escopo global, e ela seria uma entidade separada. No entanto, essa duplicação de nomes pode levar a confusão e erros do programador e deve ser evitada. Na linha 21, a classe C é declarada no escopo do namespace N. O uso de namespaces ajuda a evitar colisões de nomes. A maioria dos nomes de biblioteca padrão C++ são declarados dentro do std namespace. Para obter mais informações sobre como as regras de escopo interagem com declarações, consulte Escopo.

Definições

Algumas entidades, incluindo funções, classes, enums e variáveis constantes, devem ser definidas e declaradas. Uma definição fornece ao compilador todas as informações necessárias para gerar código de máquina quando a entidade é usada posteriormente no programa. No exemplo anterior, a linha 3 contém uma declaração para a função f , mas a definição para a função é fornecida nas linhas 15 a 18. Na linha 21, a classe C é declarada e definida (embora, como definida, a classe não faça nada). Uma variável constante deve ser definida, ou seja, atribuída um valor, na mesma instrução em que é declarada. Uma declaração de um tipo interno como int é automaticamente uma definição porque o compilador sabe quanto espaço alocar para ela.

O exemplo a seguir mostra declarações que também são definições:

// Declare and define int variables i and j.
int i;
int j = 10;

// Declare enumeration suits.
enum suits { Spades = 1, Clubs, Hearts, Diamonds };

// Declare class CheckBox.
class CheckBox : public Control
{
public:
    Boolean IsChecked();
    virtual int     ChangeState() = 0;
};

Aqui estão algumas declarações que não são definições:

extern int i;
char *strchr( const char *Str, const char Target );

Typedefs e usando instruções

Em versões mais antigas do C++, a typedef palavra-chave é usada para declarar um novo nome que é um alias para outro nome. Por exemplo, o tipo std::string é outro nome para std::basic_string<char>. Deve ser óbvio por que os programadores usam o nome typedef e não o nome real. No C++ moderno, a using palavra-chave é preferida sobre typedef, mas a ideia é a mesma: um novo nome é declarado para uma entidade, que já está declarada e definida.

Membros de classe estática

Os membros de dados de classe estática são variáveis discretas que são compartilhadas por todos os objetos da classe. Como eles são compartilhados, eles devem ser definidos e inicializados fora da definição de classe. Para obter mais informações, consulte Classes.

Declarações externas

Um programa C++ pode conter mais de uma unidade de compilação. Para declarar uma entidade definida em uma unidade de compilação separada, use a extern palavra-chave. As informações na declaração são suficientes para o compilador. No entanto, se a definição da entidade não puder ser encontrada na etapa de vinculação, o vinculador gerará um erro.

Nesta secção

Classes de armazenamento
const
constexpr
extern
Inicializadores
Aliases e typedefs
using Declaração
volatile
decltype
Atributos em C++

Ver também

Conceitos Básicos