Modificadores de acceso en C++

En C++ los modificadores de acceso permiten controlar el acceso a los miembros de una clase, facilitando el manejo de la visibilidad y protección de datos.

En C++, los modificadores de acceso son public, protected y private. Cada uno de estos modificadores define un nivel específico de accesibilidad para los miembros de una clase.

Modificadores de acceso

Los modificadores de acceso determinan la visibilidad de los miembros de una clase desde fuera de ella.

Modificador public

El modificador public permite que los miembros de una clase sean accesibles desde cualquier parte del código. Esto es útil para definir la interfaz pública de una clase (es decir, los métodos y atributos que otros componentes pueden usar para interactuar con ella).

#include <iostream>
#include <string>

class Vehiculo
{
public:
    std::string Marca;
    std::string Modelo;

    void Arrancar()
    {
        std::cout << Marca << " " << Modelo << " ha arrancado." << std::endl;
    }
};

int main()
{
    Vehiculo miVehiculo;
    miVehiculo.Marca = "Toyota";
    miVehiculo.Modelo = "Corolla";
    miVehiculo.Arrancar(); // Acceso permitido

    return 0;
}

En este ejemplo, tanto los atributos Marca y Modelo como el método Arrancar son públicos y pueden ser accedidos desde fuera de la clase Vehiculo.

Modificador private

El modificador private restringe el acceso a los miembros de la clase a la propia clase. Esto asegura que los datos internos no puedan ser modificados directamente desde fuera de la clase, promoviendo el encapsulamiento y protegiendo la integridad de los datos.

#include <iostream>

class CuentaBancaria
{
private:
    double saldo;

public:
    CuentaBancaria(double saldoInicial) : saldo(saldoInicial) {}

    void Depositar(double cantidad)
    {
        saldo += cantidad;
    }

    double ObtenerSaldo() const
    {
        return saldo;
    }
};

int main()
{
    CuentaBancaria miCuenta(1000.0);
    miCuenta.Depositar(500.0);
    std::cout << "Saldo: " << miCuenta.ObtenerSaldo() << std::endl; // Acceso permitido

    // miCuenta.saldo = 2000.0; // Error: 'saldo' es privado

    return 0;
}

Aquí, el atributo saldo está declarado como private, lo que significa que solo puede ser accedido dentro de la clase CuentaBancaria.

Modificador protected

El modificador protected permite que los miembros de una clase sean accesibles dentro de la propia clase y en las clases derivadas. Esto es útil para permitir que las clases derivadas accedan a ciertos datos o métodos de la clase base mientras mantienen estos miembros ocultos para otros usuarios de la clase.

#include <iostream>

class Animal
{
protected:
    void Comer()
    {
        std::cout << "El animal está comiendo." << std::endl;
    }
};

class Perro : public Animal
{
public:
    void Ladrar()
    {
        Comer(); // Acceso permitido
        std::cout << "El perro está ladrando." << std::endl;
    }
};

int main()
{
    Perro miPerro;
    miPerro.Ladrar(); // Acceso permitido

    // miPerro.Comer(); // Error: 'Comer' es protected

    return 0;
}

En este caso, el método Comer es protected, por lo que puede ser llamado desde la clase derivada Perro, pero no desde fuera de la jerarquía de herencia.

Modificador protected en la herencia

Cuando se utiliza protected en la herencia, los miembros protected de la clase base permanecen protected en la clase derivada, mientras que los miembros public se convierten en protected.

#include <iostream>

class Base
{
protected:
    void MetodoProtected()
    {
        std::cout << "Método protegido en la clase base." << std::endl;
    }
};

class Derivada : protected Base
{
public:
    void LlamarMetodo()
    {
        MetodoProtected(); // Acceso permitido
    }
};

int main()
{
    Derivada obj;
    obj.LlamarMetodo(); // Acceso permitido

    // obj.MetodoProtected(); // Error: 'MetodoProtected' es protected

    return 0;
}

En este ejemplo, el método MetodoProtected es protected en la clase base y se mantiene como protected en la clase derivada, lo que significa que no puede ser accedido directamente desde fuera de la jerarquía de herencia.