Initialisierungsliste von Konstruktor, statischen Mitgliedern, Freunden, inneren Klassen [Klassen und Objekte (Teil 2)]

Initialisierungsliste von Konstruktoren, statischen Mitgliedern, Freunden und inneren Klassen [Klassen und Objekte (Teil 2)]

2024-07-12

PS: Der folgende Code wurde in der VS2022-Umgebung getestet, was nicht bedeutet, dass alle Compiler ihn bestehen können. PS: Keiner der Testcodes zeigt die Deklaration der Header-Datei stdio.h. Bitte fügen Sie sie selbst hinzu, wenn Sie sie verwenden.

Fügen Sie hier eine Bildbeschreibung ein

                        Blogger-Homepage: LiUEEEEE
                          C++-Spalte
                        C-Sprachspalte
                       Spalte „Datenstruktur“.
                       Spalte „Sortieralgorithmus“.
                      Kolumne zu klassischen Themen von Niuke

Inhaltsverzeichnis

1. Initialisierungsliste des Konstruktors
2. explizites Schlüsselwort
3. Statische Mitglieder
- 3.1 statisches Elementkonzept
- 3.2 Eigenschaften statischer Elemente
4. Youyuan
- 4.1 Friend-Funktionen
- 4.2 Freundesklassen
5. Interne Klasse
6. Fazit

1. Initialisierungsliste des Konstruktors

1.1 Rückblick auf den Konstrukteur

In meinem vorherigen Blog

Konstruktion, Zerstörung, Kopieren [Klassen und Objekte (Teil 2)]
Der Konstruktor der Klasse wird in erwähnt. Am Beispiel der Datumsklasse lautet die Initialisierungsmethode wie folgt:

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Wie im obigen Code gezeigt, werden Benutzer ohne weitere C++-Studien normalerweise denken, dass der Code im Konstruktor die Initialisierung von Klassenmitgliedsvariablen ist, aber die Tatsache ist genau das Gegenteil. In C++ wird die Hauptanweisung des Konstruktors nur initialisiert Die Zuweisung kann nicht als Initialisierung im eigentlichen Sinne bezeichnet werden, da die Initialisierung nur einmal initialisiert werden kann, während der Konstruktor den Elementvariablen mehrmals Werte zuweisen kann, zum Beispiel:

	Date(int year, int month, int day)
	{
		_year = year;
		_year += 1;
	}
1
2
3
4
5

1.2 Initialisierungsliste

Zu diesem Zeitpunkt wird die Initialisierungsliste in C++ eingeführt.
Die Initialisierungsliste ist eine Liste von Datenelementen, die mit „:“ (Doppelpunkt) beginnen und durch „“, (Komma) getrennt werden. Auf jede Elementvariable folgt eine Klammer, und der in der Klammer platzierte Wert ist beispielsweise der initialisierte Wert :

	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
1
2
3
4
5

was man beachten muss ist:

Jede Mitgliedsvariable kann nur einmal in der Initialisierungsliste erscheinen (die Initialisierung kann nur einmal initialisiert werden).
Die Klasse enthält die folgenden Mitglieder, die zur Initialisierung in die Initialisierungsliste eingefügt werden müssen:
- Verweisen Sie auf Mitgliedsvariablen
- Mitgliedsvariablen des benutzerdefinierten Typs (und der benutzerdefinierte Typ verfügt nicht über einen Standardkonstruktor: einen parameterlosen Konstruktor, einen vollständig standardmäßigen Konstruktor, einen vom System automatisch generierten Konstruktor)
- const modifizierte Mitgliedsvariablen

Die oben genannten benutzerdefinierten Mitgliedsvariablen (ohne Standardkonstruktor) bedeuten, dass der Konstruktor der definierten benutzerdefinierten Mitgliedsvariablen ein Konstruktor mit Parametern ist und Parameter übergeben werden müssen, bevor er initialisiert werden kann. Wenn der Benutzer den Konstruktor anzeigt, wenn die Initialisierung erfolgt Wenn die Liste nicht geschrieben wird, generiert der Compiler sie automatisch für den Benutzer. Wenn für die Initialisierung benutzerdefinierter Mitgliedsvariablen jedoch Parameter erforderlich sind, übergibt das System die Parameter standardmäßig nicht, was zu einer Nichtinitialisierung führt um eine Nichtinitialisierungssituation zu vermeiden und unnötige Probleme bei der späteren Verwendung zu vermeiden.

1.3 Tipps zur Initialisierungsliste

Beim Schreiben der Initialisierungsliste muss die Initialisierungsreihenfolge der Mitgliedsvariablen mit der Deklarationsreihenfolge in der Klasse übereinstimmen, da der Compiler die Variablen der Reihe nach gemäß der Deklarationsreihenfolge initialisiert. Wenn der Benutzer nicht in der Reihenfolge schreibt, führt dies dazu unnötiger Ärger, wie zum Beispiel:

class A
{
public:
	A(int n)
		:_a2(n)
		,_a1(_a2)
	{}
	void Print()
	{
		cout << "_a1 = " << _a1 << endl;
		cout << "_a2 = " << _a2 << endl;
	}
private:
	int _a1;
	int _a2;
};

int main()
{
	A aa(100);
	aa.Print();

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Fügen Sie hier eine Bildbeschreibung ein
Bei der Initialisierung wie in der obigen Abbildung gezeigt werden Ergebnisse erzielt, die nicht den Erwartungen entsprechen. Daher müssen solche Vorgänge bei der Verwendung vermieden werden.

2. explizites Schlüsselwort

Für den Konstruktor gibt es auch eine eigene FunktionEinzelparameter-KonstruktoroderKonstruktor mit mehreren Parametern, aber ohne Standardwert für den ersten ParameterImplizite Typkonvertierung, zum Beispiel:

class Date
{
public:
	Date(int year)
		: _year(year)
	{}
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Date
{
public:
	Date(int year, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Bei der Zuweisung durch Übergabe eines Werts, zum Beispiel:

	Date date(2024);
1

Auf Compilerebene wird 2024 nicht direkt dem erstellten Klassenobjekt zugewiesen, sondern 2024 wird durch implizite Konvertierung in ein temporäres Klassenobjekt umgewandelt und dann dem Klassenobjekt zugewiesen, das über ein solches Objekt initialisiert werden muss ist notwendig Das initialisierte Klassenobjekt ist A und das temporäre Klassenobjekt ist B:

	Date A(2024);
	等价于
	Date A = B//B的值为2024
1
2
3

Um eine implizite Konvertierung zu vermeiden, hat C++ das Schlüsselwort „explicit“ erstellt. Durch das Hinzufügen von „explicit“ vor dem Konstruktor kann eine implizite Konvertierung verhindert werden, zum Beispiel:

	explicit Date(int year)
		: _year(year)
	{}
1
2
3

3. Statische Mitglieder

3.1 statisches Elementkonzept

Als statisch deklarierte Klassenmitglieder werden als statische Mitglieder der Klasse bezeichnet. Mit Statik geänderte Mitgliedsvariablen werden als statische Mitgliedsvariablen bezeichnet. Statische Mitgliedsvariablen müssen außerhalb der Klasse initialisiert werden, zum Beispiel:

class Date
{
public:
	Date(int year, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
	static int _i;
};

int Date::_i = 1;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.2 Eigenschaften statischer Elemente

Statische Mitglieder werden von allen Klassenobjekten gemeinsam genutzt und gehören nicht zu einem bestimmten Objekt. Sie werden im statischen Bereich gespeichert.
Statische Mitgliedsvariablen müssen außerhalb der Klasse definiert werden. Das Schlüsselwort static wird beim Definieren nicht hinzugefügt.
Auf statische Klassenmitglieder kann über das Klassenname::static-Mitglied oder das object.static-Mitglied zugegriffen werden
Statische Memberfunktionen haben diesen Zeiger nicht ausgeblendet und können nicht auf nicht statische Member zugreifen.
Statische Mitglieder sind ebenfalls Mitglieder der Klasse und werden durch öffentliche, geschützte und private Zugriffsqualifizierer eingeschränkt.

4. Youyuan

Freunde bieten eine Möglichkeit, die Kapselung zu durchbrechen, und bieten manchmal auch Bequemlichkeit. Allerdings erhöhen Freunde die Kopplung und zerstören die Kapselung, daher sollten Freunde nicht mehr als einmal verwendet werden.

Freunde werden unterteilt in: Freundesfunktionen und Freundesklassen

4.1 Friend-Funktionen

Eine Friend-Funktion bedeutet, dass, wenn eine Funktion außerhalb der Klasse auf ein privates Mitglied der Klasse zugreifen muss, darauf zugegriffen werden kann, indem diese Funktion in der Klasse als Friend-Funktion der Klasse deklariert wird, zum Beispiel:

class Date
{
	friend void Print(Date& d);
public:
	Date(int year = 1, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
void Print(Date& d)
{
	cout << d._year << " " << d._month << " " << d._day <<endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Friend-Funktionen können auf private und geschützte Mitglieder einer Klasse zugreifen, jedoch nicht auf Mitgliedsfunktionen der Klasse
Friend-Funktionen können nicht mit const geändert werden
Friend-Funktionen können an einer beliebigen Stelle in einer Klassendefinition deklariert werden und sind nicht durch Klassenzugriffsqualifizierer eingeschränkt.
Eine Funktion kann eine Friend-Funktion mehrerer Klassen sein
Das Prinzip beim Aufrufen von Friend-Funktionen ist das gleiche wie bei gewöhnlichen Funktionen.

4.2 Freundesklassen

Wenn eine Klasse auf die privaten Mitglieder einer anderen Klasse zugreifen möchte, kann sie diese Klasse als Freund in der Klasse deklarieren, auf die zugegriffen werden muss, und dann auf deren private Mitglieder zugreifen, zum Beispiel:

class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类
					   //中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
			: _hour(hour)
			, _minute(minute)
			, _second(second)
	{}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
			: _year(year)
			, _month(month)
			, _day(day)
	{}	
	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

Freundschaftsbeziehungen sind einseitig und nicht kommutativ. Wenn Sie beispielsweise in der oben genannten Time-Klasse und Date-Klasse die Date-Klasse als ihre Freundklasse in der Time-Klasse deklarieren, können Sie direkt auf die privaten Mitgliedsvariablen der Time-Klasse in der Date-Klasse zugreifen, möchten dies jedoch tun Greifen Sie auf die privaten Mitgliedsvariablen der Date-Klasse in der Time-Klasse zu.
Die Freundschaftsbeziehung kann nicht transitiv sein. Wenn C ein Freund von B und B ein Freund von A ist, kann das nicht bedeuten, dass C ein Freund von A ist.

5. Interne Klasse

C++ unterstützt die Erstellung einer weiteren Klasse innerhalb einer Klasse, die als innere Klasse bezeichnet wird. Sie gehört nicht zur äußeren Klasse und auf die Mitglieder der inneren Klasse kann nicht über die Objekte der äußeren Klasse zugegriffen werden . Die äußere Klasse hat keinen übergeordneten Zugriff auf die innere Klasse.
Und die innere Klasse ist natürlich ein Freund der äußeren Klasse, das heißt, die innere Klasse kann auf die privaten Mitglieder der äußeren Klasse zugreifen.

charakteristisch:

Innere Klassen können in externen Klassen als öffentlich, geschützt oder privat definiert werden.
Beachten Sie, dass innere Klassen direkt auf statische Elemente in äußeren Klassen zugreifen können, ohne dass der Objekt-/Klassenname der äußeren Klasse erforderlich ist.
sizeof(external class)=external class, hat nichts mit internen Klassen zu tun.

6. Fazit