C++类和对象——对象特性

目录

（1），成员变量和成员函数分开存储

（2），this指针 

（3），空指针访问成员函数

（4），const修饰成员函数

---

（1），成员变量和成员函数分开存储

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

只有非静态成员变量占用对象空间，静态成员表变量、静态成员函数以及非静态成员函数都不占用对象空间；

#include <iostream>
using namespace std;
#include <string>

class A{};  //不包括任何成员的类，所占内存空间为1

class B     //只包含一个静态成员变量的类
{
	static int a;
};

int B::a = 0;

class C    //包含一个非静态成员变量的类
{
	int b;
};

class D     //包含一个静态成员函数的类
{
	static void func()
	{
		
	}
};

class E      //包含一个非静态成员函数的类
{
	void func()
	{

	}
};

void test()
{
	A a;
	cout << "不包括任何成员的类对象所占空间：" << sizeof(a) << endl;

	B b;
	cout << "只包含一个静态成员变量的类对象所占空间：" << sizeof(b) << endl;

	C c;
	cout << "只含一个非静态成员变量的类对象所占空间：" << sizeof(c) << endl;

	D d;
	cout << "只含一个静态成员函数的类对象所占空间：" << sizeof(d) << endl;

	E e;
	cout << "只含一个非静态成员函数的类对象所占空间：" << sizeof(e) << endl;
}

int main()
{
	test();
	system("pause");
	return 0;
}

运行结果：

不包括任何成员的类对象所占空间：1
只包含一个静态成员变量的类对象所占空间：1
只含一个非静态成员变量的类对象所占空间：4
只含一个静态成员函数的类对象所占空间：1
只含一个非静态成员函数的类对象所占空间：1
请按任意键继续. . .

（2），this指针 

所有对象共用一个成员函数，也就是多个同类型的对象共用一块代码，这一块代码如何区分是哪个对象调用自己的呢？

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

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

this指针有两种用途：

第一种用途：当形参和成员变量同名时，可使用this指针区分；

下边例子中 成员函数的形参名和成员变量名相同，实际中一般在成员变量名前加m，例如m_Age；

#include <iostream>
using namespace std;
#include <string>

class person
{
public:

	void func(int age)
	{
		this->age = age;
	}

	int age;

};

void test()
{
	person p;

	p.func(10);

	cout << "p的年龄：" << p.age << endl;
}

int main()
{
	test();
	system("pause");
	return 0;
}

第二种用途： 在类的非静态成员函数中返回对象本身，可使用return *this；

#include <iostream>
using namespace std;
#include <string>

class person
{
public:
	person& func(person p)
	{
		m_Money = p.m_Money + m_Money;
		return *this;
	}

	int m_Money;

};

void test()
{
	person p1;
	p1.m_Money = 10;

	person p2;
	p2.m_Money = 20;

	person p3;
	p3.m_Money = 50;

	p1.func(p2).func(p3);

	cout << "p1的money：" << p1.m_Money << endl;
}

int main()
{
	test();
	system("pause");
	return 0;
}

上边例子中类中的成员函数返回值时对象的应用，p1.func(p2).func(p3)也称为链式编程，与cout的用法类似；

注意：成员函数的返回值是类的引用person&，如果返回值是类，则实现不了这种链式编程，因为如果返回值是类，则返回值会重新复制一个对象；

this指针本质是一个指针常量，指针常量的指向不可修改，指针指向的值可以修改；

（3），空指针访问成员函数

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

#include <iostream>
using namespace std;
#include <string>

class person
{
public:
	void func1()
	{
		cout << "这是一个成员函数，不涉及到使用this指针" << endl;
	}

	void func2()
	{
		cout << "这是一个成员函数，使用到this指针" << endl;
		if (this == NULL)
			return;

		m_Age = 100;
	}

	int m_Age;
};

void test()
{
	person* p = NULL;
	p->func1();
	p->func2();
}

int main()
{
	test();
	system("pause");
	return 0;
}

本示例中如果成员函数没有用到this指针，NULL指针可以直接调用成员函数；

如果成员函数涉及到使用this指针，需要判断this指针是否是NULL，因为NULL指针不指向任何对象实体，通过NULL操作成员变量不会成功；

注意：成员函数内都隐藏着this指针。

（4），const修饰成员函数

成员函数后边加上const后，这个函数称为常函数；

常函数内不可以修改普通成员变量；

成员属性声明加关键字mutable后，在常函数中可以修改；

声明对象时前加上const，该对象就称为常对象；

常对象只能调用常函数，以及访问加上mutable关键字的成员变量；

#include <iostream>
using namespace std;
#include <string>

class person
{
public:
	void func() const
	{
		m_A = 100;
	}

	mutable int m_A;
};

void test()
{
	const person p;
	p.func();
	cout << p.m_A << endl;
}

int main()
{
	test();
	system("pause");
	return 0;
}

我们已经知道成员函数中默认存在this指针，并且this指针时常量指针，

可以认为this指针的类型是这样的：person * const this，可以看出是无法修改this指针的指向的，也就是this指针只能指向调用成员函数的对象；

如果在成员函数后边加上const后，this指针的类型就为：const person* const this ，因此此时this指针指向的值也不能修改了，所以在常函数内部不能对普通成员属性的值进行操作。