C++：类与对象3

继续写一下类和对象的一些知识；

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

在下列代码中，分别定义非静态成员变量和静态成员变量，来计算类的对象的大小，以验证创建的变量是不是存储在类上。

计算类的大小所用的函数为：

void test01()
{
	Person p;
	cout << "size of p =" << sizeof(p) << endl;
}

首先应该明确：    

    空对象占用内存空间为1
    c++编译器会给每个空对象也分配一个字节空间，为了区分空对象占内存的位置

所以：

class Person
{};

大小为1个字节；

然后为为类分别添加非静态和静态的成员变量和成员函数，逐次验证类的大小，得到以下结论：

只有非静态成员变量属于类的对象上，增加类的大小；

静态成员变量和成员函数（静态和非静态）都不属于类的对象上，不增加类的大小；

class Person
{
	int m_A;//非静态成员变量 属于类的对象上  只有这种变量属于类的对象上
	static int m_B;//静态成员变量 共享，不属于类的对象上，不增加类的大小
	void func()//非静态成员函数 不增加类的大小
	{}
	static void func2() {}//静态成员函数 共享，不属于类的对象上，不增加类的大小
};
int Person::m_C = 0;

---

this指针

this指针 - 指向被调用的成员函数所属的对象
1、当形参和成员变量同名时，可用this指针来区分 - 解决名称冲突
2、在类的非静态成员函数中返回对象本身，可用return *this

首先创建一个Person类：

包含有参构造函数

class Person
{
public:
	Person(int age)
	{
		this->age = age;//指向被调用的 成员函数 所属的对象 - 指向p1
	}
	int age;


	Person& PersonAdddAge(Person& p)
	{
		this->age+=p.age;
		return *this;
	}
};

两个测试函数：

void test01()
{
	Person p1(18);
	cout << "p1 age:" <<p1.age<< endl;
}

在上段代码中，传入的形参也是age，与类中的成员变量重名，所以用this->age来代表此age是被调用的成员函数所属的对象。

void test02()
{
	Person p1(10);
	Person p2(10);
	p2.PersonAdddAge(p1).PersonAdddAge(p1).PersonAdddAge(p1);//链式编程思想
	cout << "p2 age:" <<p2.age<< endl;
}

在链式编程思想中，用return *this在类的非静态成员函数中返回对象本身，以达到进阶访问的需求

空指针（NULL)也可以调用成员函数，但是要注意有没有用到this指针，如果用了this，需要加以判断保证代码的健壮性。具体见注释：

class Person
{
public:
	void showClassName()
	{
		cout << "this is person class" << endl;
	}
	int m_Age;
	void showPersonAge()
	{
		if (this == NULL)//解决空指针访问实际对象成员的问题
		{
			return;
		}
		cout << "age:"<<this->m_Age << endl;
	}
};
void test01()
{
	Person* p = NULL;
	p->showClassName();//空指针可以访问此行代码
	p->showPersonAge();//this指向的是一个NULL，没有确定的对象，访问不到指定对象的成员
}

---

常函数

在成员函数后加const，使成员函数变为常函数

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

常对象：声明对象前加const，只能调用常函数

下面将不用常函数和常函数做一个比较：

非 常函数：

class Person
{
public:
	void showperson()
	{
		m_A = 100;//可以修改m_A;
	}
	int m_A;
};

常函数：

void showperson()const
	{
		m_A = 100;//不可以修改m_A;
		//相当于this->m_A=100;this指针的本质是指针常量，Person* const this;指向不可修改
		this = NULL;//err,this指向不可修改,但是指向的值可以修改
		//本函数void showperson()const相当于const Person* const this;值也不能修改

		this->m_B = 100;//right
	}
int m_A;
mutable int m_B;//特殊变量，即使在常函数中也可以修改这个值

而在使用常对象时：

void test02()
{
	const Person p;//常对象
	p.m_A = 100;//err
	p.m_B = 100;//right,常对象下也能修改

	//常对象只能调用常函数
	p.showperson();
	p.func();//常对象不可以调用普通成员函数，因为普通成员函数可以修改属性，常对象不可修改
}

---

友元：让一个函数或类，访问另一个类中的私有成员

关键字为friend - 有些私有属性也可以让类外特殊的一些函数或者类进行访问

三种实现方法：全局函数做友元；类做友元；成员函数做友元。

1、全局函数做友元

全局函数可以访问私有成员
class Building
{
	friend void goodGay(Building* building);//友元，goodGay函数可以访问私有成员
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};
//全局函数
void goodGay(Building *building)
{
	cout << "客厅" << building->m_SittingRoom << endl;
	cout << "卧室" << building->m_BedRoom << endl;//err，类内加friend void goodGay(Building *building)后可访问
}
void test01()
{
	Building building;
	goodGay(&building);
}

2、类做友元

//2类可以访问另一个类的私有成员
class Building
{
	friend class goodgay;//goodgay类 可以访问Building中的私有成员
	public:
		Building();

	public:
		string m_SittingRoom;
	private:
		string m_BedRoom;
};
class goodgay
{
public:
	goodgay();
	void visit();//访问building中的属性
	Building* building;
};
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}
goodgay::goodgay()
{
	building = new Building;
}
void goodgay::visit()
{
	cout << "goodgay:" << building->m_SittingRoom << endl;
	cout << "goodgay:" << building->m_BedRoom << endl;
}
void test01()
{
	goodgay gg;
	gg.visit();
}

3、成员函数做友元 

下面的代码要注意一点：因为是先定义的goodgay类，后定义的Building类，但是在goodgay类中使用了Building类，所以要先声明Building类。

#include<string>
class Building;//开头先申明，因为在下面goodgay类中要使用
class goodgay
{
public:
	goodgay();
	void visit1();//让visit1函数可以访问Building中的私有成员
	void visit2();//让visit2函数不可以访问Building中的私有成员
	Building * building;//要在此行使用Building类，需要在此类之前先声明Building，要不然编译器找不到
};
class Building
{
friend void goodgay::visit1();//goodgay类下的visit1成员函数作为本类的友元，可以访问私有内容
public:
	Building();
public:
	string m_sittingroom;
private:
	string m_bedroom;
};
//类外实现成员函数
Building::Building()
{
	m_sittingroom = "客厅";
	m_bedroom = "卧室";

}
goodgay::goodgay()
{
	building = new Building;
}
void goodgay::visit1()
{
	cout << "visit1访问" << building->m_sittingroom << endl;
	cout << "visit1访问" << building->m_bedroom << endl;
}
void goodgay::visit2()
{
	cout << "visit2访问" << building->m_sittingroom << endl;
	cout << "visit2访问" << building->m_bedroom << endl;//err
}

void test01()
{
	goodgay gg;
	gg.visit1();
	gg.visit2();
}