2021-02-24 Checken Sie ein und lernen Sie C ++ für den zehnten Tag

---

Eins, Klasse und Objekt

1 Paket

2. Initialisierung und Bereinigung von Objekten

(5) Tiefe und flache Kopie

Deep Copy ist eine klassische Interviewfrage und eine häufige Grube

• Flache Kopie: Wenn Sie den vom Compiler bereitgestellten Kopierkonstruktor verwenden, führen Sie eine flache Kopieroperation aus, bei der es sich um eine einfache Kopieroperation für die Zuweisung handelt
• Deep Copy: Beantragen Sie erneut Speicherplatz im Heap-Bereich für den Kopiervorgang

Wenn das Attribut im Heap-Bereich entwickelt wird, müssen Sie Ihren eigenen Kopierkonstruktor bereitstellen, um Probleme durch flache Kopien zu vermeiden
Beispiel

#include<iostream>
using namespace std;

//深拷贝与浅拷贝

class person
{
    
    
public:
	person()
	{
    
    
		cout << "person的默认构造函数调用" << endl;
	}
	person(int age, int height)
	{
    
    
		m_age = age;
		m_height = new int(height);//用一个堆区指针来存放身高
		cout << "person的有参构造函数调用" << endl;
	}

	//自己实现拷贝构造函数，解决浅拷贝带来的问题
	person(const person &p)
	{
    
    
		cout << "person拷贝构造函数调用" << endl;
		m_age = p.m_age;
		//m_height = p.m_height; 编译器默认实现的代码
		//深拷贝操作

		m_height = new int(*p.m_height);
	}
	~person()//析构代码：将堆区开辟数据做释放操作
	{
    
    
		//堆区中的数据需程序员手动释放
		if (m_height != NULL)  //手动释放操作
		{
    
    
			delete m_height;
			m_height = NULL;
		}
		cout << "person的析构函数调用" << endl;
	}

	int m_age;
	int *m_height;
};

void test01()
{
    
    
	person p1(18 ,160);
	cout << "p1的年龄为：" << p1.m_age ;
	cout << " p1的身高为：" << *p1.m_height << endl;
	person p2(p1);
	cout << "p2的年龄为：" << p2.m_age;
	cout << " p2的身高为：" << *p2.m_height << endl;
}

int main()
{
    
    
	test01();

	system("pause");
	return 0;
}

(6) Initialisierungsliste

Rolle: C ++ bietet die Syntax der Initialisierungsliste zum Initialisieren von Eigenschaften

Grammatik:构造函数 （ ）：属性1（值1），属性2（值2）......{ }

Beispiel

#include<iostream>
using namespace std;

//初始化列表

class person
{
    
    
public:
	
	//传统初始化操作
	//person(int a, int b, int c)
	//{
    
    
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//初始化列表初始化属性
	person(int a, int b, int c) :m_A(a), m_B(b), m_C(c)
	{
    
    

	}

	int m_A;
	int m_B;
	int m_C;
};

void test01()
{
    
    
	//person p(1, 2, 3);
	person p(30, 20, 10);
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
}

int main()
{
    
    
	test01();

	system("pause");
	return 0;
}

(7) Klassenobjekte als Klassenmitglieder

Ein Mitglied in C ++ kann ein Objekt einer anderen Klasse sein. Wir nennen dieses Mitglied ein Objektmitglied

Wenn andere Klassenobjekte als Mitglieder dieser Klasse verwendet werden, wird zuerst das Klassenobjekt und dann selbst erstellt

Z.B

class A {
    
     }
class B
{
    
    
	A a;
}

B类中有对象A作为成员，A为对象成员

Beispiel

#include<iostream>
using namespace std;
#include<string>

//类对象作为类成员

//手机类
class phone
{
    
    
public:
	phone(string pname)
	{
    
    
		m_Pname = pname;
		cout << "phone的构造函数调用" << endl;
	}

	//手机品牌名
	string m_Pname;

};

class person
{
    
    
public:

	person(string name, string pname) :m_name(name), m_phone(pname)
	{
    
    
		cout << "person的构造函数调用" << endl;
	}
	string m_name; //姓名
	phone m_phone;//手机品牌

};

void test01()
{
    
    
	
	person p("张三", "三星");
	cout << p.m_name  << endl;
	cout << p.m_phone.m_Pname << endl;
}

int main()
{
    
    
	test01();

	system("pause");
	return 0;
}

Ausgabeergebnis

(8) Statische Mitglieder

Ein statisches Element besteht darin, das Schlüsselwort static vor Elementvariablen und Elementfunktionen hinzuzufügen, die als statische Elemente bezeichnet werden

Statische Mitglieder sind unterteilt in:

1 * Statische Mitgliedsvariable

• Alle Objekte teilen die gleichen Daten
• Ordnen Sie während der Kompilierung Speicher zu
• In-Class-Deklaration, Out-of-Class-Initialisierung

2 * Statische Elementfunktion

• Alle Objekte haben dieselbe Funktion
• Statische Elementfunktionen können nur auf statische Elementvariablen zugreifen

Statische Elementfunktionen haben auch Zugriffsrechte: Auf private statische Elementfunktionen kann außerhalb der Klasse nicht zugegriffen werden

Beispiel

#include<iostream>
using namespace std;
#include<string>

//静态成员函数

class person
{
    
    
public:
	static void func()
	{
    
    
		A = 20;
		//B = 20;//静态成员函数不可访问非静态成员变量，无法区分是哪个对象的属性
		cout << "static void func调用" << endl;
	}
	
	static int A;//静态成员变量
	int B;//非静态变量成员

};
int person::A = 0;
//两种访问方式
void test01()
{
    
    
	//1、通过对象访问
	person p;
	p.func();

	//2、通过类名访问
	person::func();
}

int main()
{
    
    
	test01();

	system("pause");
	return 0;
}

3. C ++ Objektmodell und dieser Zeiger

(1) getrennte Speicherung von Mitgliedsvariablen und Mitgliedsfunktionen

In C ++ werden Elementvariablen und Elementfunktionen in einer Klasse separat gespeichert

Nur nicht statische Elementvariablen gehören zu Objekten der Klasse

Der C ++ - Compiler weist jedes leere Objekt zuEin Byte LeerzeichenUm den vom Objekt belegten Speicherplatz zu unterscheiden, sollte jedes leere Objekt eine eindeutige Speicheradresse haben

1. Nicht statische Elementvariablen: für Objekte, die zur Klasse gehören
2. Statische Elementvariablen: für Objekte, die nicht zur Klasse gehören
3. Nicht statische Elementfunktion: für Objekte, die nicht zur Klasse gehören
4. Statische Elementfunktion: für Objekte, die nicht zur Klasse gehören

(2) Das Konzept dieses Zeigers

Die Essenz dieses Zeigers ist eine Zeigerkonstante. Der Zeiger kann nicht geändert werden, aber der Wert kann geändert werden

Jede nicht statische Elementfunktion erzeugt nur eine Funktionsinstanz. Dies bedeutet, dass mehrere Objekte desselben Typs einen Code gemeinsam nutzen

C ++ löst die oben genannten Probleme, indem es einen speziellen Objektzeiger bereitstellt, diesen Zeiger

Der Zeiger this zeigt auf das Objekt, zu dem die Elementfunktion aufgerufen wird

• Dieser Zeiger ist ein Zeiger, der jede nicht statische Elementfunktion impliziert
• Dieser Zeiger muss nicht definiert werden, er kann direkt verwendet werden

Der Zweck dieses Zeigers:

• Wenn der formale Parameter und die Mitgliedsvariable denselben Namen haben, kann dieser Zeiger zur Unterscheidung verwendet werden (Namenskonflikte lösen).
• Um das Objekt selbst in der nicht statischen Elementfunktion der Klasse zurückzugeben, können Sie return this verwenden ( verwenden Sie dies, um das Objekt selbst zurückzugeben ).

Beispiel

#include<iostream>
using namespace std;

class person
{
    
    
public:
	person(int age)
	{
    
    
		//this 指针指向的是被调用的成员函数所属对象
		this->age = age;
	}

	person& personAddage(person &p)
	{
    
    
		this->age += p.age;

		//this指向p2的指针，而*this指向的就是p2这个对象本体
		return *this;
	}

	int age;
};
//1、解决名称冲突
void test01()
{
    
    
	person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;

}

//2、返回对象本身
void test02()
{
    
    
	person p1(10);
	person p2(10);

	//链式编程思想
	p2.personAddage(p1).personAddage(p1);
	cout << "p2的年龄为：" << p2.age << endl;

}

int main()
{
    
    
	test02();
	system("pause");
	return 0;
}

(3) Nullzeigerzugriff auf Mitgliedsfunktionen

Nullzeiger in C ++ können auch Elementfunktionen aufrufen, aber auch darauf achten, ob dieser Zeiger verwendet wird

Wenn dieser Zeiger verwendet wird, muss er beurteilt werden, um die Robustheit des Codes sicherzustellen

Beispiel

#include<iostream>
using namespace std;

class person
{
    
    
public:
	
	void showClassName()
	{
    
    
		cout << "this is person class" << endl;
	}

	void showPersonAge()
	{
    
    
		if (this == NULL)
			return;
		cout << "age = " << m_age << endl;
	}
	int m_age;
};
//1、解决名称冲突
void test01()
{
    
    
	person *p = NULL;
	p->showClassName();
	p->showPersonAge();
}



int main()
{
    
    
	test01();
	system("pause");
	return 0;
}

(4) const modifizierte Elementfunktion

Konstante Funktion:

• Nach dem Hinzufügen von const nach der Elementfunktion nennen wir diese Funktion eine konstante Funktion
• Elementeigenschaften können in konstanten Funktionen nicht geändert werden
• Nach dem Hinzufügen des veränderbaren Schlüsselworts in der Elementattributdeklaration kann es in der normalen Funktion weiterhin geändert werden

Normales Objekt:

• Fügen Sie const hinzu, bevor Sie das Objekt deklarieren, um das Objekt als konstantes Objekt zu bezeichnen
• Konstante Objekte können nur konstante Funktionen aufrufen

Beispiel

#include<iostream>
using namespace std;

class person
{
    
    
public:
	//在成员函数后面加const，修饰的是this指向，让指针指向的值也不可修改
	void showPerson()const
	{
    
    
		m_b = 100;//可修改

	}
	int m_age;
	mutable int m_b;//特殊变量
};

void test01()
{
    
    
	person p;
	p.showPerson();
}

//常对象
//常对象只能调用常函数
void test02()
{
    
    
	const  person p;
	//p.m_age = 100;
	p.m_b = 100;
}


int main()
{
    
    
	test01();

	system("pause");
	return 0;
}

[Hinweis] Der Lernkurs ist Dark Horse Program C ++ Tutorial