C++ Klasse und Objekt mit Beispiel

In der obigen Abbildung haben wir einen Einfamilienhaus-Prototyp. Aus diesem Prototyp haben wir zwei Häuser mit unterschiedlichen Merkmalen erstellt.

Klassendeklaration

In C+ wird eine Klasse mit dem Schlüsselwort class definiert. Darauf sollte der Klassenname folgen. Der Klassenkörper wird dann zwischen geschweiften Klammern {} eingefügt.

Syntax

class class-name
   {
   // data
   // functions
   };

• Der Klassenname ist der Name, der der Klasse zugewiesen werden soll.
• Bei den Daten handelt es sich um die Daten für die Klasse, die normalerweise als Variablen deklariert werden.
• Die Funktionen sind die Klassenfunktionen.

Private und öffentliche Schlüsselwörter

Diese beiden Schlüsselwörter sind Ihnen bestimmt schon einmal begegnet. Sie sind Zugriffsmodifikatoren.

• Zur Alleinbenutzung:

Wenn das Schlüsselwort private zum Definieren einer Funktion oder Klasse verwendet wird, wird es privat. Auf diese kann nur innerhalb der Klasse zugegriffen werden.

• Öffentlichkeit:

Das Schlüsselwort public hingegen macht Daten/Funktionen öffentlich. Diese sind von außerhalb der Klasse zugänglich.

Objektdefinition

Objekte werden aus Klassen erstellt. Klassenobjekte werden auf ähnliche Weise deklariert wie Variablen. Der Klassenname muss beginnen, gefolgt vom Objektnamen. Das Objekt des Klassentyps.

Syntax

class-name object-name;

• Der Klassenname ist der Name der Klasse, aus der ein Objekt erstellt werden soll.
• Der Objektname ist der Name, der dem neuen Objekt zugewiesen werden soll.

Dieser Prozess der Erstellung eines Objekts aus einer Klasse wird als Instanziierung bezeichnet.

Zugreifen auf Datenelemente

Um auf öffentliche Mitglieder einer Klasse zuzugreifen, verwenden wir den Punktoperator (.). Dies sind Mitglieder, die mit dem Modifikator für öffentlichen Zugriff gekennzeichnet sind.

Beispiel 1

#include <iostream>
using namespace std;
class Phone {
public:
	double cost;   
	int slots; 
};
int main() {
	Phone Y6;        
	Phone Y7;        

	Y6.cost = 100.0;
	Y6.slots = 2;

	Y7.cost = 200.0;
	Y7.slots = 2;
	cout << "Cost of Huawei Y6 : " << Y6.cost << endl;
	cout << "Cost of Huawei Y7 : " << Y7.cost << endl;

	cout << "Number of card slots for Huawei Y6 : " << Y6.slots << endl;
	cout << "Number of card slots for Huawei Y7 : " << Y7.slots << endl;

	return 0;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code Erklärung:

1. Binden Sie die iostream-Header-Datei in unseren Code ein, um deren Funktionen nutzen zu können.
2. Einbinden des std-Namespace in unseren Code, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Deklarieren Sie eine Klasse mit dem Namen Phone.
4. Verwenden Sie den Modifikator für den öffentlichen Zugriff, um die Variablen, die wir erstellen möchten, als öffentlich zugänglich zu markieren.
5. Deklarieren Sie die variablen Kosten eines doppelten Datentyps.
6. Deklarieren Sie eine ganzzahlige Variable mit dem Namen slots.
7. Ende des Unterrichtskörpers.
8. Aufruf der Funktion main(). Die Programmlogik sollte in den Hauptteil eingefügt werden.
9. Erstellen Sie ein Objekt mit dem Namen Y6 vom Typ Telefon. Dies wird als Instanziierung bezeichnet.
10. Erstellen Sie ein Objekt mit dem Namen Y7 vom Typ Telefon. Dies wird als Instanziierung bezeichnet.
11. Greifen Sie über das Objekt Y6 auf die Variablen-/Mitgliedskosten der Klasse Phone zu. Der Wert ist auf 100.0 gesetzt. Die Kosten für Y6 sind jetzt auf 100.0 festgelegt.
12. Greifen Sie mit dem Objekt Y6 auf die Variablen-/Mitgliedsslots der Klasse Phone zu. Der Wert ist auf 2 eingestellt. Die Steckplätze für Y6 sind jetzt auf 2 eingestellt.
13. Greifen Sie über das Objekt Y7 auf die Variablen-/Mitgliedskosten der Klasse Phone zu. Der Wert ist auf 200.0 gesetzt. Die Kosten für Y7 sind jetzt auf 200.0 festgelegt.
14. Greifen Sie mit dem Objekt Y7 auf die Variablen-/Mitgliedsslots der Klasse Phone zu. Der Wert ist auf 2 eingestellt. Die Steckplätze für Y7 sind jetzt auf 2 eingestellt.
15. Drucken Sie die Kosten für Y6 zusammen mit anderem Text auf der Konsole aus.
16. Drucken Sie die Kosten für Y7 zusammen mit anderem Text auf der Konsole aus.
17. Drucken Sie die Anzahl der Steckplätze für Y6 zusammen mit anderem Text aus.
18. Drucken Sie die Anzahl der Steckplätze für Y7 zusammen mit anderem Text aus.
19. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
20. Ende des Hauptteils der Funktion main().

Was ist eine Privatklasse?

Auf als privat markierte Klassenmitglieder kann nur durch innerhalb der Klasse definierte Funktionen zugegriffen werden. Außerhalb der Klasse definierte Objekte oder Funktionen können nicht direkt auf solche Mitglieder zugreifen. Auf ein privates Klassenmitglied kann nur über Mitglieds- und Freundfunktionen zugegriffen werden.

Was ist eine geschützte Klasse?

Als geschützt gekennzeichnete Klassenmitglieder haben gegenüber den als privat gekennzeichneten Mitgliedern einen Vorteil. Auf sie kann von Funktionen innerhalb der Klasse ihrer Definition zugegriffen werden. Darüber hinaus kann über abgeleitete Klassen auf sie zugegriffen werden.

Beispiel 2

#include <iostream>
using namespace std;
class ClassA {
public:
	void set_a(int val);
	int get_a(void);

private:
	int a;
};
int ClassA::get_a(void) {
	return a;
}
void ClassA::set_a(int val) {
	a = val;
}
int main() {
	ClassA a;
	a.set_a(20); 
	cout << "Value of a is: " << a.get_a(); 
	return 0;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
2. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse mit dem Namen ClassA.
4. Verwenden Sie den Modifikator für den öffentlichen Zugriff, um das zu erstellende Klassenmitglied als öffentlich zugänglich zu markieren.
5. Erstellen Sie die Funktion set_a(), die einen ganzzahligen Wert val annimmt.
6. Erstellen Sie eine Funktion mit dem Namen get_a().
7. Verwenden Sie den privaten Zugriffsmodifikator, um das zu erstellende Klassenmitglied als privat zugänglich zu markieren.
8. Deklarieren Sie eine Ganzzahlvariable mit dem Namen a.
9. Ende des Unterrichtskörpers.
10. Verwenden Sie den Klassennamen und den Bereichsauflösungsoperator, um auf die Funktion get_a() zuzugreifen. Wir möchten definieren, was die Funktion tut, wenn sie aufgerufen wird.
11. Die Funktion get_a() sollte beim Aufruf den Wert der Variablen a zurückgeben.
12. Ende der Definition der Funktion get_a().
13. Verwenden Sie den Klassennamen und den Bereichsauflösungsoperator, um auf die Funktion set_a() zuzugreifen. Wir möchten definieren, was die Funktion tut, wenn sie aufgerufen wird.
14. Zuweisen des Werts der Variablen val zur Variablen a.
15. Ende der Definition der Funktion set_a().
16. Rufen Sie die Funktion main() auf. Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
17. Erstellen Sie eine Instanz von ClassA und geben Sie ihr den Namen a.
18. Verwenden Sie die obige Klasseninstanz und die Funktion set_a(), um der Variablen a den Wert 20 zuzuweisen.
19. Drucken von Text neben dem Wert der Variablen a auf der Konsole. Der Wert der Variablen a wird durch Aufruf der Funktion get_a() ermittelt.
20. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
21. Ende des Hauptteils der Funktion main().

Beispiel 3

#include <iostream>
using namespace std;
class ParentClass {
protected:
	int value;
};
class ChildClass : public ParentClass {
public:
	void setId(int x) {
		value = x;
	}
	void displayValue() {
	cout << "Value is: " << value << endl;
	}
};
int main() {
	ChildClass c;
	c.setId(21);
	c.displayValue();
	return 0;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
2. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse mit dem Namen ParentClass.
4. Verwenden Sie den Zugriffsmodifikator „geschützt“, um das zu erstellende Klassenmitglied als geschützt zu markieren.
5. Erstellen Sie eine ganzzahlige Variable mit dem Namen value.
6. Ende des Unterrichtskörpers.
7. Erstellen Sie eine neue Klasse mit dem Namen ChildClass, die die ParentClass erbt.
8. Verwenden Sie den geschützten Zugriffsmodifikator, um das zu erstellende Klassenmitglied als für untergeordnete Klassen zugänglich zu markieren.
9. Erstellen Sie die Funktion setId(), die einen ganzzahligen Wert x annimmt.
10. Zuweisen des Werts der Variablen x zum Variablenwert.
11. Ende der Definition der Funktion setId().
12. Erstellen Sie eine Funktion mit dem Namen displayValue().
13. Geben Sie den Wert der Variablen mit dem Namen value zusammen mit anderem Text auf der Konsole aus.
14. Ende des Hauptteils der Funktion displayValue().
15. Ende des Hauptteils der Klasse namens ChildClass.
16. Rufen Sie die Funktion main() auf. Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
17. Erstellen Sie eine Instanz von ChildClass und geben Sie ihr den Namen c.
18. Verwenden Sie die obige Klasseninstanz und die Funktion setId(), um der Variablen x den Wert 21 zuzuweisen.
19. Verwenden Sie die obige Klasseninstanz, um die Funktion namens displayValue() aufzurufen.
20. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
21. Ende des Hauptteils der Funktion main().

Klassenmitgliedsfunktionen

Funktionen helfen uns, Daten zu manipulieren. Klassenmitgliedsfunktionen können auf zwei Arten definiert werden:

• Innerhalb der Klassendefinition
• Außerhalb der Klassendefinition

Wenn eine Funktion außerhalb einer Klassendefinition definiert werden soll, müssen wir den Bereichsauflösungsoperator (::) verwenden. Dieser sollte von den Klassen- und Funktionsnamen begleitet werden.

Beispiel 2

#include <iostream>
#include <string>
using namespace std;
class Guru99
{
public:
	string tutorial_name;
	int id;
	void printname();
	void printid()
	{
		cout << "Tutorial id is: "<< id;
	}
};
void Guru99::printname()
{
	cout << "Tutorial name is: " << tutorial_name;
}
int main() {
	Guru99 guru99;
	guru99.tutorial_name = "C++";
	guru99.id = 1001;
	guru99.printname();
	cout << endl;
	guru99.printid();
	return 0;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Fügen Sie die iostream-Header-Datei in unser Programm ein, um deren Funktionen zu nutzen.
2. Fügen Sie die String-Header-Datei in unser Programm ein, um dessen Funktionen zu nutzen.
3. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
4. Erstellen Sie eine Klasse mit dem Namen Guru99.
5. Verwenden Sie den Modifikator für den öffentlichen Zugriff, um die Klassenmitglieder, die wir erstellen möchten, als öffentlich zugänglich zu markieren.
6. Erstellen Sie eine Zeichenfolgenvariable mit dem Namen „tutorial_name“.
7. Erstellen Sie eine Ganzzahlvariable mit dem Namen id.
8. Erstellen Sie eine Funktion mit dem Namen printname(). Diese Funktion ist nicht in der Klassendefinition definiert.
9. Erstellen Sie eine Funktion mit dem Namen print(). Diese Funktion wird innerhalb der Klassendefinition definiert. Sein Hauptteil wurde innerhalb der Klassendefinition hinzugefügt.
10. Geben Sie den Wert der Variablen-ID zusammen mit anderem Text auf der Konsole aus. Beachten Sie, dass dies im Hauptteil der printid()-Funktion hinzugefügt wurde. Es wird nur ausgeführt, wenn die Funktion printid() aufgerufen wird.
11. Ende des Funktionskörpers printid().
12. Ende des Hauptteils der Klasse Guru99.
13. Der Beginn der Definition der Funktion printname().
14. Geben Sie den Wert der Variablen „tutorial_name“ zusammen mit anderem Text auf der Konsole aus. Beachten Sie, dass dies im Hauptteil der Funktion printname() hinzugefügt wurde. Es wird nur ausgeführt, wenn die Funktion printname() aufgerufen wird.
15. Ende der Definition der Funktion printname().
16. Rufen Sie die Funktion main() auf. Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
17. Erstellen Sie eine Instanz der Klasse Guru99 und geben Sie ihr den Namen guru99.
18. Verwenden Sie die obige Instanz, um einen Wert von zuzuweisen C++ zur Variable tutorial_name.
19. Verwenden Sie die guru99-Instanz, um der Variablen-ID den Wert 1001 zuzuweisen.
20. Verwenden Sie die Instanz guru99, um die Funktion printname() aufzurufen.
21. Rufen Sie den Befehl end (Endzeile) auf, um eine neue Leerzeile auf der Konsole zu drucken.
22. Verwenden Sie die Instanz guru99, um die Funktion printid() aufzurufen.
23. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
24. Ende des Hauptteils der Funktion main().

Konstruktoren und Destruktoren

Was sind Konstruktoren?

Konstrukte sind spezielle Funktionen, die Objekte initialisieren. Der C++ Compiler ruft beim Erstellen eines Objekts einen Konstruktor auf. Die Konstruktoren helfen dabei, Klassenmitgliedern Werte zuzuweisen. Dies geschieht natürlich, nachdem ihnen etwas Speicherplatz zugewiesen wurde.

Was sind Destruktoren?

Destruktoren hingegen helfen dabei, Klassenobjekte zu zerstören.

Der Konstruktorname muss dem Klassennamen ähneln. Konstruktoren haben keinen Rückgabetyp.

Der Konstruktor kann innerhalb oder außerhalb des Klassenkörpers definiert werden. Wenn er außerhalb des Klassenkörpers definiert wird, sollte er mit dem Klassennamen und dem Bereichsauflösungsoperator (::) definiert werden.

Beispiel 3

#include <iostream>  
using namespace std;
class ClassA {
public:
	ClassA() {
		cout << "Class constructor called"<<endl;
	}
	~ClassA() {
		cout << "Class destructor called"<<endl;
	}
};

int main() {
	ClassA a;
	int p = 1;
		if (p) {
			ClassA b; 
		}   
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Fügen Sie die iostream-Headerdatei in den Code ein, um ihre Funktionen zu nutzen.
2. Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
3. Erstellen Sie eine Klasse mit dem Namen ClassA.
4. Verwenden Sie den Modifikator für den öffentlichen Zugriff, um das Mitglied, das wir erstellen möchten, als öffentlich zugänglich zu markieren.
5. Erstellen Sie einen Konstruktor für die Klasse.
6. Text, der auf der Konsole ausgegeben wird, wenn der Konstruktor aufgerufen wird. Das endl ist ein C++ Schlüsselwort, das Zeilenende bedeutet. Es bewegt den Mauszeiger zur nächsten Zeile.
7. Ende des Hauptteils des Klassenkonstruktors.
8. Erstellen Sie einen Destruktor für die Klasse.
9. Text, der auf der Konsole ausgegeben wird, wenn der Destruktor aufgerufen wird. Das Endl ist ein C++ Schlüsselwort, das Zeilenende bedeutet. Es bewegt den Mauszeiger zur nächsten Zeile.
10. Ende des Körpers des Destruktors.
11. Ende des Unterrichtskörpers.
12. Rufen Sie die Funktion main() auf. Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden.
13. Erstellen Sie ein Klassenobjekt und geben Sie ihm den Namen a. Der Konstruktor wird aufgerufen.
14. Erstellen Sie eine ganzzahlige Variable mit dem Namen p und weisen Sie ihr den Wert 1 zu.
15. Erstellen Sie einen if-Anweisungsblock mit der Variablen p.
16. Erstellen Sie ein Klassenobjekt und geben Sie ihm den Namen b. Der Destruktor wird aufgerufen.
17. Ende des Hauptteils der if-Anweisung.
18. Ende des Hauptteils der main()-Funktion.

Zusammenfassung

• C++ ist objektorientiert.
• Klassen bilden die Hauptmerkmale von C++ die es objektorientiert machen.
• A C++ Klasse kombiniert Daten und Methoden zur Manipulation der Daten zu einer Einheit.
• Eine Klasse ist eine Blaupause für ein Objekt.
• Klassen bestimmen die Form eines Objekts.
• Die in einer Klasse enthaltenen Daten und Methoden werden als Klassenmitglieder bezeichnet.
• Um auf Klassenmitglieder zuzugreifen, sollten Sie eine Instanz der Klasse verwenden.
• Um eine Klasse zu erstellen, verwenden wir das Schlüsselwort class.
• Die Klassenmitgliedsfunktionen können innerhalb oder außerhalb einer Klasse definiert werden.