C++ Klasse und Objekt mit Beispiel

Was ist eine Klasse?

Eine C++-Klasse kombiniert Daten und Methoden zum Bearbeiten der Daten zu einer Klasse. Klassen bestimmen auch die Formen von Objekten. Die in einer Klasse enthaltenen Daten und Methoden werden als Klassenmitglieder bezeichnet. Eine Klasse ist ein benutzerdefinierter Datentyp. Um auf die Klassenmitglieder zuzugreifen, verwenden wir eine Instanz der Klasse. Sie können eine Klasse als Blaupause für ein Objekt sehen.

Eine Klasse sei ein Prototyp für ein Haus. Es zeigt die Position und Größe von Türen, Fenstern, Fußböden usw. Aus diesen Beschreibungen können wir ein Haus bauen. Das Haus wird zum Objekt. Aus dem Prototyp lassen sich viele Häuser bauen. Außerdem ist es möglich, viele Objekte aus einer Klasse zu erstellen.

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

In diesem Tutorial lernen Sie:

Was ist eine Klasse?
Klassenbeispiel
Private und öffentliche Schlüsselwörter
Objektdefinition
Zugriff auf Datenelemente
Klassenmitgliedsfunktionen
Konstruktoren und Destruktoren

Klassenerklärung

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

Syntax:

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

Der Klassenname ist der Name, der der Klasse zugewiesen wird.
Die Daten sind die Daten für die Klasse, normalerweise als Variablen deklariert.
Die Funktionen sind die Klassenfunktionen.

Private und öffentliche Schlüsselwörter

Auf diese beiden Stichworte müssen Sie gestoßen sein. Sie sind Zugriffsmodifikatoren.

Privat:

Wenn das Schlüsselwort private zum Definieren einer Funktion oder Klasse verwendet wird, wird es privat. Diese sind nur innerhalb der Klasse zugänglich.

Öffentlich:

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 wie Variablen deklariert. 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.

Zugriff auf Datenmitglieder

Um auf öffentliche Mitglieder einer Klasse zuzugreifen, verwenden wir den (.)Punktoperator. Dies sind Mitglieder, die mit dem Modifikator für den ö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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung :

Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
Den std-Namespace in unseren Code aufnehmen, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Deklarieren Sie eine Klasse namens Phone.
Verwendung des Modifikators für öffentlichen Zugriff, um die Variablen, die wir gerade erstellen, als öffentlich zugänglich zu markieren.
Deklarieren Sie die variablen Kosten eines doppelten Datentyps.
Deklarieren Sie eine Integer-Variable namens Slots.
Ende des Klassenhauptteils.
Aufruf der main()-Funktion. Die Programmlogik sollte in seinen Körper eingefügt werden.
Erstellen Sie ein Objekt namens Y6 vom Typ Telefon. Dies wird Instanziierung genannt.
Erstellen Sie ein Objekt namens Y7 vom Typ Telefon. Dies wird Instanziierung genannt.
Greifen Sie mit dem Objekt Y6 auf die Variablen/Elementkosten der Klasse Phone zu. Der Wert wird auf 100,0 gesetzt. Die Kosten von Y6 sind jetzt auf 100,0 festgelegt.
Greifen Sie mit dem Objekt Y6 auf die Variablen/Member-Slots der Klasse Phone zu. Der Wert wird auf 2 gesetzt. Die Slots für Y6 werden jetzt auf 2 gesetzt.
Greifen Sie mit dem Objekt Y7 auf die Variablen/Elementkosten der Klasse Telefon zu. Der Wert wird auf 200,0 gesetzt. Die Kosten von Y7 sind jetzt auf 200,0 festgelegt.
Greifen Sie mit dem Objekt Y7 auf die Variablen/Member-Slots der Klasse Phone zu. Der Wert wird auf 2 gesetzt. Die Slots für Y7 werden jetzt auf 2 gesetzt.
Drucken Sie die Kosten von Y6 auf der Konsole neben anderem Text.
Drucken Sie die Kosten von Y7 auf der Konsole neben anderem Text.
Drucken Sie die Anzahl der Slots für Y6 neben anderem Text.
Drucken Sie die Anzahl der Slots für Y7 neben anderem Text.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

Was ist ein Privatunterricht?

Auf als privat gekennzeichnete 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 wird nur durch Mitglieder- und Freundfunktionen zugegriffen.

Was ist eine geschützte Klasse?

Als geschützt markierte Klassenmitglieder haben einen Vorteil gegenüber den als privat markierten. Auf sie kann von Funktionen innerhalb der Klasse ihrer Definition zugegriffen werden. Außerdem kann von abgeleiteten 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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Erstellen Sie eine Klasse namens ClassA.
Verwenden Sie den öffentlichen Zugriffsmodifikator, um das zu erstellende Klassenmitglied als öffentlich zugänglich zu markieren.
Erstellen Sie die Funktion namens set_a(), die einen ganzzahligen Wert val akzeptiert.
Erstellen Sie eine Funktion namens get_a().
Verwenden Sie den privaten Zugriffsmodifikator, um das zu erstellende Klassenmitglied als privat zugänglich zu markieren.
Deklarieren Sie eine Integer-Variable namens a.
Ende des Klassenhauptteils.
Verwenden Sie den Klassennamen und den Bereichsauflösungsoperator, um auf die Funktion get_a() zuzugreifen. Wir wollen definieren, was die Funktion tut, wenn sie aufgerufen wird.
Die Funktion get_a() sollte beim Aufruf den Wert der Variablen a zurückgeben.
Ende der Definition der Funktion get_a().
Verwenden Sie den Klassennamen und den Bereichsauflösungsoperator, um auf die Funktion set_a() zuzugreifen. Wir wollen definieren, was die Funktion tut, wenn sie aufgerufen wird.
Zuweisung des Wertes der Variablen val an die Variable a.
Ende der Definition der Funktion set_a().
Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Erstellen Sie eine Instanz von ClassA und geben Sie ihr den Namen a.
Verwenden Sie die obige Klasseninstanz und die Funktion set_a(), um der Variablen a den Wert 20 zuzuweisen.
Einen Text neben dem Wert der Variablen a auf der Konsole ausgeben. Der Wert der Variablen a wird durch Aufrufen der Funktion get_a() ermittelt.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Fügen Sie die iostream-Header-Datei in unseren Code ein, um ihre Funktionen zu nutzen.
Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Erstellen Sie eine Klasse namens ParentClass.
Verwenden Sie den Zugriffsmodifikator protected, um das zu erstellende Klassenmitglied als geschützt zu markieren.
Erstellen Sie eine Integer-Variable namens value.
Ende des Klassenhauptteils.
Erstellen Sie eine neue Klasse namens ChildClass, die die ParentClass erbt.
Verwenden Sie den Zugriffsmodifikator protected, um das zu erstellende Klassenmitglied als für untergeordnete Klassen zugänglich zu markieren.
Erstellen Sie die Funktion namens setId(), die einen ganzzahligen Wert x annimmt.
Variablenwert den Wert der Variablen x zuweisen.
Ende der Definition der Funktion setId().
Erstellen Sie eine Funktion namens displayValue().
Drucken Sie den Wert der Variablen mit dem Namen value auf der Konsole zusammen mit anderem Text.
Ende des Hauptteils der Funktion displayValue().
Ende des Hauptteils der Klasse mit dem Namen ChildClass.
Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Erstellen Sie eine Instanz von ChildClass und geben Sie ihr den Namen c.
Verwenden Sie die obige Klasseninstanz und die Funktion setId(), um der Variablen x den Wert 21 zuzuweisen.
Verwenden Sie die obige Klasseninstanz, um die Funktion namens displayValue() aufzurufen.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

Klassenmitgliedsfunktionen

Funktionen helfen uns, Daten zu manipulieren. Klassenelementfunktionen 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. Dies 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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Fügen Sie die iostream-Header-Datei in unser Programm ein, um ihre Funktionen zu nutzen.
Fügen Sie die String-Header-Datei in unser Programm ein, um seine Funktionen zu nutzen.
Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Erstellen Sie eine Klasse namens Guru99.
Verwenden Sie den Modifikator für den öffentlichen Zugriff, um die Klassenmitglieder, die wir gerade erstellen, als öffentlich zugänglich zu markieren.
Erstellen Sie eine String-Variable mit dem Namen tutorial_name.
Erstellen Sie eine Integer-Variable namens id.
Erstellen Sie eine Funktion namens printname(). Diese Funktion ist nicht in der Klassendefinition definiert.
Erstellen Sie eine Funktion namensprinted(). Diese Funktion wird innerhalb der Klassendefinition definiert. Sein Körper wurde innerhalb der Klassendefinition hinzugefügt.
Den Wert der Variablen id zusammen mit anderem Text auf der Konsole ausgeben. Beachten Sie, dass dies im Hauptteil der Funktion printid() hinzugefügt wurde. Sie wird nur ausgeführt, wenn die Funktion printid() aufgerufen wird.
Ende des Hauptteils der Funktion printid().
Ende des Körpers der Klasse Guru99.
Beginn der Definition der Funktion printname().
Den Wert der Variablen tutorial_name auf der Konsole zusammen mit anderem Text ausgeben. Beachten Sie, dass dies im Hauptteil der Funktion printname() hinzugefügt wurde. Sie wird nur ausgeführt, wenn die Funktion printname() aufgerufen wird.
Ende der Definition der Funktion printname().
Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Erstellen Sie eine Instanz der Klasse Guru99 und geben Sie ihr den Namen guru99.
Verwenden Sie die obige Instanz, um der Variablen tutorial_name einen Wert von C++ zuzuweisen.
Verwenden Sie die guru99-Instanz, um der Variablen-ID den Wert 1001 zuzuweisen.
Verwenden Sie die Instanz guru99, um die Funktion printname() aufzurufen.
Rufen Sie den Befehl end (end line) auf, um eine neue leere Zeile auf der Konsole auszugeben.
Verwenden Sie die Instanz guru99, um die Funktion printid() aufzurufen.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

Konstruktoren und Destruktoren

Was sind Konstruktoren?

Konstrukte sind spezielle Funktionen, die Objekte initialisieren. Die C++-Compiler rufen 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 ähnlich sein. Konstruktoren haben keinen Rückgabetyp.

Der Konstruktor kann innerhalb oder außerhalb des Klassenkörpers definiert werden. Wenn sie außerhalb des Klassenkörpers definiert wird, sollte sie 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; 
		}   
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Fügen Sie die iostream-Header-Datei in den Code ein, um ihre Funktionen zu nutzen.
Fügen Sie den std-Namespace in unseren Code ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Erstellen Sie eine Klasse namens ClassA.
Verwenden Sie den Modifizierer für öffentlichen Zugriff, um das Mitglied, das wir gerade erstellen, als öffentlich zugänglich zu markieren.
Erstellen Sie einen Konstruktor für die Klasse.
Text, der auf der Konsole ausgegeben wird, wenn der Konstruktor aufgerufen wird. endl ist ein C++-Schlüsselwort, was Endzeile bedeutet. Es bewegt den Mauszeiger in die nächste Zeile.
Ende des Hauptteils des Klassenkonstruktors.
Erstellen Sie einen Destruktor für die Klasse.
Text, der auf der Konsole ausgegeben wird, wenn der Destruktor aufgerufen wird. endl ist ein C++-Schlüsselwort, was Endzeile bedeutet. Es bewegt den Mauszeiger in die nächste Zeile.
Ende des Körpers des Destruktors.
Ende des Klassenhauptteils.
Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden.
Erstellen Sie ein Klassenobjekt und geben Sie ihm den Namen a. Der Konstruktor wird aufgerufen.
Erstellen Sie eine Integer-Variable namens p und weisen Sie ihr den Wert 1 zu.
Erstellen Sie einen if-Anweisungsblock mit der Variablen p.
Erstellen Sie ein Klassenobjekt und geben Sie ihm den Namen b. Der Destruktor wird aufgerufen.
Ende des Hauptteils der if-Anweisung.
Ende des Hauptteils der main()-Funktion.

Zusammenfassung:

C++ ist objektorientiert.
Klassen bilden die Hauptmerkmale von C++, die es objektorientiert machen.
Eine C++-Klasse kombiniert Daten und Methoden zur Bearbeitung der Daten zu einer Klasse.
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 Klassenmitgliederfunktionen können innerhalb oder außerhalb einer Klasse definiert werden.

Karte in C++ Standard Template Library (STL) mit Druckbeispiel C++ Polymorphismus mit Beispiel

C Sprache