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.
Los modificadores de acceso implementa el principio de Encapsulación, uno de los pilares de la programación orientada a objetos
Si quieres aprender más sobre Encapsulación
consulta el Curso de Programación Orientada a Objetos leer más ⯈
Modificadores de Acceso
Los modificadores de acceso determinan la visibilidad de los miembros de una clase desde fuera de ella.
Modificador | Accesible desde |
---|---|
public | Desde cualquier lugar. |
protected | Desde la clase base y las clases derivadas. |
private | Solo dentro de la clase. |
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.