Zugriffsbezeichner in C++

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy. Lektion 34 von 104.

C++ bietet drei Zugriffsbezeichner, die steuern, wer auf Klassenmitglieder zugreifen kann: public, protected und private. Sie bilden die Grundlage der Kapselung.

class Account {
public:
    std::string ownerName;      // Von überall zugänglich
    
protected:
    double interestRate;        // Zugänglich in dieser Klasse und abgeleiteten Klassen
    
private:
    double balance;             // Nur innerhalb dieser Klasse zugänglich
};

Auf öffentliche Member kann von überall aus zugegriffen werden – innerhalb der Klasse, von abgeleiteten Klassen und von externem Code. Private Member sind am stärksten eingeschränkt und nur innerhalb der Klasse selbst zugänglich. Geschützte Member liegen dazwischen – für die Außenwelt verhalten sie sich wie private Member, aber abgeleitete Klassen können auf diese Member zugreifen.

class Account {
private:
    double balance;
    
public:
    Account() : balance(0) {}
    
    void deposit(double amount) {
        balance += amount;    // OK - innerhalb der Klasse
    }
};

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

Standardmäßig sind alle Mitglieder einer Klasse privat, wenn kein Spezifizierer angegeben wird. Dadurch wirst du dazu angehalten, ausdrücklich zu entscheiden, was zugänglich gemacht werden soll. Im Allgemeinen werden Datenmitglieder privat gemacht und öffentliche Methoden bereitgestellt, um sicher mit ihnen zu interagieren.

Aufgabe

Einfach

Erstellen wir ein einfaches Mitarbeiterverwaltungssystem, das zeigt, wie Zugriffsbezeichner steuern, wer worauf zugreifen kann. Du erstellst eine Klasse, in der einige Daten vollständig privat sind, einige für mögliche Unterklassen zugänglich sind und einige für alle offenstehen.

Du erstellst zwei Dateien, um deinen Code zu organisieren:

Employee.h: Definiere eine Employee-Klasse, die alle drei Zugriffsbezeichner verwendet, um Daten angemessen zu schützen:
- Öffentlich: Der name (string) des Mitarbeiters. Darauf kann von überall aus zugegriffen werden
- Geschützt: Die department (string) des Mitarbeiters: innerhalb der Klasse und von abgeleiteten Klassen aus zugänglich, aber nicht von außerhalb
- Privat: Das salary (double) des Mitarbeiters: nur innerhalb der Klasse selbst zugänglich
- Ein Konstruktor, der name, department und salary entgegennimmt, um alle drei Member zu initialisieren
- Eine öffentliche Methode getSalary(), die den privaten salary-Wert zurückgibt
- Eine öffentliche Methode getDepartment(), die den geschützten department-Wert zurückgibt
- Eine öffentliche Methode giveRaise(double amount), die das salary um den angegebenen Betrag erhöht (nur wenn amount positiv ist)
- Eine öffentliche Methode displayInfo(), die die Informationen des Mitarbeiters im folgenden Format ausgibt: "Name: <name>, Department: <department>, Salary: $<salary>"
main.cpp: Zeige, wie Zugriffsbezeichner funktionieren, indem du mit einem Employee-Objekt interagierst. Lies den Namen, die Abteilung und das Gehalt eines Mitarbeiters aus der Eingabe ein (drei separate Zeilen), und:
- Erstelle einen Employee mit den Eingabewerten
- Gib den Namen des Mitarbeiters direkt aus, indem du auf das öffentliche Member zugreifst: "Direct access - Name: <name>"
- Gib die Abteilung mithilfe des Getters aus: "Via getter - Department: <department>"
- Gib das Gehalt mithilfe des Getters aus: "Via getter - Salary: $<salary>"
- Gib dem Mitarbeiter eine Gehaltserhöhung von 5000.0
- Gib "After raise:" aus
- Rufe displayInfo() auf, um die aktualisierten Informationen anzuzeigen

Formatiere alle Gehaltswerte mit zwei Dezimalstellen mithilfe von std::fixed und std::setprecision(2) aus <iomanip>. Wandle die Gehaltseingabe mithilfe von std::stod() von einem String in einen Double-Wert um.

Die zentrale Erkenntnis ist, dass du zwar aus main direkt auf name zugreifen kannst, aber nicht direkt auf department oder salary. Du musst die öffentlichen Getter-Methoden verwenden. Das ist Kapselung in der Praxis: Die Klasse steuert, wie auf ihre Daten zugegriffen wird und wie diese geändert werden.

Probier es selbst

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

using namespace std;

int main() {
    // Eingabe lesen
    string name;
    string department;
    string salaryStr;
    
    getline(cin, name);
    getline(cin, department);
    getline(cin, salaryStr);
    double salary = stod(salaryStr);
    
    // Präzision für die Gehaltsausgabe festlegen
    cout << fixed << setprecision(2);
    
    // TODO: Erstelle ein Employee-Objekt mit den Eingabewerten
    
    // TODO: Gib den Namen des Mitarbeiters aus, indem du direkt auf das öffentliche Mitglied zugreifst
    // Format: "Direct access - Name: <name>"
    
    // TODO: Gib die Abteilung mit der Getter-Methode aus
    // Format: "Via getter - Department: <department>"
    
    // TODO: Gib das Gehalt mit der Getter-Methode aus
    // Format: "Via getter - Salary: $<salary>"
    
    // TODO: Gib dem Mitarbeiter eine Gehaltserhöhung von 5000.0
    
    // TODO: Gib "After raise:" aus
    
    // TODO: Rufe displayInfo() auf, um die aktualisierten Informationen anzuzeigen
    
    return 0;
}