Déclarations et définitions (C++)
Un programme C++ se compose de diverses entités telles que des variables, des fonctions, des types et des espaces de noms. Chacune de ces entités doit être déclarée pour pouvoir être utilisée. Une déclaration spécifie un nom unique pour l’entité ainsi que des informations sur son type et d’autres caractéristiques. En C++, le point où un nom est déclaré correspond au moment où il devient visible par le compilateur. Vous ne pouvez pas faire référence à une fonction ou une classe déclarée plus tard dans l’unité de compilation. Les variables doivent être déclarées aussi près que possible du point où elles sont utilisées.
L’exemple suivant montre quelques déclarations :
#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{/*...*/};
}
À la ligne 5, la fonction main est déclarée. À la ligne 7, une variable const nommée pi est déclarée et initialisée. À la ligne 8, un entier i est déclaré et initialisé avec la valeur produite par la fonction f. Le nom f est visible par le compilateur en raison de la déclaration effectuée à l’avance à la ligne 3.
À la ligne 9, une variable nommée obj de type C est déclarée. Toutefois, cette déclaration génère une erreur, car C n’est déclaré que plus tard dans le programme, et n’est pas déclaré à l’avance. Pour corriger l’erreur, vous pouvez soit déplacer l’ensemble de la définition de C avant main, soit ajouter une déclaration à l’avance pour celle-ci. Ce comportement est différent de celui d’autres langages tels que C#. Dans ces langages, les fonctions et les classes peuvent être utilisées avant leur point de déclaration dans un fichier source.
À la ligne 10, une variable nommée str de type std::string est déclarée. Le nom std::string est visible, car il est introduit dans le fichier d’en-tête string, qui est fusionné dans le fichier source à la ligne 1. std est l’espace de noms dans lequel la classe string est déclarée.
À la ligne 11, une erreur est déclenchée, car le nom j n’a pas été déclaré. Une déclaration doit fournir un type, contrairement à d’autres langages tels que JavaScript. À la ligne 12, le mot clé auto est utilisé, ce qui indique au compilateur de déduire le type de k en fonction de la valeur avec laquelle il est initialisé. Dans ce cas, le compilateur choisit int en tant que type.
Portée de la déclaration
Le nom introduit par une déclaration est valide dans l’étendue où la déclaration a lieu. Dans l’exemple précédent, les variables déclarées au sein de la fonction main sont des variables locales. Si vous déclarez une autre variable nommée i en dehors de main, dans une étendue globale, il s’agira d’une entité distincte. Toutefois, la duplication de noms peut être source de confusion et d’erreurs chez le programmeur. Elle doit donc être évitée. À la ligne 21, la classe C est déclarée dans l’étendue de l’espace de noms N. L’utilisation d’espaces de noms permet d’éviter les collisions de noms. La plupart des noms de bibliothèques en C++ Standard sont déclarés dans l’espace de noms std. Pour plus d’informations sur l’interaction entre les règles d’étendue et les déclarations, consultez Étendue.
Définitions
Certaines entités, notamment les fonctions, les classes, les enums et les variables constantes, doivent être définies et déclarées. Une définition fournit au compilateur toutes les informations dont il a besoin pour générer du code machine quand l’entité est utilisée plus tard dans le programme. Dans l’exemple précédent, la ligne 3 contient une déclaration pour la fonction f, mais la définition de la fonction est fournie aux lignes 15 à 18. À la ligne 21, la classe C est à la fois déclarée et définie (toutefois, bien que la classe soit définie, elle ne fait rien). Une variable constante doit être définie. En d’autres termes, elle doit se voir affecter une valeur, dans l’instruction où elle est déclarée. La déclaration d’un type intégré tel que int est automatiquement une définition, car le compilateur sait quel espace lui allouer.
L’exemple suivant montre des déclarations qui sont également des définitions :
// 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;
};
Voici quelques déclarations qui ne sont pas des définitions :
extern int i;
char *strchr( const char *Str, const char Target );
Instructions typedef et using
Dans les anciennes versions de C++, le mot clé typedef est utilisé pour déclarer un nouveau nom qui représente l’alias d’un autre nom. Par exemple, le type std::string représente un autre nom de std::basic_string<char>. La raison pour laquelle les programmeurs utilisent le nom typedef à la place du nom réel doit être évidente. En C++ moderne, le mot clé using est préféré à typedef. Toutefois, l’idée est la même : un nouveau nom est déclaré pour une entité déjà déclarée et définie.
Membres de classe statiques
Les membres de données de classe statiques sont des variables discrètes partagées par tous les objets de la classe. Dans la mesure où ils sont partagés, ils doivent être définis et initialisés en dehors de la définition de classe. Pour plus d’informations, consultez Classes.
Déclarations utilisant extern
Un programme C++ peut contenir plusieurs unités de compilation. Pour déclarer une entité définie dans une unité de compilation distincte, utilisez le mot clé extern. Les informations contenues dans la déclaration sont suffisantes pour le compilateur. Toutefois, si la définition de l’entité est introuvable à l’étape d’édition des liens, l’éditeur de liens génère une erreur.
Contenu de cette section
Classes de stockage
const
constexpr
extern
Initialiseurs
Alias et typedefs
Déclaration utilisant using
volatile
decltype
Attributs en C++