07c++的对象模型和this指针

1、成员对象和成员函数是分开储存的

#include<iostream>
using namespace std;


class person
{
	//成员对象
	int m_a;//非静态变量  占4个字节即证明是属于类的对象上面的
	static int m_b;//执行test02后，发现字节大小还是4个，即证明静态成员变量不属于类的对象上面
	//成员函数
	void fun1(){}//非静态函数，执行test02后，发现字节大小还是4个，即证明非静态函数变量不属于类的对象上面
	static void fun2() {}//静态函数，执行test02后，发现字节大小还是4个，即证明静态函数变量不属于类的对象上面
};
int person::m_b = 100;

void test()
{
	person p;
	//下面的考试可能考！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
	//空对象占用内存空间为：1
	//c++编译器会给每个空对象也分配1个字节空间大小，是为了区分空对象占内存的位置
	//每个空对象也有独一无二的内存地址
	cout << sizeof(p) << endl;
}

void test02()
{
	person p;
	cout << sizeof(p) << endl;
}
int main()
{	
	//test();
	test02();
	return 0;
}

2、this指针的使用

#include <iostream>
using namespace std;


class person
{
public:
	//正确书写
	//person(int age)
	//{
	//	m_age = age;
	//}

	//int m_age;

	person(int age)
	{
		//1、解决名称冲突
		//age = age;//三个age让编译器混乱了，要么改成上面那种m_age,要么使用this指针
		this->age = age;
		//this指针指向 被调用的成员函数 所属的对象 在这里值的是29行的p！
	}

	int age;

	//
	//如果不用引用的方式返回，相当于返回与p2不同的另一个Person（只是age都是20），那么后续的加年龄操作与！ p2 !就没有关系了
	// 如果不用&就是值传递，相当于创建了个临时变量来代替p2，则后面的数据全加到临时变量身上了
	//即用&返回的是p2的一个别名
	person& personaddage(person& p)
	{
		this->age += p.age;
		return *this;
	}
	

};

//1、解决名称冲突
void test()
{
	person p(10);
	cout << p.age << endl;
}

//2.
void test01()
{
	person p1(10);
	person p2(10);

	p2.personaddage(p1).personaddage(p1).personaddage(p1).personaddage(p1);
	cout << "p2的年龄:" << p2.age << endl;
}
int main()
{
	//test();
	test01();
	return 0;
}

3、空指针调用成员函数

#include<iostream>
using namespace std;

class person
{
public:
	//没有成员属性的成员函数空指针可以调用
	void showclass()
	{
		cout << "showclass的调用" << endl;
	}

	void showage()
	{
	//空指针如果要调用带有成员属性的成员函数，加上这个if条件
		if (this == NULL)
		{
			return;
		}
		//报错原因是传入的指针是NULL，如果还要访问指针NULL里的属性，肯定会报错
		cout <<this->m_Age << endl;
	}
	int m_Age;
};

void test()
{
	person* p = NULL;

	p->showclass();
	p->showage();

}

int main()
{
	test();

	return 0;
}

4、const修饰成员函数

#include<iostream>
using namespace std;

class person
{
public:
	//1、常函数
	//this指针的本质 是指针常量，即指向不可以修改，但值可以改，this相当于 person * const this;
	void show() const  //这里加个const变成！常函数！，相当于 person * const this变成 const  person * const this;所以第10行
	{
		//this->m_a = 100;err //所以this指针对应的值也不可以改变
		//this = NULL;err//this相当于 person * const this; 所以不可以修改指针的指向
		this->m_b = 100;
	}
	void show2()
	{

	}
	int m_a;
	mutable int m_b;//加上mutable后为特殊变量，即使在常函数中，也可以修改这个值
};

void test()
{
	person p;
	p.show();
}

//2、常对象
void test02()
{
	const person p;//在对象前加const，变成常对象
	//p.m_a = 100;err
	p.m_b = 100;//m_b是特殊值，在常对象下也可以修改

	//常对象只能调用常函数
	p.show();
	//p.show2();err//常对象不可以调用普通成员函数，因为普通成员函数可以修改成员属性，所以不能调用
}
int main()
{
	test();

	return 0;
}