[C++笔记]静态成员，友元函数与友元类，内部类

静态成员

声明为static的类成员称为类的静态成员。用static修饰的成员变量，称之为静态成员变量，而用static修饰的成员函数，称之为静态成员函数。

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。
2. 静态成员变量必须在类外定义，定义时不添加static关键字，在类内部的只是声明。
3. 类的静态成员可用 类名::静态成员 或者 对象.静态成员 来访问。
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员。
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制。

可以认为静态成员函数是为了便于突破类域访问静态成员变量而生的。

使用例1：实现一个类，计算程序中创建了多少个类对象。
-已知:类对象的创建一定会调用构造函数或拷贝构造函数。

#include<iostream>
using namespace std;

class A {
public:
	A(int a = 0){
		++count;
	}
	A(const A& aa){
		++count;
	}

	//静态成员函数，不专属于某个对象，没有this指针，所以只能访问静态成员
	static int GetCount() {
		//++_a;//不能直接访问非静态成员
		return count;
	}

private:
	static int count;//静态成员必须在类外定义，在类内部的只是声明。静态成员为所有类对象所共享，不属于某个具体的对象。
	int _a = 0;//非静态成员变量
};

int A::count = 0;//只能在类外定义并初始化静态成员(可以只定义不初始化)，注意类外无static。

void func() {
	A aa1;
	A aa2(aa1);
	A aa3 = 1;
	A aa4[10];//10个对象的自定义类型数组，每个对象都会调用构造函数初始化
	//c99开始支持变长数组
}

int main() {
	func();
	cout << A::GetCount() << endl;
	return 0;
}

使用例2：

基于例1的方式：

class Sum{
public:
    Sum(){
    	//在构造函数内实现步进
        _sum += _i;
        ++_i;
    }
    static int GetSum(){
        return _sum;
    }
private:
	//类内声明静态成员变量
    static int _i;
    static int _sum;
};

//定义并初始化静态成员变量
int Sum::_i = 1;
int Sum::_sum = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        //使用数组来自动调用n次构造函数以代替循环 
        Sum a[n];
        	//vs对变长数组支持不佳，oj通常都支持。
        	//若一定要在vs跑，可以改成下方语句，然后补上main函数。
        		//Sum* ptr = new Sum[n];
        return Sum::GetSum();
    }
};

友元

友元提供了一种突破封装的方式，有时提供便利，但也会增加耦合度，破坏封装，所以友元应尽量少用。

友元分为：友元函数和友元类

友元函数

格式：friend 类型 函数名 (参数)

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

-友元函数可访问类的私有和保护成员，但不是类的成员函数。
-友元函数不能用const修饰，因为const修饰的是*this，而友元函数没有this指针。
-友元函数可以在类定义内的任何地方声明，不受类访问限定符限制。
-一个函数可以是多个类的友元函数。
-友元函数的调用与普通函数的调用和原理相同。

#include<iostream>
using namespace std;

class Date{
	//声明友元函数
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

//被声明为友元的函数
ostream& operator<<(ostream& _cout, const Date& d){
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
istream& operator>>(istream& _cin, Date& d){
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}

int main(){
	Date d;
	cin >> d;
	cout << d << endl;
	return 0;
}

友元类

若A类为B类的友元，则A类的所有成员都能访问B类中的非公有成员。

格式：friend class 类名

-类的友元关系是单向的，不具有交换性：当类A是类B的友元，并不代表类B是类A的友元，要看在类中是否有相应的申明。
-类的友元关系不能传递：当C是B的友元， B是A的友元，并不代表C是A的友元，也要看在类中是否有相应的申明。
-友元关系不能继承。

#include<iostream>
using namespace std;

class Time{
	friend class Date; //声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _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;
};

内部类

(java常用内部类,c++不常用)

-定义在一个类的内部的类叫做内部类。
-内部类是一个独立的类，不属于外部类，不能通过外部类的对象去访问内部类的成员。
-外部类对内部类没有访问权限上的优越性。
-内部类天生就是外部类的友元类。参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元类。
-内部类比友元类多了一点权限：可以不加类名的访问外部类中的static、枚举成员。

特性：

1. 内部类可以定义在外部类的public、protected、private中，受相应的访问限定符影响，也受外部类的类域限制。
2. 内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=不包含内部类的外部类大小，内部类的空间是独立的。

#include<iostream>
using namespace std;

class A{
private:
	static int k;
	int h;
public:
	class B {//内部类B天生就是外部类A的友元
	public:
		void foo(const A& a){
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
};

int A::k = 1;

int main(){
	A::B b;
	b.foo(A());
	return 0;
}