Dichiarazioni e definizioni (C++)

Un programma C++ è costituito da varie entità, ad esempio variabili, funzioni, tipi e spazi dei nomi. Ognuna di queste entità deve essere dichiarata prima di poter essere usata. Una dichiarazione specifica un nome univoco per l'entità, insieme alle informazioni sul tipo e altre caratteristiche. In C++ il punto in cui viene dichiarato un nome è il punto in cui diventa visibile al compilatore. Non è possibile fare riferimento a una funzione o a una classe dichiarata in un secondo momento nell'unità di compilazione. Le variabili devono essere dichiarate il più vicino possibile prima del punto in cui vengono usate.

L'esempio seguente mostra alcune dichiarazioni:

#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{/*...*/};
}

Nella riga 5 la main funzione viene dichiarata. Nella riga 7 una const variabile denominata pi viene dichiarata e inizializzata. Nella riga 8 un numero intero i viene dichiarato e inizializzato con il valore prodotto dalla funzione f. Il nome f è visibile al compilatore a causa della dichiarazione forward alla riga 3.

Nella riga 9 viene dichiarata una variabile denominata obj di tipo C . Tuttavia, questa dichiarazione genera un errore perché C non viene dichiarata fino a un secondo momento nel programma e non viene dichiarata in avanti. Per correggere l'errore, è possibile spostare l'intera definizione di C prima main o aggiungere una dichiarazione di inoltro per tale definizione. Questo comportamento è diverso da altri linguaggi, ad esempio C#. In questi linguaggi, le funzioni e le classi possono essere usate prima del punto di dichiarazione in un file di origine.

Nella riga 10 viene dichiarata una variabile denominata str di tipo std::string . Il nome std::string è visibile perché viene introdotto nel stringfile di intestazione, che viene unito al file di origine nella riga 1. std è lo spazio dei nomi in cui viene dichiarata la string classe .

Nella riga 11 viene generato un errore perché il nome j non è stato dichiarato. Una dichiarazione deve fornire un tipo, a differenza di altri linguaggi, ad esempio JavaScript. Nella riga 12 viene usata la auto parola chiave , che indica al compilatore di dedurre il tipo di k in base al valore con cui viene inizializzato. In questo caso il compilatore sceglie int per il tipo .

Ambito della dichiarazione

Il nome introdotto da una dichiarazione è valido all'interno dell'ambito in cui si verifica la dichiarazione. Nell'esempio precedente le variabili dichiarate all'interno della main funzione sono variabili locali. È possibile dichiarare un'altra variabile denominata i all'esterno di main, nell'ambito globale e si tratta di un'entità separata. Tuttavia, tale duplicazione dei nomi può causare confusione ed errori da parte del programmatore e deve essere evitata. Nella riga 21 la classe C viene dichiarata nell'ambito dello spazio dei nomi N. L'uso degli spazi dei nomi consente di evitare conflitti di nomi. La maggior parte dei nomi della libreria standard C++ viene dichiarata all'interno dello spazio dei std nomi . Per altre informazioni sull'interazione delle regole di ambito con le dichiarazioni, vedere Ambito.

Definizioni

Alcune entità, incluse funzioni, classi, enumerazioni e variabili costanti, devono essere definite e dichiarate. Una definizione fornisce al compilatore tutte le informazioni necessarie per generare codice computer quando l'entità viene usata più avanti nel programma. Nell'esempio precedente la riga 3 contiene una dichiarazione per la funzione f , ma la definizione per la funzione viene fornita nelle righe da 15 a 18. Nella riga 21, la classe C è dichiarata e definita (anche se come definito la classe non esegue alcuna operazione). Una variabile costante deve essere definita, in altre parole assegnata a un valore, nella stessa istruzione in cui viene dichiarata. Una dichiarazione di un tipo predefinito, int ad esempio, è automaticamente una definizione perché il compilatore sa quanto spazio allocare per esso.

Nell'esempio seguente vengono illustrate anche le dichiarazioni che sono definizioni:

// 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;
};

Ecco alcune dichiarazioni che non sono definizioni:

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

Typedef e istruzioni using

Nelle versioni precedenti di C++, la typedef parola chiave viene usata per dichiarare un nuovo nome che è un alias per un altro nome. Ad esempio, il tipo std::string è un altro nome per std::basic_string<char>. Dovrebbe essere ovvio perché i programmatori usano il nome typedef e non il nome effettivo. In C++, la using parola chiave è preferibile rispetto typedefa , ma l'idea è la stessa: un nuovo nome viene dichiarato per un'entità, che è già dichiarata e definita.

Membri di classe statici

I membri dati della classe statici sono variabili discrete condivise da tutti gli oggetti della classe . Poiché sono condivisi, devono essere definiti e inizializzati all'esterno della definizione della classe. Per altre informazioni, vedere Classi.

Dichiarazioni extern

Un programma C++ può contenere più di un'unità di compilazione. Per dichiarare un'entità definita in un'unità di compilazione separata, usare la extern parola chiave . Le informazioni nella dichiarazione sono sufficienti per il compilatore. Tuttavia, se la definizione dell'entità non viene trovata nel passaggio di collegamento, il linker genererà un errore.

Contenuto della sezione

Classi di archiviazione
const
constexpr
extern
Inizializzatori
Alias e typedef
using Dichiarazione
volatile
decltype
Attributi in C++

Vedi anche

Concetti di base