C-Grundlagen (2)_developdoc

C-Grundlagen (2)

2024-07-12

Inhaltsverzeichnis

1. Klassen und Objekte

1.1 Klassendefinition

1.2 Zugangsqualifikationen

1.3 Klassendomäne

2. Instanziierung

2.1 Instanziierungskonzept

2.2 Objektgröße

3.Dieser Zeiger

4.Standard-Memberfunktionen von Klassen

4.1Konstrukteur

4.2 Destruktor

4.5 Überlastung des Bedieners

1. Klassen und Objekte

1.1 Klassendefinition

Klassendefinitionsformat

class ist das Schlüsselwort, das die Klasse definiert, Stack ist der Name der Klasse und {} ist der Hauptteil der Klasse. Beachten Sie, dass das Semikolon am Ende der Definition nicht weggelassen wird. Die Inhalte im Klassenkörper werden als Mitglieder der Klasse bezeichnet: Variablen in der Klasse werden als Attribute oder Mitgliedsvariablen der Klasse bezeichnet; Funktionen in der Klasse werden als Methoden oder Mitgliedsfunktionen der Klasse bezeichnet.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
	//成员变量
	int* a;
	int top;
	int  capacity;
	//成员函数
	void Push()
	{
 
	}
	void Pop()
	{
 
	}
};//分号不能省略
int main()
{
	
 
	return 0;
}

Um Mitgliedsvariablen zu unterscheiden, ist es im Allgemeinen üblich, der Mitgliedsvariablen eine spezielle Kennung hinzuzufügen, z. B. beginnend mit _ oder m_ vor oder nach der Mitgliedsvariablen.Für diese C++-Syntax gibt es keine Vorschriften, sie ist lediglich eine Frage der persönlichen oder geschäftlichen Präferenz.


//为区分成员变量，一般前面加_
//成员变量
int* _a;
int _top;
int  _capacity;

Struct in C++ kann auch Klassen definieren. Gleichzeitig wurde struct zu einer Klasse erweitert. Unter normalen Umständen können wir auch Funktionen definieren Ich empfehle weiterhin, Klassen zum Definieren von Klassen zu verwenden.

In einer Klasse definierte Mitglieder sind standardmäßig inline

1.2 Zugangsqualifikationen

C++ ist eine Möglichkeit, die Kapselung zu implementieren, indem Klassen verwendet werden, um die Eigenschaften und Methoden eines Objekts zu kombinieren, um das Objekt vollständiger zu machen und seine Schnittstelle über Zugriffsrechte selektiv externen Benutzern bereitzustellen.

Auf durch public (public) geänderte Mitglieder kann außerhalb der Klasse direkt zugegriffen werden, durch protected (protected) und private (private) geänderte Mitglieder können außerhalb der Klasse nicht direkt zugegriffen werden, protected und private sind dasselbe
Der Zugriffsberechtigungsbereich beginnt an der Position, an der die Zugriffsberechtigung angezeigt wird, bis zum Erscheinen des nächsten Zugriffsqualifizierers. Wenn kein nachfolgender Zugriffsqualifizierer vorhanden ist, endet der Bereich bei }, dem Ende der Klasse.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
	
	///
 
	void Push()
	{
 
	}
	//Push 没给限定符 class默认私有 private 
	///
public:
	void Pop()
	{
 
	}
	int Swap()
	{
 
	}
	//Pop和Swap 被public修饰，直到下一个限定符出现之前都为公有
	///
protected:
	int add();
//add 被public修饰，直到下一个限定符出现之前都为保护
/// /
 
private:
 
	int* _a;
	int _top;
	int  _capacity;
//成员变量被private修饰，直到}结束都为私有
};
int main()
{
	Stack st;
	//公有可以访问
	st.Pop();
	st.Swap();
	//私有不可访问
	st._top;
 
 
 
	return 0;
}

Zusätzliche Bemerkungen:

Wenn Klassendefinitionsmitglieder nicht durch Zugriffsqualifizierer geändert werden, sind sie standardmäßig „privat“ und die Struktur standardmäßig „öffentlich“.
Im Allgemeinen werden Mitgliedsvariablen auf privat/geschützt beschränkt und Mitgliedsfunktionen, die von anderen verwendet werden müssen, werden als öffentlich platziert.

1.3 Klassendomäne

Die Klasse definiert einen neuen Bereich. Wenn Sie Mitglieder außerhalb der Klasse definieren, müssen Sie den ::scope-Operator verwenden, um anzugeben, zu welchem Klassenbereich das Mitglied gehört.

Die Klassendomäne wirkt sich auf die Suchregeln der Kompilierung aus. Wenn Init im folgenden Programm die Klassendomäne Stack nicht angibt, behandelt der Compiler Init als globale Funktion. Wenn er während der Kompilierung keine Mitglieder wie _top findet, wechselt er zu Klassendomäne, um sie zu finden.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
 
public:
	void Init(int x, int y);
 
};
void Stack::Init(int x, int y)
 
	{
		 _top = x;
		 _capacity = y;
	}
int main()
{
	
	return 0;
}

Beachten:

Die Funktionsdeklarationen und Definitionen in der Klasse werden getrennt. Nachdem die Klasse erstellt wurde, muss eine neue Klassendomäne angegeben werden, andernfalls ist sie nicht zugänglich.

2. Instanziierung

2.1 Instanziierungskonzept

Der Prozess der Erstellung eines Typs im physischen Speicher wird als Klasseninstanziierung bezeichnet.
Eine Klasse ist eine abstrakte Beschreibung eines Objekts. Sie begrenzt die Mitgliedsvariablen der Klasse und es wird kein Speicherplatz zugewiesen.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
//声明
 
	int* _a;
	int _top;
	int  _capacity;
 
};
 
int main()
{
	
	Stack::_top = 2024;
	//编译器报错，_top只是声明，并未实例化
 
	return 0;
}

Eine Klasse kann mehrere Objekte instanziieren, und die instanziierten Objekte belegen tatsächlichen physischen Raum und speichern Mitgliedsvariablen. Zum Beispiel: Das Instanziieren von Objekten aus einer Klasse ist wie die Verwendung von Architekturzeichnungen zum Bau eines Hauses in der Realität. Klassen sind wie Entwurfszeichnungen, die die Anzahl der Räume, die Größe des Hauses usw. planen, aber es gibt keine physischen Gebäude, und es kann nicht in Menschen leben, nur wenn ein Haus anhand der Entwurfszeichnungen gebaut wird, können Menschen in dem Haus leben.Die gleiche Klasse ähnelt einer Entwurfszeichnung. Sie teilt dem Compiler lediglich mit, wie viel Speicher geöffnet werden soll, aber sie öffnet nicht den Speicher. Nur den instanziierten Objekten wird physischer Speicher zum Speichern von Daten zugewiesen.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
 
//声明
	int* _a;
	int _top;
	int  _capacity;
 
};
 
int main()
{
	
	
	Stack st;
    st._top=2024;
//Stack实例化出st，系统已经给st分配内存了，可以存储数据，编译通过
 
	return 0;
}

2.2 Objektgröße

Analysieren Sie, welche Mitglieder das Klassenobjekt hat? Jedes von einer Klasse instanziierte Objekt verfügt über einen unabhängigen Datenraum, daher muss das Objekt Mitgliedsvariablen enthalten. Sind also Mitgliedsfunktionen enthalten? Erstens handelt es sich nach der Kompilierung um einen Abschnitt mit Anweisungen, die nicht im Objekt gespeichert werden können. Diese Anweisungen werden in einem separaten Bereich (Codesegment) gespeichert. Wenn das Objekt gespeichert werden muss, kann es sich nur um einen Zeiger handeln eine Memberfunktion. Ist es notwendig, Zeiger im Objekt zu speichern? Date instanziiert zwei Objekte d1 und d2. Sowohl di als auch d2 verfügen über unabhängige Mitgliedsvariablen _year/_month/_day, aber die Mitgliedsfunktionen Init von d1 und d2 sind die /Print-Zeiger ist dasselbe und wird verschwendet, wenn es im Objekt gespeichert wird. Wenn Sie Date verwenden, um 100 Objekte zu instanziieren, wird der Mitgliedsfunktionszeiger 100 Mal wiederholt gespeichert, was zu verschwenderisch ist. Tatsächlich muss der Funktionszeiger nicht gespeichert werden. Die aufrufende Funktion wird in eine Assembly-Anweisung kompiliert. Tatsächlich muss der Compiler die Adresse der Funktion beim Kompilieren und Verknüpfen finden . Es kann zur Laufzeit nicht gefunden werden. Der Status wird zur Laufzeit gefunden, daher muss die Funktionsadresse gespeichert werden.

Regeln zur Speicherausrichtung

Das erste Mitglied befindet sich am Adressoffset 0 von der Struktur
Andere Mitgliedsvariablen müssen an Adressen ausgerichtet werden, die ein Vielfaches der Ausrichtungsnummer sind.
Ausrichtungsnummer = Der kleinere Wert aus der Standard-Ausrichtungsnummer des Compilers und der Größe des Mitglieds
Die Standardausrichtungsnummer der VS x64-Plattform ist 4 und die Standardausrichtungsnummer von x86 ist 8
Die Gesamtgröße der Struktur beträgt: ein ganzzahliges Vielfaches der maximalen Alignment-Nummer (die größte aller Typvariablen und die kleinste Standard-Alignment-Nummer)
Wenn Strukturen verschachtelt sind, wird die verschachtelte Struktur auf ein ganzzahliges Vielfaches ihrer eigenen maximalen Ausrichtungszahl ausgerichtet, und die Gesamtgröße der Struktur ist ein ganzzahliges Vielfaches aller maximalen Ausrichtungszahlen (einschließlich der Ausrichtungszahl verschachtelter Strukturen).


class A
{
public:
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch;
 
	int _i;
};
//_ch 是一个字节，默认对齐数是4，最大对齐数是4，所以开辟4个字节用来存在_ch
// _i是4个字节，默认对齐数是4，最大对齐数是4，所以开辟4个字节用来存储_i
class B
{
public:
	void Print()
	{
	//。。。
	}
 
	
};
class B
{
 
 
};
//B和C里面没有存储任何成员变量，只有一个函数，可成员函数不存对象里面
// 按理来说是0，但是结构体怎么会没大小，为表示对象存在C++对这种规定大小为1，为了占位标识对象存在

3.Dieser Zeiger

Nachdem der Compiler kompiliert wurde, fügen die Mitgliedsfunktionen der Klasse standardmäßig einen Zeiger auf die aktuelle Klasse an der ersten Position des formalen Parameters hinzu, der als dieser Zeiger bezeichnet wird.

Der Init-Prototyp in der Date-Klasse ist beispielsweise void Init (Date * const this, int year, int month, int day). Beim Zugriff auf Mitgliedsvariablen in den Mitgliedsfunktionen der Klasse wird über den This-Zeiger auf die Essenz zugegriffen. wie _year in der Init-Funktion, this->_year=year

Prototyp:


class Date
{
	void Print()
	{
 
		cout << _year << "n" << _month << "n" << _day << endl;
	}
	void Init( int year, int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
 
	}
	
private:
	int _year;
	int _month;
	int _day;
 
};


Date d1;
d1.Init(2024,7,10);
 
d1.Print();
Date d2;
 
d2.Init(2024, 7, 9);
d2.Print();

echter Prototyp


class Date
{
	void Init(Date* const this,int year, int month,int day)
	
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
 
	}
	void Printf(Date* const this)
	
	{
 
		cout << this->_year << "n" <<this-> _month << "n" << this->_day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
 
};


Date d1;
d1.Init(&d1,2024,7,10);
d1.Print(&d1);
 
Date d2;
d2.Init(&d2,2024, 7, 9);
d2.Print();

C++ legt fest, dass dieser Zeiger nicht an die Stelle tatsächlicher Parameter und formaler Parameter geschrieben werden darf (der Compiler wird ihn beim Kompilieren verarbeiten), dieser Zeiger kann jedoch explizit im Funktionskörper verwendet werden Der Inhalt, auf den dieser Zeiger zeigt, kann

Dieser Zeiger wird auf dem Stapel gespeichert

4.Standard-Memberfunktionen von Klassen

Die Standard-Member-Funktion ist eine Member-Funktion, die nicht explizit vom Benutzer definiert wird und automatisch vom Compiler generiert wird. Sie wird als Standard-Member-Funktion bezeichnet.

4.1Konstrukteur

Der Konstruktor ist eine spezielle Mitgliedsfunktion. Es ist zu beachten, dass der Konstruktor zwar als Konstruktor bezeichnet wird, der Hauptinhalt des Konstruktors jedoch nicht darin besteht, Platz zum Erstellen von Objekten zu schaffen (das lokale Objekt, das wir normalerweise verwenden, ist der Platz, der geöffnet wird). Der Stapelrahmen wird erstellt) ), aber das Objekt wird initialisiert, wenn das Objekt instanziiert wird. Der Kern des Konstruktors besteht darin, die Funktion der Init-Funktion zu ersetzen, die wir zuvor in den Klassen Stack und Date geschrieben haben. Der automatische Aufruf des Konstruktors ersetzt die Init-Funktion perfekt.

Merkmale des Konstruktors:

Der Funktionsname ist derselbe wie der Klassenname
Kein Rückgabewert (Sie müssen nichts als Rückgabewert angeben und nicht void schreiben. Dies ist die Regel von C++)
Wenn das Objekt instanziiert wird, ruft das System automatisch den entsprechenden Konstruktor auf.
Konstruktoren können überladen sein
Wenn in der Klasse kein expliziter Konstruktor definiert ist, generiert der C++-Compiler automatisch einen Parameterlosen Standardkonstruktor. Sobald der Benutzer den Konstruktor explizit definiert, generiert der Compiler ihn nicht mehr.


class Date
{public:
	//1.无参构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	//2.带参构造函数
	Date(int year, int month, int day)
{
		_year = year;
		_month = month;
		_day = day;
	}
 
 
	//3.全缺省构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
 
};

Der parameterlose Konstruktor, der Standardkonstruktor und der vom Compiler standardmäßig generierte Konstruktor, wenn wir keinen Konstruktor schreiben, werden alle als Standardkonstruktoren bezeichnet. Aber nur einer dieser drei kann existieren, nicht gleichzeitig. Obwohl der parameterlose Konstruktor und der vollständige Standardkonstruktor eine Funktionsüberladung darstellen, kommt es beim Aufruf zu Mehrdeutigkeiten.Beachten Sie, dass der Standardkonstruktor nicht nur der vom Compiler standardmäßig generierte ist, sondern auch der Konstruktor, der parameterlose Konstruktor, und der vollständige Standardkonstruktor ist auch der Standardkonstruktor. Zusammenfassend lässt sich sagen, dass er ohne Übergabe von Parametern aufgerufen werden kann.

Wir schreiben es nicht. Das vom Compiler generierte Konstrukt stellt keine Anforderungen an die Initialisierung integrierter Typ-Member-Variablen. Das heißt, ob es initialisiert wird oder nicht, hängt vom Compiler ab.


//text.cpp
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请失败");
		}
		_capacity = n;
		_top = 0;
	}
 
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
//两个Stack实现队列
class MyQueue
{
private:
    int size;
	Stack pushst;
	Stack popst;
};
 
int main()
{
 
	MyQueue my;
 
 
	return 0;
}

C++ unterteilt Typen in benutzerdefinierte Typen und integrierte Typen (Basistypen). Integrierte Typen sind die nativen Datentypen, die von der Sprache bereitgestellt werden, z. B. int/char/double/pointer usw. Benutzerdefinierte Typen sind Typen, die wir selbst mithilfe von Schlüsselwörtern wie class/struct definieren.Der Konstruktor wird hier automatisch initialisiert, und VS initialisiert auch die integrierte Typgröße. Verschiedene Compiler haben unterschiedliche Initialisierungswerte, und C++ gibt diese nicht an.

Für benutzerdefinierte Mitgliedsvariablen ist es erforderlich, den Standardkonstruktor dieser Mitgliedsvariablen aufzurufen, um sie zu initialisieren.Wenn diese Mitgliedsvariable keinen Standardkonstruktor hat, wird ein Fehler gemeldet. Wenn wir diese Mitgliedsvariable initialisieren möchten, müssen wir zur Lösung eine Initialisierungsliste verwenden.

Zusammenfassung: In den meisten Fällen müssen wir den Konstruktor selbst implementieren. In einigen Fällen ähnelt er MyQueue, und wenn Stack über einen Standardkonstruktor verfügt, kann MyQueue automatisch generiert und verwendet werden.

4.2 Destruktor


~Stack()
{
	free(_a);
	_a = nullptr;
	_top = _capacity = 0;
}

Eigenschaften des Destruktors:

1. Dem Destruktornamen werden die Zeichen ~ vorangestellt

2. Keine Parameter und kein Rückgabewert (konsistent mit dem Konstruktor)

3. Eine Klasse kann nur einen Destruktor haben.Wenn die Definition nicht angezeigt wird, generiert das System automatisch einen Standarddestruktor.

4. Wenn der Objektdeklarationszyklus endet, ruft das System automatisch den Destruktor auf.

5. Ähnlich wie beim Konstruktor schreiben wir den vom Compiler automatisch generierten Destruktor nicht und verarbeiten nicht die integrierten Typmitglieder. Benutzerdefinierte Typmitglieder rufen andere Destruktoren auf.

6. Es ist auch zu beachten, dass bei der Anzeige des Destruktors auch der Destruktor des benutzerdefinierten Typmitglieds aufgerufen wird, was bedeutet, dass der Destruktor des benutzerdefinierten Typmitglieds unabhängig von der Situation automatisch aufgerufen wird.


//text.cpp
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请失败");
		}
		_capacity = n;
		_top = 0;
 
 
	}
 
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top=_capacity=0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
	
};
//两个Stack实现队列
class MyQueue
{public:
    //编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化
	//编译器默认生成MyQueue的析构函数调用了Stack的析构，释放了Stack内部的资源
	//显示写析构也会调用Stack的析构
	~MyQueue()
	{
		cout << "~MyQueue" << endl;
	}
private: 
	
	Stack pushst;
	Stack popst;
	
};
 
 
int main()
{
 
	MyQueue my;
 
 
	return 0;
}

Der Destruktor in MyQueue macht nichts, aber C++ schreibt vor, dass andere Destruktoren aufgerufen werden, um den Speicher freizugeben.

Wenn keine Ressourcen angefordert werden, muss der Destruktor nicht geschrieben werden und der vom Compiler generierte Standarddestruktor kann direkt verwendet werden. Wenn der generierte Standarddestruktor verwendet werden kann, ist es nicht erforderlich, den Destruktor explizit zu schreiben B. MyQueue, aber es gibt eine Ressourcenanwendung. Achten Sie beim Zerstören darauf, den Destruktor direkt zu schreiben, da es sonst zu Ressourcenverlusten wie Stack kommt

4.5 Überlastung des Bedieners

Wenn Operatoren für typisierte Objekte verwendet werden, können wir mit der Sprache C++ neue Bedeutungen in Form einer Operatorüberladung angeben. C++ legt fest, dass ein Klassentypobjekt, das einen Operator verwendet, in einen Aufruf der entsprechenden Operatorüberladung umgewandelt werden muss. Andernfalls meldet der Compiler einen Fehler.
Beim Überladen von Operatoren handelt es sich um eine Funktion mit einem bestimmten Namen. Ihr Name setzt sich aus dem Operator und dem später zu definierenden Operator zusammen.Wie andere Funktionen verfügt auch sie über einen Rückgabetyp und eine Parameterliste sowie einen Funktionskörper


 
 
bool operator<(Date d1, Date d2)
{
 
}
bool operator==(Date d1,Date d2)
{
	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}

Eine überladene Operatorfunktion benötigt so viele Parameter wie Parameter, auf die der Operator einwirkt.Der unäre Transportkomfort hat einen Parameter und der binäre Operator hat zwei Parameter. Der linke Operand des binären Operators wird an den ersten Parameter und der rechte Operand an den zweiten Parameter übergeben.


//text.cpp
#include<iostream>
using namespace std;
 
class Date
{
public:
	Date(int year, int month, int day)
	{
	_year= year;
		_month = month;
		_day = day;
 
	}
 
 
 
	int _year;
	int _month;
	int _day;
 
};
 
bool operator<(Date d1, Date d2)
{
 
}
bool operator==(Date d1,Date d2)
{
	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
int main()
{
 
	Date d1(2024, 7, 10);
	Date d2(2024,7,9);
//两种用法都可以
	d1 == d2;
	operator==(d1 , d2);
	return 0;
}

Wenn eine überladene Operatorfunktion eine Mitgliedsfunktion ist, wird ihr erster Operand standardmäßig an den impliziten Zeiger this übergeben. Wenn der Operator als Mitgliedsfunktion überladen ist, hat er daher einen Parameter weniger als der Operand.
Nachdem ein Operator überladen wurde, bleiben seine Priorität und Assoziativität mit den integrierten Typoperationen konsistent.
Sie können keinen sexuellen Operator erstellen, indem Sie Übereinstimmungen verketten, die in der Syntax nicht vorhanden sind: z. B.

Technologieaustausch

C-Grundlagen (2)

1. Klassen und Objekte

1.1 Klassendefinition

1.2 Zugangsqualifikationen

1.3 Klassendomäne

2. Instanziierung

2.1 Instanziierungskonzept

2.2 Objektgröße

3.Dieser Zeiger

4.Standard-Memberfunktionen von Klassen

4.1Konstrukteur

4.2 Destruktor

4.5 Überlastung des Bedieners

Persönliches Profil

meine Kontaktdaten