＜C++＞初始化列表_static成员_友元

目录

一、初始化列表

excplicit关键字

 二、static成员

三、友元

---

一、初始化列表

class Date
{
public:
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
private:
 int _year;
 int _month;
 int _day;
};

对于构造函数，如上代码，在创建对象时，调用构造函数后，类成员会有一个初始值，但这样并不是初始化，初始化只能有一次，而在函数里可以有多次赋值。

使用初始化列表才是对类成员的初始化：

在函数定义后面加”:“，有多个值用逗号隔开

class A
{
public:
	A(int a = 10, int b = 20)
		:_a(a)
		,_b(b)
	{

	}
private:
	int _a;
	int _b;
};

此外，C++11中对于缺省参数的补丁其实本质也是初始化列表

class A
{
public:

private:
	int _a = 10;
	int _b = 20;
};

注意：

1、初始化列表中的成员变量只能初始化一次

2、引用成员变量、const成员变量、没有默认构造函数的自定义类

初始化列表的成员变量初始化顺序是根据声明顺序，而不是给值的顺序

excplicit关键字

防止隐式类型转化

构造函数不仅可以用于初始化的作用，还可以用于隐式类型转换。

class A
{
public:
	A(int a = 10)
		:_a(a)
	{

	}
private:
	int _a = 10;
	int _b = 20;
};

int main()
{
	A a1(100);
	A a2 = 200; //发生类型转换，先生成tmp临时变量，在将tmp拷贝给a2

	return 0;
}

在构造函数前面加一个explicit关键字就可以制止类型转换

 二、static成员

在类中的成员变量是所有这个类共享的，且只能在类外定义和初始化。

 静态成员函数没有this指针，所以无法访问普通成员变量，但可以访问静态成员变量。

访问静态成员时，可以类名：：静态成员

三、友元

友元是一种突破class类封装的一种语法

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

friend关键字

友元顾名思义就是这个类的朋友。类外部的函数是不能访问类的私有成员的，使用友元就可以使其能够访问类的私有成员

语法：在类中用friend关键字声明外部的函数、类等

友元函数

在类中声明外部定义的函数，外部的函数就可以访问类中的私有成员

class A
{
	friend void Print(A& a1); //声明是A类的友元函数
public:
	A(int a = 0)
		:_a(a)
	{

	}
private:
	int _a;
};

void Print(A& a1)
{
	cout << a1._a;
}

int main()
{
	A a1(10);

	Print(a1);

	return 0;
}

友元类

在类中声明外部定义的类，外部定义的类就可以访问这个类中的私有成员了

注意：B是A的友元类，但A并不是B的友元类

class A
{
	friend class B; //声明B是A的友元类
public:
	A(int a = 0)
		:_a(a)
	{

	}
private:
	int _a;
};

class B
{
public:
	B(int b = 0)
		:_b(b)
	{

	}

	void Print(A& a1)
	{
		cout << a1._a;
	}
private:
	int _b;
};


int main()
{
	A a1(10);
	B b1;

	b1.Print(a1);

	return 0;
}

内部类

在类中定义类，比如在A类中定义B类，B类就是A的友元类，但A不是B的友元类

内部类

• 注意定义在public、private、protect都是可以的
• 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
• . sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
public:
	A(int a = 0)
		:_a(a)
	{

	}
private:
	int _a;

public:
	class B
	{
	public:
		B(int b = 0)
			:_b(b)
		{

		}

		void Print(A& a1)
		{
			cout << a1._a;
		}
	private:
		int _b;
	};
};

int main()
{
	A a1(10);
	A::B b1;

	b1.Print(a1);

	return 0;
}