[C ++] Modelo de objetos de C ++ y este puntero

1. Almacenamiento independiente de variables miembro y funciones miembro

En C ++, las variables miembro y las funciones miembro de una clase se almacenan por separado

Solo las variables miembro no estáticas pertenecen a los objetos de la clase

(1) El tamaño del objeto vacío

#include <iostream>
using namespace std;

class Person
{
};

void test01() {
	Person p1;
	cout << "空对象的大小是:" << sizeof(p1) << endl;
}

int main(void)
{
	test01();

	system("pause");
	return 0;
}

El espacio de memoria ocupado por los objetos vacíos es: 1. El compilador de C ++ también asignará un espacio de bytes para cada objeto vacío, con el fin de distinguir la ubicación de la memoria del objeto vacío;

Cada objeto vacío también debe tener una dirección de memoria única única.

#include <iostream>
using namespace std;

class Person
{
public:
	int m_A;     //非静态成员变量  属于类的对象上

	static int m_B;   //静态成员变量 不属于类的对象上

	void func(){}     //非静态成员函数  不属于类的对象上

	static void func2(){}  //静态成员函数  不属于类的对象上
};
int Person::m_B = 10;

void test01() {
	Person p1;
	cout << "p1的大小是:" << sizeof(p1) << endl;
}

int main(void)
{
	test01();

	system("pause");
	return 0;
}

2. El concepto de este puntero

Sabemos que las variables miembro y las funciones miembro se almacenan por separado en C ++

Cada función miembro no estática solo producirá una instancia de función, lo que significa que varios objetos del mismo tipo compartirán un fragmento de código

Entonces la pregunta es: ¿cómo distingue este fragmento de código qué objeto se llama a sí mismo?

 

C ++ resuelve los problemas anteriores proporcionando un puntero de objeto especial, este puntero. Este puntero apunta al objeto al que se llama la función miembro

Este puntero es un puntero que implica cada función miembro no estática

No es necesario definir este puntero, se puede utilizar directamente

El propósito de este puntero:

• Cuando el parámetro formal y la variable miembro tienen el mismo nombre, este puntero se puede utilizar para distinguir

• Para devolver el objeto en sí en la función miembro no estática de la clase, puede usar return * this

(1) Cuando el parámetro formal y la variable miembro tienen el mismo nombre, este puntero se puede utilizar para distinguir

No uses esto

#include <iostream>
using namespace std;

class Person2
{
public:
	Person2(int age)
	{
		age = age;     //编译器会认为这三个age是一样的
	}

	int age;
};

void test02()
{
	Person2 p(18);
	cout << p.age << endl;
}

int main(void)
{
	test02();

	system("pause");
	return 0;
}

Utilizar esta

#include <iostream>
using namespace std;

class Person2
{
public:
	Person2(int age)
	{
		this->age = age;    
	}

	int age;
};

void test02()
{
	Person2 p(18);
	cout << p.age << endl;
}

int main(void)
{
	test02();

	system("pause");
	return 0;
}

(2) Para devolver el objeto en sí en la función miembro no estática de la clase, puede usar return * this

Ahora es necesario agregar siempre la edad de p1 a p2

#include <iostream>
using namespace std;

class Person2
{
public:
	Person2(int age)
	{
		this->age = age;    
	}

	Person2& addAge(Person2& p)
	{
		this->age += p.age;
		return *this;
	}


	int age;
};

void test02()
{
	Person2 p1(10);

	Person2 p2(10);

	p2.addAge(p1).addAge(p1).addAge(p1);


	cout << p2.age << endl;
}

int main(void)
{
	test02();

	system("pause");
	return 0;
}

3. Acceso de puntero nulo a funciones miembro

Los punteros nulos en C ++ también pueden llamar a funciones miembro, pero también prestan atención a si se usa este puntero

Si se utiliza este puntero, debe evaluarse para garantizar la solidez del código.

#include <iostream>
using namespace std;

class Person3
{
public:
	void showClass()
	{
		cout << "this is Person3" << endl;
	}

	void showAge()
	{
		cout << "age = " << age << endl;
	}

	int age;
};


void test03()
{
	//空指针访问成员函数
	Person3* p = NULL;
	p->showClass();    //空指针，可以调用成员函数

	p->showAge();      //但是如果成员函数中用到了this指针，就不可以了
}


int main(void)
{
	test03();

	system("pause");
	return 0;
}

Modifique el código de la siguiente manera:

#include <iostream>
using namespace std;

class Person3
{
public:
	void showClass()
	{
		cout << "this is Person3" << endl;
	}

	void showAge()
	{
		if (this == NULL)
		{
			return;
		}
		cout << "age = " << age << endl;
	}

	int age;
};


void test03()
{
	//空指针访问成员函数
	Person3* p = NULL;
	p->showClass();    //空指针，可以调用成员函数

	p->showAge();      //但是如果成员函数中用到了this指针，就不可以了
}


int main(void)
{
	test03();

	system("pause");
	return 0;
}

Después de la prueba, también se puede acceder a las funciones miembro estáticas a través de punteros nulos.

4. función miembro modificada const

(1) Función constante

Función constante:

• Después de agregar la función miembro const, llamamos a esta función una función constante

• Los atributos de miembro no se pueden modificar en funciones constantes

• Después de agregar la palabra clave mutable en la declaración del atributo de miembro, aún se puede modificar en la función normal

#include <iostream>
using namespace std;

class Person4
{
public:


	//1、this指针的本质是一个指针常量，指针的指向不可修改
	//5、如果想让指针指向的值也不可以修改，需要声明常函数
	void show()const    //5
	{
		//3、const Type* const pointer;
		//2、this = NULL; //不能修改指针的指向 Person* const this;
		//4、this->m_A = 100; //但是this指针指向的对象的数据是可以修改的

		//6、const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
		this->m_B = 100;
	}
	int m_A;
	mutable int m_B; //可修改 可变的
};


int main(void)
{
	

	system("pause");
	return 0;
}

• La esencia de este puntero es una constante de puntero, y el punto del puntero no se puede modificar
• this = NULL; // No se puede modificar el puntero a Person * const this;
• this-> m_A = 100; // Pero los datos del objeto apuntado por este puntero se pueden modificar
• Si desea que el valor señalado por el puntero no se pueda modificar, debe declarar una función constante;
• void show () const {}
• función miembro modificada const, que indica que los datos en el espacio de memoria apuntado por el puntero no se pueden modificar, excepto para las variables modificadas por mutable

(2) Objetos regulares

Objeto regular:

• Agregue const antes de declarar el objeto para llamar al objeto un objeto constante

• Los objetos constantes solo pueden llamar a funciones constantes

#include <iostream>
using namespace std;

class Person4
{
public:


	//1、this指针的本质是一个指针常量，指针的指向不可修改
	//5、如果想让指针指向的值也不可以修改，需要声明常函数
	void show()const    //5
	{
		//3、const Type* const pointer;
		//2、this = NULL; //不能修改指针的指向 Person* const this;
		//4、this->m_A = 100; //但是this指针指向的对象的数据是可以修改的

		//6、const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
		this->m_B = 100;
	}

	void MyFunc1() 
	{
		
	}

	void MyFunc2()const
	{

	}

	int m_A;
	mutable int m_B; //可修改 可变的
};


void test004()
{
	const Person4 person; //常量对象  
	cout << person.m_A << endl;
	//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
	person.m_B = 100; //但是常对象可以修改mutable修饰成员变量


	//常对象只能调用常函数
	//person.MyFunc1();   //常对象不可用调用普通成员函数，因为普通成员函数可以修改属性
	
	person.MyFunc2();
}


int main(void)
{
	test004();

	system("pause");
	return 0;
}