【C++】初始化列表、static成员、友元、内部类

目录

1.构造函数初始化的细节

1.1构造函数体内的赋值

1.2初始化列表

1.3 explicit关键字

2.static成员

2.1概念

3.友元函数

3.1友元类

4.内部类

5.匿名对象

---

1.构造函数初始化的细节

1.1构造函数体内的赋值

创建对象时，编译器会自动调用构造函数，给每个成员一个合适的初始值。

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

上面的构造函数的调用后，只能说给每个成员变量赋值了，并不能称为初始化，在构造函数的函数体内只能称之为赋值，赋值是可多次赋值的，初始化只能一次。

1.2初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟 一个放在括号中的初始值或表达式。

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

注意：每个成员变量只能在初始化列表出现一次（初始化只能一次）

        类中包含：const成员变量、引用成员变量、自定义类型成员变量的一定要在初始化列表初始化。

        尽量使用初始化列表，自定义类型的变量一定会调用初始化列表。

class A
{
public:
	void print()
	{
		cout<<x<<endl;
	}
private:
	int x = 0;
};

class Date
{
public:
	Date(int day)
	{}
private:
	int _day;
	A _a;
};

int main()
{
	Date d(1);
	return 0;
}

成员变量初始化的顺序是按照在类里面声明的顺序，与初始化列表的顺序无关。

1.3 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值 的构造函数，还具有类型转换的作用。explicit修饰构造函数，禁止类型转换。

 去掉explicit关键字后：

编译通过，编译器会用2003构造一个无名对象，最后用无名对象给d对象进行赋值。就相当于从int类型转换到Date类型了。

2.static成员

2.1概念

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

class A
{
public:
	void print()
	{
		cout<<x<<endl;
	}
private:
	int x = 0;
	static int _a;
};
static int _a = 10;

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

2. 静态成员变量在类里面只是声明，要在类外面定义并初始化。

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

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

3.友元函数

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

class Date
{
	friend istream& operator>>(istream& _cin, Date& d);
	friend ostream& operator<<(ostream& _cout, Date& d);
public:
	Date()
	{}
	Date(int year, int month = 1, int day = 1)
		:_day(day)
	{}
private:
	int _day;
	A _a;
	
};

istream& operator>>(istream& _cin, Date& d)
{
	cin >> d._day;
	return _cin;
}
ostream& operator<<(ostream& _cout, Date& d)
{
	cout << d._day;
	return _cout;
}

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

运行结果：

注意：

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

友元函数不能用const修饰

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

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

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

3.1友元类

一个类也可以是另一个类的友元，可以访问另一个类中的私有成员。（单向的）

 以上代码就是类Date是类A的友元，Date可访问A的非公开成员但是A不能访问Date的非公开成员。

4.内部类

概念：如果一个类定义在另一个类里面，这个类就叫做内部类。

注意：内部类并不属于外面那个类，内部类是外部类的友元，但是外部类不是内部类的友元。

class A
{
public:
	A()
	:x(10)
	{}
	class B
	{
	public:
		void func(A& a)
		{
			cout<<a.x<<endl;
		}
	};
private:
	int x;
};

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

5.匿名对象

class A
{
public:
	A()
	:x(10)
	{}
	class B
	{
	public:
		void func(const A& a)
		{
			cout<<a.x<<endl;
		}
	};
private:
	int x;
};

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

以上代码运行截图：

 其中B()和A()是匿名对象，直接定义，并没有给这个对象取名字。匿名函数的生命周期只有一行，下一行就会调用析构函数。