C++入门--友元、静态成员、单例设计模式、成员变量和函数的存储

友元

类的主要特点之一是数据隐藏，即类的私有成员无法在类的外部访问，但是我们有时候需要在类的外部访问类的私有成员。那么我们可以使用友元来解决，友元是一种特权，允许访问类的私有成员。友元分为：友元函数和友元类。

友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但是需要在类的内部声明，声明时需要加friend关键字。

实例代码：

class Date{
	friend ostream&(ostream& cout,const Date& date);
	friend istream&(istream& cin,Date& date);
public:
	Date(int year,int month,int day):_year(year),_month(month),_day(day){}
private:
	int _year;
	int _month;
	int _day;
}

ostream& operator<<(ostream& cout,const Date& date){
	cout<<date._year<<date._month<<date._day;
	return cout;
}
istream& operator>>(istream& cin,Date& date){
	cin>>date._year;
	cin>>date._month;
	cin>>date._day;
	return cin;
}
int main()
{
	Date d;
	cin>>d;
	cout<<d<<endl;
	return 0;
}

注意：

■ 1、友元函数可以访问类的私有和保护成员，但不是类的成员函数。

■ 2、友元函数不能用const修饰。

■ 3、友元函数可以在类定义的任何地方声明，不受类访问限定符限制。

■ 4、一个函数可以时多个类的友元函数。

■ 5、友元函数的调用和普通函数的调用和原理相同。

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

注意：

■1、友元关系是单向的，不具有交换性。

比如下述实例Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行

■2、友元关系不能传递。

如果B是A的友元，C是A的友元，则不能说明C是A的友元。

实例代码1：

class Date; // 前置声明
class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour, int minute, int second): _hour(hour), _minute(minute), _second(second){}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}
	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t.second = second;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

实例代码2：

class Window_mgr {
public:
	void clear();
};
class Screen {
	friend void Window_mgr::clear();
public:
	Screen() = default;
	Screen(string str) {
		this->contents = str;
	}
private:
	string contents;
};

void Window_mgr::clear() {
	Screen sc("Hello Friend!!");
	cout << sc.contents << endl;
}

我们还可以把某个类的成员函数声明成友元，这时我们必须明确指出该成员函数属于哪个类。这时我们需要考虑声明和定义的彼此依赖关系：

• 首先定义Window_mgr类，其中声明clear函数，但是不能定义它，在clear使用Screen的成员之前必须先声明Screen。
• 然后定义Screen，包括对于clear的友元声明。
• 最后定义clear，此时它才可以使用Screen的成员。

静态成员

在类定义中，它的成员（包括成员变量和成员函数），这些成员可以用关键字static声明为静态的，称为静态成员。不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被所有属于这个类的对象共享。

静态成员变量

在一个类中，若将一个成员变量声明为static，这种成员称为静态成员变量。与一般的数据成员不同，无论建立了多少个对象，都只有一个静态数据的拷贝。静态成员变量，属于某个类，所有对象共享。静态变量，是在编译阶段就分配空间，对象还没有创建时，就已经分配空间。

特征

■ 1、静态成员变量必须在类中声明，在类外定义。

■ 2、静态数据成员不属于某个对象，在为对象分配空间时不包括静态数据成员所占的空间。

■ 3、类静态成员即可用类名::静态成员或者对象.静态成员来访问。

实例代码：

class Person {
public:
	static int Num;
private:
	static int Other;
};
//静态数据成员在类外初始化，初始化时不加static 
int Person::Num = 0;
int Person::Other = 0;


int main() {
	//1. 通过类名直接访问
	Person::Num = 100;
	cout << "Person::Num:" << Person::Num << endl;

	//2. 通过对象访问
	Person p1, p2;
	p1.Num = 200;

	cout << "p1.Num:" << p1.Num << endl;
	cout << "p2.Num:" << p2.Num << endl;

	//3. 静态成员也有访问权限，类外不能访问私有成员
	//cout << "Person::Other:" << Person::sOther << endl;
	Person p3;
	//cout << "p3.Other:" << p3.Other << endl;

	return 0;
}

静态成员函数

在类定义中，前面用static说明的成员函数称为静态成员函数。静态成员函数使用方式和静态变量一样，同样在对象没有创建前，即可通过类名调用。静态成员函数主要为了访问静态变量，不能访问普通成员变量。静态成员函数的意义，不在于信息共享，数据沟通，而在于管理静态数据成员，完成对静态数据成员的封装。

特征

■ 1、静态成员函数没有隐藏的this指针，静态成员函数只能访问静态变量，不能访问普通成员变量。

■ 2、普通成员函数可访问静态成员变量和非静态成员变量。

■ 3、静态成员和类的普通成员一样，也有public、protected、private 3种访问级别，也可以具有返回值。

实例代码：

class Person{
public:
	//普通成员函数可以访问static和普通成员属性
	void changeParam1(int param){
		Param = param;
		Num = param;
	}
	//静态成员函数只能访问static成员属性
	static void changeParam2(int param){
		//Param = param; //无法访问
		Num = param;
	}
private:
	static void changeParam3(int param){
		//Param = param; //无法访问
		Num = param;
	}
private:
	int Param;
	static int Num;
};
//静态成员属性类外初始化
int Person::Num = 0;
int main(){
	//1.类名直接调用
	Person::changeParam2(300);
	
	//2.通过对象直接调用
	Person p;
	p.changeParam2(400);
	
	//3.静态成员函数也有访问权限
	//Person::changeParam3(300); //类外无法访问私有静态成员函数
	//Person p1;
	//p1.changeParam3(400);
	
	return 0;
}

const静态成员属性

如果一个类的成员，既要实现共享，又要实现不可改变，那就要用static const修饰。定义静态const数据成员，最好在类内部初始化。

实例代码：

class Person{
public:
	static const int share=100;//只读区不可修改
}
int main(){
	cout<<Person::share<<endl;
	return 0;
}

单例设计模式

单例设计模式它的核心结构中只包含一个被称为单例的特殊类，可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约资源。

单例设计的实现

在单例类的内部实现只生成一个实例，同时它提供一个静态的getInstance()工厂方法，让客户可以访问它唯一实例。为了防止在外部对其实例化，将其默认构造函数和拷贝构造函数设计为私有；在单例类内部定义一个Singleton类型的静态对象，让作为外部共享的唯一实例。

单例设计的实例

模拟公司员工使用打印机场景，打印机打印员工要输出的内容，并且可以累计打印机使用次数。

class Printer{
public:
	//返回外部共享的唯一实例
	static Printer* getInatance(){
		return this->singlePrinter;
	}
	void PrintText(string text){
		cout << "打印内容:" << text << endl;
		cout << "已打印次数:" << times << endl;
		cout << "--------------" << endl;
		times+;
	}

private:
	//防止外部进行实列化
	Printer(){
		times=0;
	}
	Printer(const Printer& printer){}
private:
	int times;
	//在内部只生成一个实例
	static Printer *singlePrinter;
	
}

Printer* Printer::singlePrinter=new Printer;

成员变量和函数的存储

问题：C++实现了封装，那么成员属性和成员方法又是怎样存储的呢？
答案：成员属性和成员函数是分开存储的。

C++中非静态数据成员直接内含在类对象中，每个对象都有自己数据，但是每一个非内敛成员函数虽然内含在class声明中的，但是却不出现在对象中只会诞生一份函数实例，也就是每个对象共享成员函数，对于不同的对象使用this指针来找到每个对象的数据。

实例代码：

class MyClass01{
public:
	int mA;
};

class MyClass02{
public:
	int mA;
	static int sB;
};

class MyClass03{
public:
	void printMyClass(){
		cout << "hello world!" << endl;
	}
public:
	int mA;
	static int sB;
};

class MyClass04{
public:
	void printMyClass(){
		cout << "hello world!" << endl;
	}
	static void ShowMyClass(){
		cout << "hello world！" << endl;
	}
public:
	int mA;
	static int sB;
};

class Myclass05{}
int main(){

	MyClass01 mclass01;
	MyClass02 mclass02;
	MyClass03 mclass03;
	MyClass04 mclass04;
	Myclass05 mclass05;
	cout << "MyClass01:" << sizeof(mclass01) << endl; //4
	//静态数据成员并不保存在类对象中
	cout << "MyClass02:" << sizeof(mclass02) << endl; //4
	//非静态成员函数不保存在类对象中
	cout << "MyClass03:" << sizeof(mclass03) << endl; //4
	//静态成员函数也不保存在类对象中
	cout << "MyClass04:" << sizeof(mclass04) << endl; //4
	//空类的大小
	cout << "MyClass05:" << sizeof(mclass05) << endl; //1
	return 0;
}

运行结果：

结论：通过上述实例可以看出C++类对象中的变量和函数是分开存储的。一个类的实际大小，就是该类的非静态成员变量之和，当然还要字节对齐，注意空类的大小，编译器给空类一个字节来唯一标识这个类。

关于字节对齐的详细讲解可以看看我的另一篇博客：C语言字节对齐、位域、枚举、联合体