C++编程——C++对象模型和this指针

1. C++对象模型

C++中类对象的成员变量和成员函数是分开存储的

• 非静态成员变量，属于类的对象上
• 静态成员变量，不属于类的对象上
• 非静态成员函数，不属于类的对象上
• 静态成员函数，不属于类的对象上

即只有非静态成员变量才属于类的对象上

示例1：(空类的对象模型)

class Person
{

};

void test()
{
	Person p;

	//空对象占用的内存空间为1
	//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
	//每个空对象也应该有一个独一无二的内存地址
	cout << "size of p = " << sizeof(p) << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

示例2：(只含int类型静态成员变量)

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

void test()
{
	Person p;
	// 含有int m_A后，类对象所占用的大小为4
	cout << "size of p = " << sizeof(p) << endl;
}
1
2
3
4
5
6
7
8
9
10
11

示例3：(含int类型静态成员变量和int类型非静态成员变量)

class Person
{
	int m_A; //非静态成员变量 属于类的对象上
	static int m_B; //静态成员变量， 不属于类的对象上
};

int Person::m_B = 0; //静态成员变量类内声明，类外初始化


void test()
{
	Person p;
	// 含有int m_A和static int m_B后，类对象所占用的大小同样为4
	cout << "size of p = " << sizeof(p) << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

示例4：（含int类型静态成与非静态成员变量，同时含有静态与非静态成员函数）

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

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

	}

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

	}
};

int Person::m_B = 0; //静态成员变量类内声明，类外初始化


void test()
{
	Person p;
	// 类对象所占用的大小为4
	cout << "size of p = " << sizeof(p) << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2. this指针

通过C++对象模型可知，静态与非静态成员函数都不属于类的对象，即每一个成员函数只会生成一份函数实例，类的不同对象共享这一份函数实例。
那么就面临着一个问题：既然类的所有对象都共享同一份函数实例，那代码如何区分是哪个对象在调用成员函数呢？
这就引出了this指针的概念，C++通过提供特殊的对象指针，即this指针，解决上述问题。this指针指向被调用成员函数所属的对象

this指针的两大用途：

• 当形参和成员变量同名时，可用this指针区分,以解决名称冲突

示例：

class Person
{
public:
	Person(int age)
	{
		this->age = age; //this指针指向被调用成员函数所属的对象
		//age = age; 采用这种方式无法给类成员属性赋正确的值
	}
	int age;
};

int main()	
{
	Person p1(10); 
	//当创建p1对象后，this指针就指向了p1对象，执行this->age = age;就能给成员变量赋正确的值

	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 在类的非静态成员函数中返回对象本身，可使用return *this

示例1：

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

	void AddPerson(Person &p)
	{
		this->age += p.age;
	}

	int age;
};

int main()	
{
	Person p1(10);
	Person p2(10);

	p2.AddPerson(p1); //AddPerson返回的是void，所以p2.AddPerson(p1).AddPerson(p1)会报错，无法实现连续AddPerson

	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

示例2：(解决示例1无法连续调用AddPerson的问题)

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

	Person& AddPerson(Person &p) //注意这里返回值必须是引用，不然操作的对象就不是返回的对象了。值传递的方式会创建新的对象
	{
		this->age += p.age;
		return *this; //返回当前调用该函数的对象
	}

	int age;
};



int main()	
{
	Person p1(10);
	Person p2(10);

	p2.AddPerson(p1).AddPerson(p1);//如果AddPerson的返回值是Person,那后面输出的值就是20，因为值传递会产生新的对象
	cout << "p2的年龄是" << p2.age << endl; //输出的结果是30
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

注意事项：由this指针衍生出的一个问题是空指针访问成员函数的问题
空指针是可以访问成员函数的，但是如果成员函数出现访问类属性的情况，就会出现报错。
示例：

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

	void showClassName()
	{
		cout << "this is Person class" << endl;
	}

	void showPersonAge()
	{
		cout << "age = " << age << endl; //相当于this->age
	}
	int age;
};



int main()	
{
	Person * p = NULL;
	p->showClassName(); //能够正常运行
	p->showPersonAge(); //出现报错，因此空指针无法访问成员变量

	system("pause");
	return 0;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31