C++回顾（七）—— 面向对象模型

7.1 静态成员变量和静态成员函数

7.1.1 静态成员变量

1. 关键字 static 可以用于说明一个类的成员；
2. 静态成员提供了一个同类对象的共享机制；
3. 把一个类的成员说明为 static 时，这个类无论有多少个对象被创建，这些对象共享这个 static 成员

静态成员局部于类，它不是对象成员，在类的外部进行初始化。

7.1.2 静态成员函数

1. 静态成员函数冠以关键字static；
2. 静态成员函数提供不依赖于类数据结构的共同操作，它没有this指针；
3. 在类外调用静态成员函数用 “类名 :: ”作限定词，或通过对象调用。

疑难问题：静态成员函数中，不能使用普通变量，只能使用静态成员变量。

7.1.3 总结

• 所有同类对象共享同一个静态成员变量；
• 静态成员变量一定要在类的外部初始化；
• 静态成员函数内部只能访问静态成员变量，不能访问普通变量；
• 静态成员变量可以直接通过类名来访问
• 静态成员函数可以通过类名直接访问

#include <iostream>

using namespace std;

class Student
{
public:
	static int count;   //静态成员变量  所有对象共享同一个静态成员变量
private:
	int id;
public:
	Student()
	{
		count++;
		id = count;
	}

	static int getCount()   //静态成员函数
	{
		//id++;  //静态成员函数内部只能访问静态成员变量，不能访问普通变量（这里报错）
		return count;
	}
};

//注：静态成员变量一定要在类的外部初始化
int Student::count = 0;

int main()
{
	Student s1;
	Student s2;

	cout << Student::count << endl;   //静态成员变量可以直接通过类名来访问
	cout << s1.getCount() << endl;
	cout << Student::getCount() << endl;   //静态成员函数可以通过类名直接访问

	return 0;
}

运行结果：

7.2 面向对象模型

7.2.1 基础知识

• C++中的class从面向对象理论出发，将变量(属性)和函数(方法)集中定义在一起，用于描述现实世界中的类。从计算机的角度，程序依然由数据段和代码段构成。

• C++编译器如何完成面向对象理论到计算机程序的转化？
  换句话：C++编译器是如何管理类、对象、类和对象之间的关系？
  具体的说：具体对象调用类中的方法，那，c++编译器是如何区分，是那个具体的类，调用这个方法那?

7.2.2 编译器对成员变量和成员函数的处理机制

• 通过上面的案例，我们可以的得出：
  C++类对象中的成员变量和成员函数是分开存储的

• （1）成员变量：
  普通成员变量：存储于对象中，与struct变量有相同的内存布局和字节对齐方式
  静态成员变量：存储于全局数据区中
  

• （2）成员函数：
  存储于代码段中。

问题出来了：
很多对象共用一块代码？代码是如何区分具体对象的那？
换句话说：int getK() const { return k; }，代码是如何区分，具体obj1、obj2、obj3对象的k值？==>(通过 this 指针）

7.2.3 总结

• 1、C++类对象中的成员变量和成员函数是分开存储的。C语言中的内存四区模型仍然有效
• 2、C++中类的普通成员函数都隐式包含一个指向当前对象的this指针。
• 3、静态成员函数与普通成员函数的区别：
  静态成员函数不包含指向具体对象的指针
  普通成员函数包含一个指向具体对象的指针

#include <iostream>

using namespace std;

class Test
{
private:
	int a;
	char b;    
public:
	Test(int _a)
	{	
		this->a = _a;
	}
	void show()    //等价于void show(Test *this)   所有的成员函数隐藏了一个参数 this指针
	{
		cout << this->a << endl;
	}
};

int main()
{
	Test t1(0);
	cout << sizeof(t1) << endl;  //不包含静态成员变量

	Test t2(1);

	t1.show();   //等价于 t1.show(&t1);
	t2.show();   //等价于 t2.show(&t2);

	return 0;
}

运行结果：

7.2.4 const修饰成员函数

• const关键字写在函数名的后面；
• 常函数只能访问访问变量，不能修改变量。
  
  示例代码：

#include <iostream>

using namespace std;

class Test
{
private:
	int a;
	int b;
public:
	Test()
	{
		a = 0;
		b = 1;
	}
	void show() const   //注意位置 常函数
	{
		//a++;             //常函数只能访问变量，不能修改变量（所以这里会报错）
		cout << a << " "  << b << endl;
	}
};

int main()
{
	Test t1;
	t1.show();

	return 0;
}

运行结果：

7.2.5 全局函数和成员函数

• 1、把全局函数转化成成员函数，通过this指针隐藏左操作数

Test add(Test &t1, Test &t2)  ===》  Test add(Test &t2)

• 2、把成员函数转换成全局函数，多了一个参数

void printAB()  ===》  void printAB(Test *pthis)

• 3、函数返回元素和返回引用

Test& add(Test &t2) //*this //函数返回引用
{
    this->a = this->a + t2.getA();
    this->b = this->b + t2.getB();
    return *this; //*操作让this指针回到元素状态
} 

Test add2(Test &t2) //*this //函数返回元素
{
    //t3是局部变量
    Test t3(this->a+t2.getA(), this->b + t2.getB()) ;
    return t3;
}

代码示例：

#include <iostream>

using namespace std;

class Test
{
	friend void show(Test &t);   //声明友元函数
private:
	int a;
public:
	Test()
	{
		a = 100;
	}
	void show()
	{
		cout << this->a << endl;
	}
};

void show(Test &t)  //成员函数改成全局函数  需要添加一个参数
{
	//cout << a << endl;  //a是成员变量 通过对象来访问（这里会报错）
	cout << t.a << endl;   //友元函数可以访问类的私有成员变量
}

int main()
{
	Test t1;
	t1.show();

	show(t1);

	return 0;
}

运行结果：

7.3 友元

7.3.1 友元函数

友元函数不是类的内部函数，是一个全局函数，但是可以改变类的私有属性
友元函破坏了类的封装性

7.3.2 友元类

若B类是A类的友员类，则B类的所有成员函数都是A类的友员函数
友员类通常设计为一种对数据操作或类之间传递消息的辅助类

示例代码：

#include <iostream>

using namespace std;

class A
{
	friend class B;   //友元类  可以在类B中访问类A的私有成员变量
private:
	int a;
};

class B
{
public:
	void print(A &ta)
	{
		cout << ta.a << endl;
	}
};

int main()
{
	return 0;
}