Especificadores de acceso en C++

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 34 de 104.

C++ proporciona tres especificadores de acceso que controlan quién puede acceder a los miembros de una clase: public, protected y private. Estos forman la base de la encapsulación.

class Account {
public:
    std::string ownerName;      // Accesible desde cualquier lugar
    
protected:
    double interestRate;        // Accesible en esta clase y clases derivadas
    
private:
    double balance;             // Accesible solo dentro de esta clase
};

Los miembros públicos pueden ser accedidos desde cualquier lugar: dentro de la clase, desde clases derivadas y desde código externo. Los miembros privados son los más restrictivos y solo se puede acceder a ellos dentro de la propia clase. Protegido se encuentra entre ambos: funciona como privado para el mundo exterior, pero las clases derivadas pueden acceder a estos miembros.

class Account {
private:
    double balance;
    
public:
    Account() : balance(0) {}
    
    void deposit(double amount) {
        balance += amount;    // OK - dentro de la clase
    }
};

int main() {
    Account acc;
    acc.deposit(100);         // OK - deposit es público
    // acc.balance = 500;     // ERROR - balance es privado
}

De forma predeterminada, todos los miembros de una clase son privados si no se proporciona ningún especificador. Esto te anima a decidir explícitamente qué debe exponerse. La práctica general consiste en hacer que los miembros de datos sean privados y proporcionar métodos públicos para interactuar con ellos de forma segura.

Desafío

Fácil

Construyamos un sistema sencillo de gestión de empleados que demuestre cómo los especificadores de acceso controlan quién puede acceder a qué. Crearás una clase en la que algunos datos sean completamente privados, otros sean accesibles para posibles subclases y otros estén abiertos a todos.

Crearás dos archivos para organizar tu código:

Employee.h: Define una clase Employee que utilice los tres especificadores de acceso para proteger los datos adecuadamente:
- Público: El name del empleado (string). Se puede acceder a él desde cualquier lugar
- Protegido: El department del empleado (string): accesible dentro de la clase y por las clases derivadas, pero no desde fuera
- Privado: El salary del empleado (double): solo es accesible dentro de la propia clase
- Un constructor que reciba name, department y salary para inicializar los tres miembros
- Un método público getSalary() que devuelva el valor privado de salary
- Un método público getDepartment() que devuelva el valor protegido de department
- Un método público giveRaise(double amount) que incremente el salario en la cantidad indicada (solo si amount es positivo)
- Un método público displayInfo() que muestre la información del empleado con el formato: "Name: <name>, Department: <department>, Salary: $<salary>"
main.cpp: Demuestra cómo funcionan los especificadores de acceso al interactuar con un objeto Employee. Lee el nombre, el departamento y el salario de un empleado desde la entrada (tres líneas separadas) y, después:
- Crea un Employee con los valores introducidos
- Imprime directamente el nombre del empleado accediendo al miembro público: "Direct access - Name: <name>"
- Imprime el departamento utilizando el getter: "Via getter - Department: <department>"
- Imprime el salario utilizando el getter: "Via getter - Salary: $<salary>"
- Concede al empleado un aumento de 5000.0
- Imprime "After raise:"
- Llama a displayInfo() para mostrar la información actualizada

Da formato a todos los valores salariales con dos decimales utilizando std::fixed y std::setprecision(2) de <iomanip>. Convierte la entrada del salario de string a double utilizando std::stod().

La idea clave aquí es que, aunque puedes acceder directamente a name desde main, no puedes acceder directamente a department ni a salary. Debes utilizar los métodos getter públicos. Esto es la encapsulación en acción: la clase controla cómo se accede a sus datos y cómo se modifican.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include <iomanip>
#include "Employee.h"

using namespace std;

int main() {
    // Leer la entrada
    string name;
    string department;
    string salaryStr;
    
    getline(cin, name);
    getline(cin, department);
    getline(cin, salaryStr);
    double salary = stod(salaryStr);
    
    // Establecer la precisión para la salida del salario
    cout << fixed << setprecision(2);
    
    // TODO: Crear un objeto Employee con los valores de entrada
    
    // TODO: Imprimir el nombre del empleado accediendo directamente al miembro público
    // Format: "Direct access - Name: <name>"
    
    // TODO: Imprimir el departamento usando el método getter
    // Format: "Via getter - Department: <department>"
    
    // TODO: Imprimir el salario usando el método getter
    // Format: "Via getter - Salary: $<salary>"
    
    // TODO: Dar al empleado un aumento de 5000.0
    
    // TODO: Imprimir "After raise:"
    
    // TODO: Llamar a displayInfo() para mostrar la información actualizada
    
    return 0;
}