Spécificateurs d’accès en C++

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 34 sur 104.

C++ fournit trois spécificateurs d’accès qui contrôlent qui peut accéder aux membres d’une classe : public, protected et private. Ils constituent le fondement de l’encapsulation.

class Account {
public:
    std::string ownerName;      // Accessible de n'importe où
    
protected:
    double interestRate;        // Accessible dans cette classe et les classes dérivées
    
private:
    double balance;             // Accessible uniquement au sein de cette classe
};

Les membres publics peuvent être accessibles de n’importe où — à l’intérieur de la classe, depuis les classes dérivées et depuis du code externe. Les membres privés sont les plus restrictifs et ne sont accessibles qu’au sein de la classe elle-même. Protégé se situe entre les deux — il se comporte comme privé vis-à-vis du monde extérieur, mais les classes dérivées peuvent accéder à ces membres.

class Account {
private:
    double balance;
    
public:
    Account() : balance(0) {}
    
    void deposit(double amount) {
        balance += amount;    // OK - à l'intérieur de la classe
    }
};

int main() {
    Account acc;
    acc.deposit(100);         // OK - deposit est public
    // acc.balance = 500;     // ERROR - balance est private
}

Par défaut, tous les membres d’une classe sont privés si aucun spécificateur n’est indiqué. Cela vous encourage à décider explicitement de ce qui doit être exposé. En règle générale, les membres de données sont privés et des méthodes publiques sont fournies pour interagir avec eux en toute sécurité.

Défi

Facile

Construisons un système simple de gestion des employés qui montre comment les spécificateurs d'accès contrôlent qui peut accéder à quoi. Vous allez créer une class dans laquelle certaines données sont complètement privées, certaines sont accessibles aux classes dérivées potentielles, et certaines sont ouvertes à tout le monde.

Vous allez créer deux fichiers pour organiser votre code :

Employee.h : Define une class Employee qui utilise les trois spécificateurs d'accès afin de protéger les données de manière appropriée :
- Public : le name (chaîne de caractères) de l'employé. Celui-ci peut être accessible de anywhere
- Protected : le department (chaîne de caractères) de l'employé : accessible à l'intérieur de la class et par les classes derived, mais pas de l'extérieur
- Private : le salary (double) de l'employé : accessible uniquement à l'intérieur de la class elle-même
- Un constructeur qui prend name, department et salary pour initialiser les trois members
- Un method public getSalary() qui renvoie la valeur salary privée
- Un method public getDepartment() qui renvoie la valeur department protégée
- Un method public giveRaise(double amount) qui augmente le salary de la amount indiquée (uniquement si amount est positive)
- Un method public displayInfo() qui affiche les informations de l'employé au format : "Name: <name>, Department: <department>, Salary: $<salary>"
main.cpp : montrez comment fonctionnent les spécificateurs d'accès en interagissant avec un object Employee. Lisez le name, le department et le salary d'un employé depuis l'input (trois lignes distinctes), puis :
- Créez un Employee avec les valeurs d'input
- Affichez directement le name de l'employé en accédant au member public : "Direct access - Name: <name>"
- Affichez le department à l'aide du getter : "Via getter - Department: <department>"
- Affichez le salary à l'aide du getter : "Via getter - Salary: $<salary>"
- Give à l'employé une augmentation de 5000.0
- Affichez "After raise:"
- Appelez displayInfo() pour afficher les informations mises à jour

Formatez toutes les valeurs de salary avec deux décimales à l'aide de std::fixed et de std::setprecision(2) de <iomanip>. Convertissez l'input de salary de string en double à l'aide de std::stod().

L'idée essentielle ici est que, bien que vous puissiez accéder directement au name depuis main, vous ne pouvez pas accéder directement au department ni au salary. Vous devez utiliser les public getter methods. C'est l'encapsulation en action : la class contrôle la manière dont ses données sont accessibles et modifiées.

Essayez vous-même

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

using namespace std;

int main() {
    // Lire l'entrée
    string name;
    string department;
    string salaryStr;
    
    getline(cin, name);
    getline(cin, department);
    getline(cin, salaryStr);
    double salary = stod(salaryStr);
    
    // Définir la précision pour la sortie du salaire
    cout << fixed << setprecision(2);
    
    // TODO: Créer un objet Employee avec les valeurs d'entrée
    
    // TODO: Afficher le nom de l'employé en accédant directement au membre public
    // Format: "Direct access - Name: <name>"
    
    // TODO: Afficher le département en utilisant la méthode getter
    // Format: "Via getter - Department: <department>"
    
    // TODO: Afficher le salaire en utilisant la méthode getter
    // Format: "Via getter - Salary: $<salary>"
    
    // TODO: Accorder une augmentation de 5000.0 à l'employé
    
    // TODO: Afficher "After raise:"
    
    // TODO: Appeler displayInfo() pour afficher les informations mises à jour
    
    return 0;
}