【C++学习】类和对象--对象特性（2）

静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。

静态成员变量：

        所有对象共享同一份数据

        在编译阶段分配内存

        类内声明，类外初始化

静态成员函数：

        所有对象共享同一个函数

        静态成员函数只能访问静态成员变量

 类内声明，类外初始化

#include<iostream>
using namespace std;
class person
{
	//1.所有对象共享同一份数据
	//2.在编译阶段分配内存
	//3.类内声明，类外初始化
public:
	static int m_A;
};
void test()
{
	person p;
	cout << p.m_A << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

会报错：

 需要在类外声明：

int person::m_A = 100;

静态成员变量     不属于某个对象上，所有对象都共享同一份文件

因此静态成员变量有两种访问方式

//1.通过对象进行访问
person p;
cout << p.m_A << endl;

(只有静态成员能使用   方式2  访问） 

//2.通过类名进行访问
cout<<person::m_A<<endl;

静态成员函数

    //1.所有对象共享同一个函数
    //2.静态成员函数只能访问静态成员变量

 访问方式

    //1.通过对象访问
	person p;
	p.func();
	//2.通过类名访问
	person::func();

对这里能通过类名访问的理解：

因为静态成员函数不属于某一个对象上面，大家共享同一个。无需创建对象就可以访问。

对象模型

成员变量和成员函数分开存储。

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

空对象占用内存空间为1。

C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置，每个空对象也应有一个独一无二的内存地址。

this指针

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码，

那么，如何区分哪个对象调用自己的呢？

C++通过提供特殊的对象指针，this指针，解决上述问题，this指针指向被调用的成员函数所属的对象。（this指针被每一个非静态成员函数隐含，this指针无需定义，直接使用即可）

 用途：

1.解决名称冲突

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

2.返回对象本身

class person
{
public:
	person(int age)
	{
		this->age = age;
	}
	person& personaddage(person &p)
	{
		this->age += p.age;
		return *this;
	}
	int age;
};
void test()
{
	person p1(10);
	person p2(10);
	p2.personaddage(p1).personaddage(p1).personaddage(p1);//链式编程思想
	cout << p2.age << endl;
}

空指针调用成员函数

C++允许空指针调用成员函数

#include<iostream>
using namespace std;
class person
{
public:
	void showname()
	{
		cout << "person类" << endl;
	}
	void showage()
	{
		cout << m_age << endl;//默认this->m_age,但这里this是空指针，所以出现问题
	}
	int m_age;
};

void test()
{
	person* p=NULL;
	p->showname();
	p->showage();//这里会出错
}
int main()
{
	test();
	system("pause");
	return 0;
}

解决办法：

void showage()
	{
		if (this == NULL)
		{
			return;
		}
		cout << m_age << endl;
	}

const修饰成员函数

常函数：（成员函数后加const后，称为常函数）

        常函数内不可以修改成员属性

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

---

m_a=100;//相当于this->m_a=100

this指针的本质是指针常量，指针的指向不可修改 （person*const this）

const person*const this

在成员函数后面加const ，修饰的是this指向，让指针指向的值也不可修改

---

 加了mutable之后即使是在常函数里也可以修改。

常对象：（声明函数前加const后，称为常对象）

        常对象只能调用常函数。

 总结：

常函数/常属性  让成员属性  不可修改，加了mutable关键字就可以了。