Vue d’ensemble des membres de classe

  • Article

A class ou struct se compose de ses membres. Le travail exécuté par une classe est effectué par ses fonctions membres. L'état géré est stocké dans ses données membres. L’initialisation des membres est effectuée par les constructeurs et propre travail de mise en service, comme libérer de la mémoire et libérer des ressources, est effectuée par des destructeurs. En C++11 et versions ultérieures, les données membres peuvent (et généralement doivent) être initialisées au point de déclaration.

Genres de membres de classe

La liste complète des catégories de membres est la suivante :

Exemple de déclaration de classe

L'exemple suivant illustre une déclaration de classe simple :

// TestRun.h

class TestRun
{
    // Start member list.

    // The class interface accessible to all callers.
public:
    // Use compiler-generated default constructor:
    TestRun() = default;
    // Don't generate a copy constructor:
    TestRun(const TestRun&) = delete;
    TestRun(std::string name);
    void DoSomething();
    int Calculate(int a, double d);
    virtual ~TestRun();
    enum class State { Active, Suspended };

    // Accessible to this class and derived classes only.
protected:
    virtual void Initialize();
    virtual void Suspend();
    State GetState();

    // Accessible to this class only.
private:
    // Default brace-initialization of instance members:
    State _state{ State::Suspended };
    std::string _testName{ "" };
    int _index{ 0 };

    // Non-const static member:
    static int _instances;
    // End member list.
};

// Define and initialize static member.
int TestRun::_instances{ 0 };

Accessibilité des membres

Les membres d'une classe sont déclarés dans la liste des membres. La liste des membres d’une classe peut être divisée en un nombre privatequelconque et protectedpublic des sections utilisant des mot clé s appelées spécificateurs d’accès. Un signe deux-points : doit suivre le spécificateur d’accès. Ces sections n’ont pas besoin d’être contiguës ; autrement dit, l’une de ces mot clé peut apparaître plusieurs fois dans la liste des membres. Le mot clé désigne l'accès de tous les membres jusqu'au spécificateur d'accès suivant ou l'accolade fermante. Pour plus d’informations, consultez Contrôle d’accès aux membres (C++).

Membres statiques

Des données membres peuvent être déclarées comme statiques, ce qui signifie que tous les objets de la classe ont accès à la même copie de celles-ci. Une fonction membre peut être déclarée statique, auquel cas elle ne peut accéder qu’aux membres de données statiques de la classe (et n’a pas this de pointeur). Pour plus d’informations, consultez Membres de données statiques.

Fonctions membres spéciales

Les fonctions membres spéciales sont des fonctions que le compilateur fournit automatiquement si vous ne les spécifiez pas dans votre code source.

  • Constructeur par défaut.

  • Constructeur de copie

  • (C++11) Constructeur de déplacement

  • Opérateur d'assignation de copie

  • (C++11) Opérateur d’affectation de déplacement

  • Destructeur

Pour plus d’informations, consultez fonctions membres spéciales.

Initialisation à l’échelle des membres

En C++11 et versions ultérieures, les déclarateurs de membres non statiques peuvent contenir des initialiseurs.

class CanInit
{
public:
    long num {7};       // OK in C++11
    int k = 9;          // OK in C++11
    static int i = 9; // Error: must be defined and initialized
                      // outside of class declaration.

    // initializes num to 7 and k to 9
    CanInit(){}

    // overwrites original initialized value of num:
    CanInit(int val) : num(val) {}
};
int main()
{
}

Si un membre est affecté à une valeur dans un constructeur, cette valeur remplace la valeur affectée à la déclaration.

Il n’existe qu’une seule copie partagée de membres de données statiques pour tous les objets d’un type de classe donné. Les membres de données statiques doivent être définies et peuvent être initialisées au niveau de la portée du fichier. Pour plus d’informations sur les membres de données statiques, consultez Les membres de données statiques. L’exemple suivant montre comment initialiser les membres de données statiques :

// class_members2.cpp
class CanInit2
{
public:
    CanInit2() {} // Initializes num to 7 when new objects of type
                 //  CanInit are created.
    long     num {7};
    static int i;
    static int j;
};

// At file scope:

// i is defined at file scope and initialized to 15.
// The initializer is evaluated in the scope of CanInit.
int CanInit2::i = 15;

// The right side of the initializer is in the scope
// of the object being initialized
int CanInit2::j = i;

Remarque

Le nom de classe, CanInit2, doit précéder i pour spécifier que le i défini est un membre de classe CanInit2.

Voir aussi

Classes et structs