c++中static静态成员变量和静态成员函数、explcit和隐式类型转换、友元函数（）详解

1.static静态成员(函数)

1.1概念

声明为 static 的类成员 称为 类的静态成员 ，用 static 修饰的 成员变量 ，称之为 静态成员变量 ；用

static 修饰 的 成员函数 ，称之为 静态成员函数 。 静态成员变量一定要在类外进行初始化

1.2特征

 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

静态成员变量也不能给缺省值，因为缺省值是给初始化列表的，而初始化列表是初始化某个对象的，静态成员变量是属于整个类的，不属于某一个具体对象。

class A {

//静态成员变量在类中声明
public:
	static int Count1;
private:
	static int Count2;
};
//静态成员变量在类外定义并且初始化,
//不需要static修饰，但需要类名::的形式指定类域
int A::Count1 = 1;	
int A::Count2 = 2;

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

静态成员也是类的成员，受 public 、 protected 、 private 访问限定符的限制

class A {
public:
	void abc1()
	{
		//A::public静态成员变量可以在类内表示
		cout << A::Count1<<endl;
	}
	void abc2()
	{
		//A::private静态成员变量可以在类内表示
		cout << A::Count2 << endl;
	}
//静态成员变量在类中声明
public:
	static int Count1;
private:
	static int Count2;
};
//静态成员变量在类外定义并且初始化,
//不需要static修饰，但需要类名::的形式指定类域
int A::Count1 = 1;	
int A::Count2 = 2;
int main()
{
	A aa;
	aa.abc1();
	//public修饰的成员变量可以在类外访问
	cout << A::Count1 << endl;
	cout << aa.Count1 << endl;
	aa.abc2();
	//private修饰的成员变量不能再类外访问
	//cout << A::Count2 << endl;
	//cout << aa.Count2 << endl;
	return 0;
}

静态成员函数 没有 隐藏的 this 指针 ，不能访问任何非静态成员

静态成员函数不能调用非静态成员函数，因为没有this指针

非静态成员函数可以调用类的静态成员函数

class A {
public:
	static int abc1()
	{
		//A::public静态成员变量可以在类内表示
		return Count1;
	}
	static int abc2()
	{
		//A::private静态成员变量可以在类内表示
		return Count2;
	}
	//静态成员变量在类中声明
public:
	static int Count1;
private:
	static int Count2;
};
//静态成员变量在类外定义并且初始化,
//不需要static修饰，但需要类名::的形式指定类域
int A::Count1 = 1;
int A::Count2 = 2;
int main()
{
	A aa;
	//静态成员函数调用时，突破类域就可以
	cout << A::abc1() << endl;
	cout << aa.abc1() << endl;
	return 0;
}

1.3总结

静态成员函数和静态成员变量，本质是受限制的全局变量和全局函数，专属这个类，受访问限定符和类域限制

2.explicit

2.1隐式类型转换

class Date
{
public:
	Date(int year = 2023, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date a1(2023,11,13);
	Date a2;
	Date a3;
	//相当于2024这个整形隐式类型转换为了Date形
	//用2024构造一个临时变量，类型为const Date，临时变量再去赋值构造a2；
	a2 = 2024;
	//c++11规定可以传多个参数
	a3 = { 2024,3,3 };
	return 0;
}

需要注意的是，隐式类型转换的临时变量是const类型，需要考虑权限问题

权限可以平移，可以缩小，但不能被放大！！！

const可以传给const（权限平移），const可以传给非const（权限缩小）

非const成员函数 不能 传给非const（权限放大），非const可以传给const（权限平移）

2.2expilcit的作用

用 explicit 修饰构造函数，将会禁止构造函数的隐式转换 。

但如果是显示类型转换，expilcit是禁止不了的

3.友元

3.1友元函数

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

当我们需要在一个全局函数中访问一个对象中的私有或者保护成员时，需要在类中声明友元函数

class Date
{
	//声明友元函数，注意是声明，不是定义！！！
	friend int add(Date aa);
public:
private:
	int _year;
	int _month;
	int _day;
};
int add(Date aa)
{
	//在全局函数中需要访问一个类的私有时，需要在类中声明友元函数
	return aa._year + aa._month;
}

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

友元函数 不能用 const 修饰

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

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用原理相同

3.2友元类

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

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

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

class Date1
{
	//声明Date2是Date1的友元类，
	//Date2可以访问Date1的私有或者保护成员
	friend class Date2;
private:
	int _year1;
	int _month1;
	int _day1;
};
class Date2
{
public:
	//可以访问Date1中的私有或者保护成员
	int add(Date1 d1)
	{
		return d1._year1;
	}
private:
	int _year2;
	int _month2;
	int _day2;
};