Clases y objetos en C++: Guía práctica con ejemplos de código

¿Qué es una clase?

Una clase de C++ es un tipo de dato definido por el usuario que agrupa datos y las funciones que operan sobre esos datos en una sola entidad. Piénselo como un plano: define la forma y el comportamiento de los objetos que pueden crearse a partir de él.

Al igual que el plano de una casa especifica la ubicación de puertas, ventanas y habitaciones, una clase describe la disposición de sus miembros de datos y las operaciones que pueden manipularlos. Múltiples casas (objetos) pueden construirse a partir del mismo plano.

En la ilustración anterior, el único prototipo produce dos casas distintas con diferentes características.

En este tutorial aprenderá:

• Qué es una clase y por qué importa en C++
• Ejemplos concretos de clases
• El papel de los modificadores de acceso private y public
• Cómo crear objetos (instanciación)
• Acceso seguro a miembros de datos
• Funciones miembro dentro y fuera de la definición de la clase
• Constructores y destructores en acción

Declaración de clase

Declarar una clase es sencillo: use la palabra clave class seguida del nombre de la clase y encierre el cuerpo entre llaves.

Sintaxis

class nombreClase {
    // miembros de datos
    // funciones miembro
};

• nombreClase – el identificador de su clase.
• Los miembros de datos se declaran típicamente como variables.
• Las funciones miembro proporcionan comportamiento.

Modificadores de acceso: private vs. public

Los modificadores de acceso controlan la visibilidad de los miembros de la clase.

• private – los miembros solo son accesibles dentro de la clase o sus amigos.
• public – los miembros pueden accederse desde cualquier lugar donde el objeto sea visible.

Creación de objetos (Instanciación)

Los objetos son instancias de una clase. Declarar un objeto sigue el mismo patrón que declarar una variable: nombreClase nombreObjeto;

Sintaxis

nombreClase nombreObjeto;

• nombreClase – la clase a partir de la cual se crea el objeto.
• nombreObjeto – el identificador para el nuevo objeto.

La instanciación asigna memoria para el objeto y puede disparar su constructor.

Acceso a miembros de datos

Los miembros de datos públicos se acceden usando el operador punto (.).

Ejemplo

#include <iostream>
using namespace std;
class Telefono {
public:
    double costo;
    int ranuras;
};
int main() {
    Telefono Y6;
    Telefono Y7;
    Y6.costo = 100.0;
    Y6.ranuras = 2;
    Y7.costo = 200.0;
    Y7.ranuras = 2;
    cout << "Costo de Huawei Y6: " << Y6.costo << endl;
    cout << "Costo de Huawei Y7: " << Y7.costo << endl;
    cout << "Número de ranuras para tarjetas Huawei Y6: " << Y6.ranuras << endl;
    cout << "Número de ranuras para tarjetas Huawei Y7: " << Y7.ranuras << endl;
    return 0;
}

Salida:

¿Por qué usar Getters/Setters?

Acceder o modificar datos directamente puede romper el encapsulamiento. Usar funciones miembro getter y setter proporciona acceso controlado.

Ejemplo con encapsulamiento

#include <iostream>
using namespace std;
class ClaseA {
public:
    void setA(int val);
    int getA() const;
private:
    int a;
};
int ClaseA::getA() const {
    return a;
}
void ClaseA::setA(int val) {
    a = val;
}
int main() {
    ClaseA obj;
    obj.setA(20);
    cout << "Valor de a es: " << obj.getA();
    return 0;
}

Salida:

Miembros protegidos y herencia

Los miembros protegidos son accesibles dentro de la clase y por clases derivadas, permitiendo herencia controlada.

Ejemplo

#include <iostream>
using namespace std;
class ClasePadre {
protected:
    int valor;
};
class ClaseHija : public ClasePadre {
public:
    void setId(int x) {
        valor = x;
    }
    void mostrarValor() {
        cout << "Valor es: " << valor << endl;
    }
};
int main() {
    ClaseHija c;
    c.setId(21);
    c.mostrarValor();
    return 0;
}

Salida:

Funciones miembro dentro vs. fuera de la clase

Las funciones miembro pueden definirse inline dentro de la clase o declararse dentro y definirse después usando el operador de resolución de ámbito ::.

Ejemplo

#include <iostream>
#include <string>
using namespace std;
class Guru99 {
public:
    string nombre_tutorial;
    int id;
    void imprimirNombre();
    void imprimirId() {
        cout << "ID del tutorial es: " << id;
    }
};
void Guru99::imprimirNombre() {
    cout << "Nombre del tutorial es: " << nombre_tutorial;
}
int main() {
    Guru99 guru;
    guru.nombre_tutorial = "C++";
    guru.id = 1001;
    guru.imprimirNombre();
    cout << endl;
    guru.imprimirId();
    return 0;
}

Salida:

Constructores y destructores

Los constructores inicializan objetos al crearlos, mientras que los destructores limpian justo antes de que un objeto sea destruido.

Ejemplo

#include <iostream>
using namespace std;
class ClaseA {
public:
    ClaseA() {
        cout << "Constructor de clase llamado" << endl;
    }
    ~ClaseA() {
        cout << "Destructor de clase llamado" << endl;
    }
};
int main() {
    ClaseA a; // constructor llamado
    int p = 1;
    if (p) {
        ClaseA b; // constructor llamado, destructor al final del bloque
    } // destructor para 'a' llamado aquí
    return 0;
}

Salida:

Conclusiones clave

• C++ es fundamentalmente orientado a objetos; las clases son los bloques de construcción.
• Una clase agrupa datos y funciones relacionadas, creando un plano reutilizable.
• Use public, private y protected para imponer encapsulamiento.
• Instancie objetos con el nombre de la clase seguido del nombre del objeto.
• Acceda a miembros públicos vía operador punto; use getters/setters para datos privados.
• Las funciones miembro pueden definirse inline o fuera de la clase con ::.
• Los constructores inicializan objetos; los destructores manejan limpieza.