C++d对象与this指针

快来打我* 2022-12-27 02:29 111阅读 0赞

一、成员变量与成员函数分开存储。  
在C++中，类内的成员变量和成员函数是分开储存的，只有非静态成员变量才属于类的对象上。

\#include <iostream>  
using namespace std;

class Person\{  
public:  
int m\_A; //非静态成员变量 属于对象上

static int m\_B; //静态成员变量 不属于对象上

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

static void func2() //静态成员函数 不属于对象上  
\{

\}  
\};

int main()  
\{  
//Person p; //空对象占用内存空间为:1  
//C++编译器都会给空对象分配1个字节的空间，是为了区分空对象占内存的位置。  
//空对象在内存空间有一个独一无二的地址。  
//cout << "sizeof(p):" << sizeof(p) << endl; //1

Person p;  
cout << "sizeof(p):" << sizeof(p) << endl; //4

return 0;  
\}

二、this指针的概念。  
通过第一点，我们知道在C++中成员变量和成员函数分开存储。  
静态成员变量、静态成员函数都是在编译阶段已经分配好内存的了。  
非静态成员函数是在运行代码之后，才会在代码去申请空间，由于函数在代码区申请的空间，只会诞生一份函数实例，也就是说，所以的同类型的对象都是公用这份代码。  
那么问题来了： 这一块代码如何区分是哪个对象调用自己的？

C++通过提供特殊的对象指针:this指针，解决上述的问题，this指针指向被调用的成员函数所属的对象。

this指针是隐含在每一个非静态成员函数内的一种指针。  
this指针不需要定义，直接使用就可以。

this指针的用途：  
1）形参和成员变量同名时，可以用this指针加以区分。  
2）在类的非静态成员函数中返回对象本身，可以使用return \*this。

\#include <iostream>  
using namespace std;

//this指针  
/\*  
this指针的用途：  
1）形参和成员变量同名时，可以用this指针加以区分。  
2）在类的非静态成员函数中返回对象本身，可以使用return \*this。  
\*/

class Person\{  
public:  
Person(int age) //构造函数也是非静态的成员函数  
\{  
//this指针指向被调用的成员函数所属的对象，其实就是this指向p1  
//this->age代表访问这个对象p1的成员变量age  
//谁调用这个有参构造，this就向谁。

this->age = age; //这时候this就是指向p1这个对象  
\}

//返回值这里写Person，那么返回的是p2的副本，并不是p2的本身，所以后续累加都是对副本进行操作，p2没有动过。  
//返回值这里写Person&，那么返回的是p2的本身，所以后续的累加是对p2的本身作累加。  
Person& PersonAddAge(Person &p)  
\{  
this->age += p.age;  
return \*this;  
\}

int age;  
\};

int main()  
\{  
//1. 使用this指针来解决名字冲突  
//Person p1(18);  
//cout << "p1的年龄:" << p1.age << endl;

//Person p2(28);  
//cout << "p2的年龄:" << p2.age << endl;

//2. 返回对象本身用\*this。  
Person p1(10);  
Person p2(10);

//p2.PersonAddAge(p1);  
//cout << "p2的年龄:" << p2.age << endl;

//C++链式编程思想  
p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);  
cout << "p2的年龄:" << p2.age << endl;  
return 0;  
\}

三、空指针访问成员函数。  
C++空指针也是可以调用成员函数的，但是要注意有没有使用到this指针。  
如果用到了this指针，需要加以判断保证代码的健壮性。

\#include <iostream>  
using namespace std;

//空指针调用成员函数  
class Person\{  
public:  
void showClassName() //该非静态成员函数没有使用到this指针  
\{  
cout << "this is Person class!" << endl;  
\}

void showPersonAge()  
\{  
if(this == NULL)  
\{  
return;  
\}

//其实在这里，每一个成员变量默认都是使用this指针指向的。  
//也就是说，这里的m\_Age，其实就是this->m\_Age;  
//因为我们没有创建对象，所以this没有指向确切的实体。  
//所以this是NULL，因为是NULL，并且还在访问成员，所以就段错误。  
cout << "age = " << m\_Age << endl;  
\}

int m\_Age;  
\};

int main()  
\{  
Person \*p = NULL;  
p->showClassName();  
p->showPersonAge();

return 0;

四、const修饰成员函数。

常函数：  
成员函数后加const后，我们称这个函数为常函数。  
常函数内不可以修改成员属性。  
成员属性声明时加关键字mutable后，在常函数中依然可以修改。

常对象：  
声明对象前加const称该对象为常对象。  
常对象只能调用常函数。

\#include <iostream>  
using namespace std;

//常函数  
/\*  
成员函数后加const后，我们称这个函数为常函数。  
常函数内不可以修改成员属性。  
成员属性声明时加关键字mutable后，在常函数中依然可以修改。  
\*/

/\*  
常对象：  
声明对象前加const称该对象为常对象。  
常对象只能调用常函数。  
\*/

class Person\{  
public:  
Person(int a)  
\{  
this->m\_A = a;  
\}

void showPerson() const //常函数  
\{  
//m\_A = 100; //在常函数中修改成员属性。  
m\_B = 100;  
\}

void func() //普通函数  
\{

int m\_A; //普通变量，不是一个常量  
mutable int m\_B; //特殊变量，即使在常函数中，也可以修改这个值 (加了mutable，从"常"变成"不常")  
\};

int main()  
\{  
/\*  
Person p; //普通对象 : 可以调用普通函数，也可以调用常函数  
p.showPerson();  
p.func();  
\*/

const Person p(100);  
//p.m\_A = 100; //错误  
p.m\_B = 100;

p.showPerson();  
//p.func(); //p是常对象,所以只能调用常函数，不能调用普通函数。

return 0;  
\}

总结：  
1）在函数头后面加const，这个函数就是常函数。  
2）如果类中有普通变量，则在常函数中不能修改这个普通变量。  
3）如果类中有普通变量，但是这个普通变量在声明前加了一个mutable，那么这个变量就变成特殊变量。  
4）在常函数中可以修改特殊变量的值。  
5）在声明对象前加一个const，这个对象就变成常对象。  
6）声明了常对象，也就意味着这个类中普通变量都是常的，所以构造函数去给普通变量赋值。  
不能先声明常对象，然后在常对象后面再给普通变量中，因为声明常对象，普通变量由于是常的，没有值，就会报错。  
7）常对象可以修改mutable修饰的变量。  
8）常对象只能调用常函数，不能调用普通函数。