Información general sobre miembros de clase

  • Artículo

Un class o struct consta de sus miembros. Las funciones miembro son las encargadas de realizar el trabajo de la clase a la que pertenecen. El estado que mantienen se almacena en sus miembros de datos. La inicialización de los miembros se lleva a cabo mediante constructores y el trabajo de limpieza, como la liberación de memoria y de los recursos se realiza mediante destructores. En C++11 y versiones posteriores, los miembros de datos pueden (y normalmente deberían) inicializarse en el punto en el que se declaran.

Tipos de miembros de clase

La lista completa de categorías de miembros es la siguiente:

Ejemplo de declaración de clase

En el siguiente ejemplo se muestra una declaración de clase sencilla:

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

Accesibilidad de miembros

Los miembros de una clase se declaran en la lista de miembros. La lista de miembros de una clase se puede dividir en un número cualquiera de secciones private, protected y public mediante el uso de palabras clave conocidas como especificadores de acceso. Un signo de dos puntos : debe ir a continuación del especificador de acceso. Estas secciones no tienen que ser contiguas, es decir, cualquiera de estas palabras clave puede aparecer varias veces en la lista de miembros. La palabra clave designa el acceso de todos los miembros hacia arriba hasta el especificador de acceso siguiente o la llave de cierre. Para más información, consulte Control de acceso a miembros (C++).

Miembros estáticos

Un miembro de datos se puede declarar como static, lo que significa que todos los objetos de la clase tienen acceso a la misma copia del mismo. Una función miembro puede declararse como static, en cuyo caso solo puede tener acceso a los miembros de datos estáticos de la clase (y no tiene puntero this). Para más información, consulte Miembros de datos estáticos.

Funciones miembro especiales

Las funciones miembro especiales son funciones que el compilador proporciona automáticamente si no las especifica en el código fuente.

  • Constructor predeterminado

  • Constructor de copias

  • (C++11) Constructor de movimiento

  • Operador de asignación de copia

  • (C++11) Operador de asignación de movimiento

  • Destructor

Para más información, consulte Funciones miembro especiales.

Inicialización miembro a miembro

En C++11 y versiones posteriores, los declaradores de miembros no estáticos pueden contener 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()
{
}

Si un miembro recibe un valor en un constructor, ese valor sobrescribe el valor asignado en la declaración.

Solo hay una copia compartida de los miembros de datos estáticos para todos los objetos de un tipo de clase determinado. Los miembros de datos estáticos se deben definir y se pueden inicializar en el ámbito de archivo. Para más información sobre los miembros de datos estáticos, consulte Miembros de datos estáticos. En el ejemplo siguiente se muestra cómo inicializar miembros de datos 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;

Nota:

El nombre de clase, CanInit2, debe preceder a i para especificar que el i definido es un miembro de la clase CanInit2.

Consulte también

Clases y structs