El propósito de este puntero:
1. Cuando el parámetro formal y la variable miembro tienen el mismo nombre, este puntero se puede utilizar para distinguir.
2. Para devolver el objeto en sí en la función miembro no estática de la clase, puede usar return * this
Cada función miembro no estática solo producirá una instancia de función, es decir, 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.
Los objetos p1, p2 y p3 todos llaman a esta función, ¿cómo distinguir quién la llamó?
Utilice este puntero para resolver este problema
El puntero this apunta al objeto al que pertenece la función miembro llamada En
pocas palabras, quien llama a esta función, este puntero señala a quién.
1. Este puntero es un puntero que implica cada función miembro no estática.
2. No es necesario definir este puntero, se puede utilizar directamente.
1. Resolver conflictos de nombres:
ahora veamos el problema del conflicto de nombres:
#include <iostream>
using namespace std;
class Person {
public:
Person(int age) {
age = age;
}
int age;
};
//1.解决名称冲突
void test01() {
Person p1(18);
cout << "p1的年龄为:" << p1.age << endl;
}
//2.返回对象本身用*this
int main() {
test01();
return 0;
}
El resultado es 0. Si el compilador que usa es vs, el resultado debería ser confuso Estoy usando Dev-C ++.
El compilador pensará que estas tres edades tienen la misma edad, que no es lo mismo que su atributo age, por lo que nunca le hemos asignado un valor a este atributo age.
Solución:
1. No tenga el mismo nombre para el atributo de miembro y el nombre del parámetro formal que le pasamos.
2. Utilice este puntero.
¿Cómo usar este puntero?
el código se muestra a continuación:
#include <iostream>
using namespace std;
class Person {
public:
Person(int age) {
//this指针指向的是被调用成员函数所属对象
this->age = age;
}
int age;
};
//1.解决名称冲突
void test01() {
Person p1(18);
cout << "p1的年龄为:" << p1.age << endl;
}
//2.返回对象本身用*this
int main() {
test01();
return 0;
}
En este punto, el compilador cree que sí, por lo que resuelve el problema.
2. Use * this para devolver el objeto en sí.
Primero mire este fragmento de código:
#include <iostream>
using namespace std;
class Person {
public:
Person(int age) {
this->age = age;
}
int age;
void PersonADDAge(Person &p) {
this->age += p.age;
}
};
//1.解决名称冲突
//void test01() {
// Person p1(18);
// cout << "p1的年龄为:" << p1.age << endl;
//
//}
//2.返回对象本身用*this
void test02() {
Person p1(10);
Person p2(10);
p2.PersonADDAge(p1).PersonADDAge(p1).PersonADDAge(p1);
cout << "p2的年龄为：" << p2.age << endl;
}
int main() {
// test01();
test02();
return 0;
}
Nuestro objetivo es sumar 3 veces la edad de p1 a p2. La edad deseada de p2 devuelve 40, pero el compilador informa de un error. ¿Por qué?
Debido a que llamamos a la función PersonADDAge por primera vez, el retorno es nulo, por lo que ya no podemos llamar a esta función PersonADDAge, por lo que si podemos hacer que el valor de retorno de la primera llamada a esta función siga siendo p2, entonces podemos llamarlo de nuevo ¿Cómo implementamos esta función?
Utilice este puntero.
el código se muestra a continuación:
#include <iostream>
using namespace std;
class Person {
public:
Person(int age) {
this->age = age;
}
int age;
//如果要返回本体，要用引用的方式返回。
Person &PersonADDAge(Person &p) {
this->age += p.age;
//this指向p2的指针，而*this指向的就是p2这个对象本体。
return *this;
}
};
//1.解决名称冲突
//void test01() {
// Person p1(18);
// cout << "p1的年龄为:" << p1.age << endl;
//
//}
//2.返回对象本身用*this
void test02() {
Person p1(10);
Person p2(10);
//链式编程思想
p2.PersonADDAge(p1).PersonADDAge(p1).PersonADDAge(p1);
cout << "p2的年龄为：" << p2.age << endl;
}
int main() {
// test01();
test02();
return 0;
}
El resultado en este momento es 40.
Entonces, ¿por qué usar referencias?
La referencia apunta a su propia memoria, se copia sin referencia y la copia apunta a otra memoria.
Lo que se devuelve aquí no es un puntero o referencia, porque se agregó antes , por lo que lo que se devuelve es la ontología p2. *
En este momento, eliminamos esta referencia y vemos cuál es el resultado.
El resultado es: 20
¿por qué?
Debido a que lo que se devuelve en este momento son datos copiados, cada devolución es un objeto nuevo.
Entonces, al final, la primera llamada afecta al p2 real, por lo que el resultado es 20