Déclarations et définitions (C++)

  • Article

Un programme C++ se compose de différentes 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 avant de 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 auquel un nom est déclaré est le point auquel il devient visible par le compilateur. Vous ne pouvez pas faire référence à une fonction ou à une classe déclarée ultérieurement dans l’unité de compilation. Les variables doivent être déclarées aussi près que possible avant le point auquel elles sont utilisées.

L’exemple suivant montre certaines 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{/*...*/};
}

Sur la ligne 5, la main fonction est déclarée. Sur la ligne 7, une const variable nommée pi est déclarée et initialisée. Sur 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 de transfert sur la ligne 3.

Dans 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 elle n’est pas déclarée tant qu’elle n’est pas déclarée ultérieurement dans le programme et qu’elle n’est pas déclarée à l’avance. Pour corriger l’erreur, vous pouvez déplacer l’intégralité de la définition avant Cmain ou ajouter une déclaration de transfert pour celle-ci. Ce comportement est différent des 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 stringfichier d’en-tête, qui est fusionné dans le fichier source à la ligne 1. std est l’espace de noms dans lequel la string classe est déclarée.

À la ligne 11, une erreur est généré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, la auto mot clé est utilisée, ce qui indique au compilateur de déduire le type de k la valeur avec laquelle il est initialisé. Le compilateur dans ce cas choisit int pour le type.

Portée de la déclaration

Le nom introduit par une déclaration est valide dans l’étendue où la déclaration se produit. Dans l’exemple précédent, les variables déclarées à l’intérieur de la main fonction sont des variables locales. Vous pouvez déclarer une autre variable nommée i en dehors du principal, dans l’étendue globale, et il s’agirait d’une entité distincte. Toutefois, ces duplications de noms peuvent entraîner une confusion et des erreurs du programmeur et doivent être évitées. À 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èque standard C++ sont déclarés dans l’espace std de noms. Pour plus d’informations sur la façon dont les règles d’étendue interagissent avec les déclarations, consultez Étendue.

Définitions

Certaines entités, notamment les fonctions, les classes, les énumérations et les variables constantes, doivent être définies ainsi que déclarées. Une définition fournit au compilateur toutes les informations dont il a besoin pour générer du code d’ordinateur lorsque l’entité est utilisée ultérieurement 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 dans les lignes 15 à 18. Sur la ligne 21, la classe C est déclarée et définie (bien que définie par la classe ne fasse rien). Une variable constante doit être définie, en d’autres termes, affectée à une valeur, dans la même instruction dans laquelle elle est déclarée. Une déclaration d’un type intégré tel que int celui-ci est automatiquement une définition, car le compilateur sait combien d’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 );

Typedefs et instructions using

Dans les versions antérieures de C++, le typedef mot clé est utilisé pour déclarer un nouveau nom qui est un alias pour un autre nom. Par exemple, le type std::string est un autre nom pour std::basic_string<char>. Il doit être évident que les programmeurs utilisent le nom typedef et non le nom réel. En C++moderne, le using mot clé est préférétypedef, mais l’idée est la même : un nouveau nom est déclaré pour une entité, qui est déjà déclarée et définie.

Membres de classe statique

Les membres de données de classe statique sont des variables discrètes partagées par tous les objets de la classe. Comme 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 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 la extern mot clé. Les informations contenues dans la déclaration sont suffisantes pour le compilateur. Toutefois, si la définition de l’entité est introuvable dans l’étape de liaison, l’éditeur de liens génère une erreur.

Contenu de cette section

Classes de stockage
const
constexpr
extern
Initialiseurs
Alias et typedefs
using Déclaration
volatile
decltype
Attributs en C++

Voir aussi

Concepts de base