Unterschiede zwischen öffentlichen und privaten Zugriffsspezifiern in C++

Unterschiede zwischen öffentlichen und privaten Zugriffsspezifiern in C++

Inhaltsverzeichnis:

1. Einführung in die Unterschiede zwischen den öffentlichen und privaten Zugriffsspezifiern 1.1 Öffentlicher Zugriffsspezifizier 1.2 Privater Zugriffsspezifizier
2. Beispiel für den öffentlichen Zugriffsspezifizier
3. Beispiel für den privaten Zugriffsspezifizier
4. Verwendung von Funktionen mit privaten Zugriffsspezifiern 4.1 Getter-Funktion 4.2 Setter-Funktion
5. Konzept der Kapselung
6. Beispiel für die Verwendung von Getter- und Setter-Funktionen
7. Die Rolle privater Memberfunktionen 7.1 Das Konzept der "Information Hiding"
8. Beispiel für eine private Memberfunktion
9. Die Rolle öffentlicher Memberfunktionen 9.1 Die Funktion "Print Bonus"
10. Fazit

Öffentliche und private Zugriffsspezifiere in C++

In der Programmiersprache C++ gibt es Zugriffsspezifizierer, die bestimmen, wo die Member einer Klasse verwendet werden können. Die beiden Hauptzugriffsspezifiere sind der öffentliche und der private Zugriffsspezifizier. In diesem Artikel werden wir uns die Unterschiede zwischen diesen beiden Zugriffsspezifiern genauer ansehen und Beispiele für ihre Verwendung geben.

1. Einführung in die Unterschiede zwischen den öffentlichen und privaten Zugriffsspezifiern

Die öffentlichen Zugriffsspezifiere ermöglichen die Verwendung und den Zugriff auf die Membervariablen einer Klasse außerhalb der Klasse. Das bedeutet, dass wir auf diese Variablen in unserem Hauptprogramm zugreifen können. Der private Zugriffsspezifizier hingegen begrenzt den Zugriff auf die Membervariablen und -funktionen auf die Klasse selbst. Das heißt, wir können nicht auf diese Variablen oder Funktionen außerhalb der Klasse zugreifen.

1.1 Öffentlicher Zugriffsspezifizier

Wenn wir einen Member einer Klasse als öffentlich deklarieren, kann auf diesen Member außerhalb der Klasse zugegriffen werden. Ein Beispiel hierfür ist die Definition einer Klasse namens "Employee", die einen öffentlich deklarierten Member namens "Name" hat. Der öffentliche Zugriffsspezifizier ermöglicht es uns, den Namen des Mitarbeiters in unserem Hauptprogramm zu verwenden und darauf zuzugreifen.

Angestellter employee1;
employee1.Name = "Kevin";
cout << "Der Name des Mitarbeiters ist: " << employee1.Name << endl;

In diesem Beispiel können wir den Namen des Mitarbeiters "Kevin" ausgeben, da der öffentliche Zugriffsspezifizier den Zugriff auf den Namen außerhalb der Klasse ermöglicht.

1.2 Privater Zugriffsspezifizier

Im Gegensatz dazu limitiert der private Zugriffsspezifizier den Zugriff auf einen Member außerhalb der Klasse. Wenn wir den Zugriffsspezifizier eines Members als privat deklarieren, können wir nicht auf diesen Member von außerhalb der Klasse zugreifen. Nehmen wir als Beispiel die Deklaration eines privaten Members "Gehalt" in der "Employee"-Klasse. Wenn wir nun versuchen, auf dieses Mitglied von außerhalb der Klasse zuzugreifen und ihm den Wert "50.000" zuzuweisen, erhalten wir einen Compilerfehler.

Angestellter employee1;
employee1.Gehalt = 50000; // Compilerfehler

Die Meldung besagt, dass das Gehalt ein privater Member der Klasse "Employee" ist und daher nicht von außerhalb der Klasse zugegriffen werden kann.

2. Beispiel für den öffentlichen Zugriffsspezifizier

Wir haben bereits gesehen, dass der öffentliche Zugriffsspezifizier den Zugriff auf einen Member von außerhalb der Klasse ermöglicht. Jetzt schauen wir uns ein Beispiel an, um dies weiter zu veranschaulichen.

class Employee {
public:
    string Name;
};

int main() {
    Employee employee1;
    employee1.Name = "Kevin";
    cout << "Der Name des Mitarbeiters ist: " << employee1.Name << endl;
    return 0;
}

In diesem Beispiel haben wir die Klasse "Employee" definiert und einen öffentlich deklarierten Member "Name". Im Hauptprogramm deklarieren wir eine Instanz der Klasse "Employee" namens "employee1" und weisen ihr den Namen "Kevin" zu. Durch die Verwendung des öffentlichen Zugriffsspezifizierers können wir den Namen des Mitarbeiters ausgeben.

3. Beispiel für den privaten Zugriffsspezifizier

Nun schauen wir uns ein Beispiel für den privaten Zugriffsspezifizier an.

class Employee {
private:
    double Gehalt;
};

int main() {
    Employee employee1;
    employee1.Gehalt = 50000; // Compilerfehler
    return 0;
}

In diesem Beispiel haben wir einen privaten Member "Gehalt" in der Klasse "Employee" deklariert. Wenn wir versuchen, diesen Member im Hauptprogramm zuzuweisen, erhalten wir einen Compilerfehler, da der Zugriffsspezifizier privat ist und daher der Zugriff von außerhalb der Klasse nicht erlaubt ist.

4. Verwendung von Funktionen mit privaten Zugriffsspezifiern

Neben Mitgliedsvariablen können auch Funktionen in einer Klasse als privat oder öffentlich deklariert werden. Funktionen mit privatem Zugriffsspezifizier können nur von anderen Funktionen innerhalb der Klasse aufgerufen werden. Wir verwenden normalerweise Getter- und Setter-Funktionen, um den Zugriff auf private Membervariablen zu verwalten.

4.1 Getter-Funktion

Eine Getter-Funktion wird verwendet, um den Wert einer privaten Membervariable abzurufen. Betrachten wir ein Beispiel:

class Employee {
private:
    double Gehalt;

public:
    double getGehalt() {
        return Gehalt;
    }
};

int main() {
    Employee employee1;
    employee1.setGehalt(50000);
    cout << "Der Gehalt des Mitarbeiters beträgt: " << employee1.getGehalt() << endl;
    return 0;
}

In diesem Beispiel haben wir eine öffentliche Getter-Funktion "getGehalt" in der Klasse "Employee" definiert. Diese Funktion gibt den privaten Member "Gehalt" zurück. Durch die Verwendung der Getter-Funktion erhalten wir Zugriff auf das private Member "Gehalt" und können es im Hauptprogramm verwenden.

4.2 Setter-Funktion

Eine Setter-Funktion wird verwendet, um den Wert einer privaten Membervariable festzulegen. Betrachten wir ein Beispiel:

class Employee {
private:
    double Gehalt;

public:
    void setGehalt(double neuesGehalt) {
        if (neuesGehalt < 0) {
            Gehalt = 0;
        } else {
            Gehalt = neuesGehalt;
        }
    }
};

In diesem Beispiel haben wir eine öffentliche Setter-Funktion "setGehalt" in der Klasse "Employee" definiert. Diese Funktion überprüft den übergebenen Wert und legt das private Member "Gehalt" entsprechend fest. Wenn der übergebene Wert kleiner als 0 ist, wird das Gehalt auf 0 gesetzt. Andernfalls wird das Gehalt auf den übergebenen Wert festgelegt.

5. Konzept der Kapselung

Die Kombination aus privaten Membern und Getter- und Setter-Funktionen ist ein Beispiel für das Konzept der Kapselung. Bei der Kapselung werden die internen Details einer Klasse verborgen, sodass sie nur über die öffentlichen Funktionen zugänglich sind. Dies ermöglicht eine bessere Kontrolle über den Zugriff auf und die Verwendung von Mitgliedern einer Klasse und garantiert eine konsistente und sichere Manipulation der Daten.

6. Beispiel für die Verwendung von Getter- und Setter-Funktionen

Angenommen, wir haben das private Member "Gehalt" in unserer "Employee"-Klasse und möchten sicherstellen, dass negative Gehälter nicht zugewiesen werden. Hier ist ein Beispiel, wie wir Getter- und Setter-Funktionen nutzen können, um dies zu erreichen:

class Employee {
private:
    double Gehalt;

public:
    double getGehalt() {
        return Gehalt;
    }

    void setGehalt(double neuesGehalt) {
        if (neuesGehalt < 0) {
            Gehalt = 0;
        } else {
            Gehalt = neuesGehalt;
        }
    }
};

int main() {
    Employee employee1;
    employee1.setGehalt(-100);
    cout << "Der Gehalt des Mitarbeiters beträgt: " << employee1.getGehalt() << endl;
    return 0;
}

In diesem Beispiel setzen wir das Gehalt des Mitarbeiters mit der Setter-Funktion "setGehalt" auf einen negativen Wert, indem wir "-100" übergeben. Da die Setter-Funktion den übergebenen Wert überprüft und negative Werte auf 0 setzt, erhalten wir, wenn wir den Gehalt mit der Getter-Funktion "getGehalt" abrufen, den Wert 0.

7. Die Rolle privater Memberfunktionen

Private Memberfunktionen sind Funktionen, die nur von anderen Funktionen innerhalb der Klasse aufgerufen werden können. Sie dienen dazu, den internen Ablauf und die Implementierung der Klasse zu verbergen. Dieses Konzept wird als "Information Hiding" bezeichnet.

7.1 Das Konzept der "Information Hiding"

Das Konzept des "Information Hiding" bedeutet, dass wir die internen Details und die Funktionsweise einer Klasse verbergen und nur diejenigen Methoden und Funktionen öffentlich machen, die für die externe Verwendung relevant sind. Durch das Verbergen der internen Implementierung können wir die Klasse sicherer, robuster und flexibler machen.

8. Beispiel für eine private Memberfunktion

Lassen Sie uns ein Beispiel für eine private Memberfunktion betrachten. Angenommen, wir möchten in unserer "Employee"-Klasse eine private Memberfunktion haben, die den Jahresbonus eines Mitarbeiters basierend auf seinem Gehalt berechnet. Hier ist ein Beispiel, wie das aussehen könnte:

class Employee {
private:
    double Gehalt;

    double calculateBonus() {
        return Gehalt * 0.10;
    }

public:
    void printBonus() {
        cout << "Der Mitarbeiter " << Name << " hat einen Bonus in Höhe von " << calculateBonus() << endl;
    }
};

int main() {
    Employee employee1;
    employee1.printBonus();
    return 0;
}

In diesem Beispiel haben wir die private Memberfunktion "calculateBonus", die den Bonus eines Mitarbeiters basierend auf seinem Gehalt berechnet. Die öffentliche Funktion "printBonus" ruft die private Memberfunktion "calculateBonus" auf und gibt den Namen des Mitarbeiters sowie den berechneten Bonus aus.

9. Die Rolle öffentlicher Memberfunktionen

Öffentliche Memberfunktionen sind Funktionen, auf die von außerhalb der Klasse zugegriffen werden kann. Sie liefern die Schnittstelle zur Kommunikation mit der Klasse und ermöglichen es uns, auf die privaten Members und Funktionen zuzugreifen.

9.1 Die Funktion "Print Bonus"

Im vorherigen Beispiel haben wir die öffentliche Memberfunktion "printBonus" gesehen, die den Namen des Mitarbeiters und den Bonus ausgibt. Hier ist der relevante Teil des Codes:

void printBonus() {
    cout << "Der Mitarbeiter " << Name << " hat einen Bonus in Höhe von " << calculateBonus() << endl;
}

Die Funktion "printBonus" verwendet die private Memberfunktion "calculateBonus", um den Bonus zu berechnen. Durch den Aufruf der öffentlichen Funktion "printBonus" können wir den Bonuswert erhalten und anzeigen.

10. Fazit

In diesem Artikel haben wir die Unterschiede zwischen den öffentlichen und privaten Zugriffsspezifiern in C++ gesehen. Öffentliche Zugriffsspezifiere ermöglichen den Zugriff auf Members von außerhalb der Klasse, während private Zugriffsspezifiere den Zugriff auf Members nur innerhalb der Klasse erlauben. Wir haben auch gesehen, wie Getter- und Setter-Funktionen verwendet werden können, um den Zugriff und die Manipulation privater Membervariablen zu verwalten und das Konzept der Kapselung zu implementieren. Darüber hinaus haben wir die Rolle privater Memberfunktionen und das Konzept des "Information Hiding" diskutiert.

【Ressourcen】:

• ChecoPortfolioCourses.com: Hier erhalten Sie Unterstützung beim Erstellen eines eindrucksvollen Portfolios.