Menu

Tech

Deutsch

Attribute (Datenmember)

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

Datenmember (Attribute) speichern den Zustand eines Objekts. Sie werden typischerweise als private deklariert und über öffentliche Getter-/Setter-methods aufgerufen. Dies wird als Kapselung bezeichnet.

Private Datenmember

class BankAccount {
private:
    std::string accountName;
    int balance;
};

Öffentliche Getter und Setter

class BankAccount {
private:
    std::string accountName;
    int balance;

public:
    void setBalance(int balance) {
        this->balance = balance;
    }
    
    int getBalance() {
        return this->balance;
    }
};

Setter mit Validierung

void BankAccount::setBalance(int balance) {
    if (balance >= 0) {
        this->balance = balance;
    }
}

Zugriffsbezeichner

class MyClass {
private:    // Nur innerhalb der Klasse zugänglich
    int secret;

public:     // Von überall zugänglich
    int getSecret() { return secret; }

protected:  // In der Klasse und in Unterklassen zugänglich
    int shared;
};

Wenn Datenmitglieder private gemacht werden, werden sie vor externem Code verborgen. Getter geben ihre Werte zurück, Setter ändern sie mit optionaler Validierung. Dadurch werden deine Daten geschützt und der Zugriff darauf kontrolliert.

Aufgabe

Mittel

Erstelle eine BankAccount-Klasse mit privaten Datenelementen und öffentlichen Zugriffsmethoden:

Private Member: accountName (String), balance (int)
Setter: setAccountName, setBalance
Getter: getAccountName, getBalance
deposit(int amount): erhöht den Kontostand, wenn amount > 0 ist
withdraw(int amount): gibt „Success“ zurück, wenn dies möglich ist, andernfalls „Insufficient funds“

Probier es selbst

#include <iostream>
#include "BankAccount.h"

int main() {
    std::string name;
    int initial, depositAmt;
    std::getline(std::cin, name);
    std::cin >> initial >> depositAmt;
    
    BankAccount account;
    account.setAccountName(name);
    account.setBalance(initial);
    
    std::cout << "Account: " << account.getAccountName() << std::endl;
    std::cout << "Balance: " << account.getBalance() << std::endl;
    
    account.deposit(depositAmt);
    std::cout << "After deposit: " << account.getBalance() << std::endl;
    
    std::string result = account.withdraw(2000);
    std::cout << "Withdraw 2000: " << result << std::endl;
    std::cout << "Final Balance: " << account.getBalance() << std::endl;
    return 0;
}

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Objektorientierte Programmierung

1Grundlagen der OOP

Externe Dateien C++ Build & Kompilierung Header-Dateien & Quelldateien Namespaces & Gültigkeitsbereich Einführung in OOP mit C++Klassen vs. Objekte Der „this“-Zeiger Methoden (Member-Funktionen)Attribute (Datenmember)Grundlagen zu Ctors & Dtors Rückblick – Einfacher Taschenrechner

4Klassenattribute

Instanz- vs. statische Member Getter und Setter Const-Memberfunktionen Mutable-Schlüsselwort Statische Methoden und Variablen Friend-Funktionen und -Klassen Zusammenfassung – Bankkontoverwaltung

7Vererbung

Grundlagen der Vererbung Zugriffsebenen bei der Vererbung Aufrufreihenfolge von Ctor & Dtor Überschreiben von Methoden Virtuelle Funktionen & VTable Mehrfachvererbung Virtuelle Vererbung Rückblick – Mitarbeiterhierarchie

10STL-Übersicht

STL-Übersicht & Philosophie STL-Container Iteratoren STL-Algorithmen Funktoren & Lambda-Ausdrücke Rückblick – Worthäufigkeit

13Entwurfsmuster Teil 1

Einführung in Entwurfsmuster Singleton-Muster Factory und Abstract Factory Builder-Muster Beobachter-Muster Strategie-Muster

2Speicherverwaltung

Stack- vs. Heap-Speicher Zeiger und Referenzen Dynamischer Speicher (new/delete)Intelligente Zeiger in C++RAII in C++Rückblick – Dynamischer Array-Manager

5Kapselung

Zugriffsbezeichner in C++Zugriffsbezeichner im Detail Informationsverbergung Struct vs. Klasse Verschachtelte und innere Klassen Wiederholung – Studierendenverwaltungssystem

8Polymorphie

Polymorphie zur Compilezeit vs. Laufzeit Funktionsüberladung Virtuelle Funktionen erneut betrachtet Rein virtuelle Funktionen Abstrakte Klassen Interface-Design in C++Dynamic Casting & RTTI Rückblick – Shape-Calculator

11Fortgeschrittene OOP-Konzepte

Komposition vs. Vererbung Mixins mittels CRTP Pimpl-Idiom Typlöschung Enum-Klassen & starke Typisierung Ausnahmebehandlung in OOP Benutzerdefinierte Ausnahmehierarchien

14Entwurfsmuster Teil 2

Befehlsmuster Adaptermuster Dekorierermuster Template-Method-Muster Zustandsmuster Kompositmuster RAII als Muster

3Konstruktoren & Destruktoren

Standardkonstruktor Parametrisierter Konstruktor Kopierkonstruktor Move-Konstruktor Konstruktor-Initialisierungslisten Delegierende Konstruktoren Destruktor im Detail Drei-/Fünf-/Null-Regel Zusammenfassung – String-Klasse

6Operatorüberladung

Einführung in die Operatorüberladung Arithmetische Operatorüberladung Vergleichsoperatorüberladung Stream-Operatoren Zuweisungsoperatorüberladung Überladung der Operatoren [] und ()Typkonvertierungsoperatoren Wiederholung – Matrix-Klasse

9Templates

Funktionstemplates Klassen-Templates Template-Spezialisierung Variadische Templates Grundlagen zu SFINAE und Type Traits Rückblick – Generischer Container

12Moderne C++-Funktionen

Move-Semantik & Rvalues Perfektes Forwarding Lambda-Ausdrücke im Detail std::function & std::bind constexpr und consteval Strukturierte Bindungen optional, variant, any

15Abschließende Herausforderungen

E-Learning-Plattform Bankensystem

Übe selbstständig: Online-C++-Compiler