Visão geral de membros de classe

  • Artigo

Um class ou struct consiste em seus membros. O trabalho que uma classe faz é executado por suas funções membro. O estado que ele mantém é armazenado nos respectivos membros de dados. A inicialização de membros é feita por construtores e o trabalho de limpeza, como liberação de memória e liberação de recursos, é feito por destruidores. No C++ 11 e posterior, os membros de dados podem (e geralmente devem) ser inicializados no ponto de declaração.

Tipos de membros de classe

A lista completa de categorias de membros é a seguinte:

Exemplo de declaração de classe

O exemplo a seguir mostra uma declaração de classe simples:

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

Acessibilidade de membro

Os membros de uma classe são declarados na lista de membros. A lista de membros de uma classe pode ser dividida em qualquer número de seções private, protected e public usando palavras-chave conhecidas como especificadores de acesso. Um dois pontos : deverá seguir o especificador de acesso. Essas seções não precisam ser contíguas, ou seja, qualquer uma dessas palavras-chave poderá aparecer várias vezes na lista de membros. A palavra-chave designa o acesso de todos os membros acima até o próximo especificador de acesso ou a próxima chave de fechamento. Para obter mais informações, consulte Controle de acesso a membro (C++).

Membros estáticos

Um membro de dados pode ser declarado como estático, o que significa que todos os objetos da classe têm acesso à mesma cópia dele. Uma função membro pode ser declarada como estática, nesse caso, ela somente pode acessar membros de dados estáticos da classe (e não tem ponteiro this). Para obter mais informações, consulte Membros de dados estáticos.

Funções de membro especiais

Funções membro especiais são as funções que o compilador fornecerá automaticamente se você não especificá-las no código-fonte.

  • Construtor padrão

  • Construtor de cópia

  • (C++11) Construtor de movimento

  • Operador de atribuição de cópia

  • (C++11) Operador de atribuição de movimento

  • Destruidor

Para obter mais informações, consulteFunções membro especiais.

Inicialização por membro

No C++ 11 e posterior, os declaradores de membros não estáticos podem conter inicializadores.

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 um membro receber um valor em um construtor, esse valor substituirá o valor atribuído na declaração.

Há apenas uma cópia compartilhada de membros de dados estáticos para todos os objetos de um determinado tipo de classe. Os membros de dados estáticos devem ser definidos e podem ser inicializados no escopo do arquivo. Para obter mais informações sobre membros de dados estáticos, consulte Membros de dados estáticos. O exemplo a seguir mostra como inicializar membros de dados estáticos:

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

Observação

O nome da classe, CanInit2, deve preceder i para especificar que i que está sendo definida é um membro da classe CanInit2.

Confira também

Classes e Structs