Panoramica dei membri di classe

Un class oggetto o struct è costituito dai relativi membri. Il lavoro effettuato da una classe viene eseguito dalle rispettive funzioni membro. Lo stato mantenuto viene archiviato nei rispettivi membri dati. L'inizializzazione dei membri viene eseguita dai costruttori e il lavoro di pulizia, ad esempio liberare memoria e rilasciare le risorse, viene eseguito da distruttori. In C++11 e versioni successive i membri dati possono e in genere devono essere inizializzati in corrispondenza del momento della dichiarazione.

Tipi di membri di classe

L'elenco completo delle categorie membro è il seguente:

• Funzioni membro speciali.

• Panoramica delle funzioni membro.

• Membri dati modificabili e statici , inclusi i tipi predefiniti e altri tipi definiti dall'utente.

• Operatori

• Dichiarazioni di classi annidate e .

• Unioni

• Enumerazioni.

• Campi di bit.

• Amici.

• Alias e typedef.

  Nota

  Gli elementi friend vengono inclusi nell'elenco precedente perché sono contenuti nella dichiarazione di classe. Non sono tuttavia membri effettivi della classe perché non si trovano nell'ambito della classe.

Esempi di dichiarazione di classe

L'esempio seguente illustra una semplice dichiarazione di classe:

// 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à del membro

I membri di una classe vengono dichiarati nell'elenco dei membri. L'elenco di membri di una classe può essere suddiviso in un numero qualsiasi di privateprotected sezioni e public usando parole chiave note come identificatori di accesso. Un punto : deve seguire l'identificatore di accesso. Queste sezioni non devono essere contigue; ovvero, una di queste parole chiave può essere visualizzata più volte nell'elenco dei membri. La parola chiave consente di accedere a tutti i membri fino all'identificatore di accesso successivo o alla parentesi graffa di chiusura. Per altre informazioni, vedere Controllo di accesso dei membri (C++).

Membri statici

Un membro dati può essere dichiarato come statico, ovvero tutti gli oggetti della classe possono accedere alla stessa copia del membro. Una funzione membro può essere dichiarata come statica, nel qual caso può accedere solo ai membri dati statici della classe (e non dispone di puntatore this ). Per altre informazioni, vedere Membri dati statici.

Funzioni membro speciali

Le funzioni membro speciali sono funzioni fornite automaticamente dal compilatore se non vengono specificate nel codice sorgente.

• Costruttore predefinito.

• Costruttore di copia

• (C++11) Costruttore Move

• Operatore di assegnazione di copia

• (C++11) Operatore di assegnazione move

• Distruttore

Per altre informazioni, vedere Funzioni membro speciali.

Inizializzazione a livello di membro

In C++11 e versioni successive i dichiaratori di membri non statici possono includere inizializzatori.

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()
{
}

Se a un membro viene assegnato un valore in un costruttore, tale valore sovrascrive il valore assegnato alla dichiarazione.

È disponibile una sola copia condivisa di membri dati statici per tutti gli oggetti di un determinato tipo di classe. I membri dei dati statici devono essere definiti e possono essere inizializzati in ambito file. Per altre informazioni sui membri dati statici, vedere Membri dati statici. Nell'esempio seguente viene illustrato come inizializzare membri dati statici:

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

Nota

Il nome della classe, CanInit2, deve precedere i per specificare che i da definire è un membro della classe CanInit2.

Vedi anche

Classi e struct