构造函数的一点补充

构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

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

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

编译器默认生成的构造函数对内置类型不处理（默认构造函数有三种，自己没写编译器默认生成的，自己写了但是没有参数的和自己写了但是是全缺省参数的，如果不清楚请看我的上一篇博客：类和对象中篇），对自定义类型会调用其默认构造函数，但是如果自定义类型的默认构造函数是编译器自动生成的话，又是对自定义类型的内置类型没做什么处理，以此类推。如果一直套娃下去，而且所有的自定义类型的类都是编译器默认生成的构造函数，那等于说是啥都没干。但是如果我们想要不用默认构造函数就能初始化自定义类型呢？

代码如下：
例1：

class Time
{
private:
	int _hour;
};

class Date
{
public:
	Date(int year = 1949)
	{
		_year = year;
	}
private:
	int _year;
	Time _t;
};

上面的Time类中，有一个编译器默认生成的构造函数。
Date类中我显示定义了一个Date的构造函数。还定义了一个自定义类型_t；

此时我编译：

会出现一个警告，写的是_t未初始化。

我给Time类型加上构造函数并且为其成员变量_t赋值后（没有赋值的话还是会警告），警告消失。

但是想要不用默认构造还赋值一个我们想用的值，可以不？

当Time没有默认构造的时候，还要分两种情况：

1. Date没有显示写默认构造：

class Time
{
public:
	Time(int hour)
	{
		_hour = 0;
	}
private:
	int _hour;
};

class Date
{
private:
	int _year;
	Time _t;
};

报错的是Date类的。因为Time类中没有默认构造函数，而Date在生成d的时候还是要调用Time的默认构造函数的，但是Date类调不动，因为根本没有。

2. Date显示写了构造函数：

class Time
{
public:
	Time(int hour)//不是默认构造
	{
		_hour = 0;
	}
private:
	int _hour;
};

class Date
{
public:
	Date(int year)//Date的构造函数
	{
		_year = year;
	}

private:
	int _year;
	Time _t;
};

会报错：

上面Time类中的构造函数不是默认构造函数，有参但不是全缺省。

再改改：

在Date构造函数中再搞一个Time类t， 然后将t赋值给_t（这里是默认的赋值运算符重载，如果不了解，还是先看看我的类和对象中篇），还是有问题，好像必须要调用默认构造函数才行，但是也未必，我们可以看到，Date构造函数 { 下边有报错，为啥是这里报错呢？

上面说了一堆，比较模糊，只是为了引出一个东西：初始化列表。

初始化列表

先看看长啥样：

这里的Time类里面可是没有默认构造函数的。

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

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

初始化列表可以认为是成员变量定义的地方。
而上面的int _year; int _month; int _day; 都是声明。不是在定义，这一点应该是刚学类和对象那会就要清楚的。

还是以刚刚的Date和Time类为例，说三点：

1. 当Time类没有默认构造函数时，必须在Date的构造函数中使用初始化列表。
2. 当Time有默认构造时，不用显示使用初始化列表，但还是会在Date构造函数处使用初始化列表来调用Time的默认构造函数。
3. Time有默认全缺省的构造函数时，可以在Date构造函数的初始化列表处使用全缺省构造函数来直接为Time类成员变量进行非缺省参数的初始化。

2和3给俩例子。

2：

3：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量
const成员变量
自定义类型成员(且该类没有默认构造函数时)

给个例子：

3. 不管是内置类型还是自定义类型，能用初始化列表初始化就用，使用初始化列表基本没什么毛病。但是也有在函数体内初始化的场景，这里把例子给出来：


这样看起来会舒服很多。

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

直接给例题：

四选一：
A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{}

	void Print() 
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
};
int main() 
{
	A aa(1);
	aa.Print();
}

上面第四点可以说是已经把答案说出来了。这里再解释一下，初始化时不会按照初始化列表的顺序，而是按照成员变量声明的顺序初始化。所以是先初始化_a2，此时_a1为随机值，所以给_a2也是随机值，然后再初始化_a1为1。

所以答案是：D。

explicit关键字

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

什么意思？
还是先给例子：

d2在定义的时候，会调用构造函数，是因为发生了隐式类型转换。

赋值运算符在给某一变量赋值的时候，会先为右侧数值做一个临时拷贝，然后再将这个拷贝的东西赋值给左侧变量，所以理论上讲d2在初始化前，右侧会以2022这个数先构造一个临时的Date对象（临时对象具有常属性），这个对象中year的值就是2022，然后再将这个临时对象拷贝给d2，但实际上并不是这么做的。

实际上时直接调用了构造函数。这是 构造 + 拷贝构造 + 编译器优化 -> 直接调用构造函数。

再给个例子：

加个引用就不行了。因为临时对象具有常属性，不能被修改，给引用就可以通过d3来改那个临时拷贝了，但是不能那么做，权限会被放大（权限只能缩小或者平移）。

这一点就类似于：

再看：

加上const就可以了，因为加了const就不能通过d3来改变那个临时数据了。

那我不想让d2发生隐式转换呢？
在构造函数前加explicit就好了。

这个就解释到这，以后会讲到这个的使用场景。但是是不加explicit的使用场景。

Static成员

C语言也学过static了，这里是C++的类里面static的用法。

概念

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

看看长啥样：
静态成员变量：

静态成员函数：

特性

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

静态成员变量，是在编译阶段就分配空间，对象还没有创建时，就已经分配空间。
静态成员变量必须在类中声明，在类外定义。
静态数据成员不属于某个对象，在为对象分配空间中不包括静态成员所占空间。

这一点与类对象共享函数代码很类似。

第一点就不解释了。
第二点刚刚给的例子中就有。

说第三点（和第一点结合）：

第四点：


其实第四点归根到底就是因为静态成员函数中没有隐藏的this指针。

第五点：

说一下第五点的使用场景：
写一个只能在栈上定义对象的类。
先动脑想想。
.
.
.
.
.
.
.
答案：

面试题：实现一个类，计算程序中创建出了多少个类对象。

class A
{
public:
	A()
	{
		_i++;//每创建一个变量就让_i加一次。
	}

	static void NumOfCreateA()
	{
		cout << _i << endl;
	}

private:
	static int _i;
};
int A::_i = 0;
int main()
{
	A a[100];
	A::NumOfCreateA();
	return 0;
}

再来道题：
牛客JZ64

我写了两个，
第一个：

class sum
{
public:
    sum()
    {
        _sum += _i;
        _i++;
    }

    static int Sum(int n) 
    {
        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)
    {
        sum s[n];//这里的变长数组可以直接用n
        return sum::Sum(n);
    }
};

第二个：

class Solution 
{
public:
    Solution()
    {
        _sum += _i;
        _i++;
    }
    static int Sum_Solution(int n) 
    {
        Solution s[n - 1];//这里的变长数组只能用n-1
        //我猜是后台在实现的时候还定义了一个Solution
        //的对象，然后导致多加了一次
        return _sum;
    }
private:
    static int _i;
    static int _sum;
};
int Solution::_i = 1;
int Solution::_sum = 0;

静态的就讲到这，下面讲讲友元。

友元

中篇讲运算符重载的时候应该是要提一下这个友元的，不过给整忘了，这里补上。

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

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

上面这句话说的太专业化了，说人话就是能不用友元就尽量不用。

友元函数

Date类，想要直接用 cout 打印，需要对 << 运算符进行重载。

但是不能重载到类内，因为 << 是一个二元运算符，重载的函数左参数一定是this指针，也就是左操作数，右操作数（右参数）是ostream类型的对象，这样就很鸡肋了，用起来就变成了这样：

如果我把cout和d换个位置就会报错：

因为在调用 << 的时候this指针占了左参数，cout就必须放在右边了。
但是我如果接着用左边是d右边是cout的话，就不能连续打印了。

所以说不能在类内重载 << 运算符。

那就得在类外了。

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

上面就是友元的一个使用场景。

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

友元函数不能用const修饰(const是用来修饰this指针的，友元函数没有)

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

一个函数可以是多个类的友元函数
比如fun(A& a, B& b, C& c)就可以在ABC类中都声明一下友元函数func。

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

友元类

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

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

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

用一句话说就是你的是我的，我的还是我的。

友元关系不能传递
例如：如果C是B的友元， B是A的友元，则不能说明C是A的友元。

友元关系不能继承，等讲到继承了再给大家详细介绍。

class Time
{
	friend class Date; 
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;
};

上面的Date类就能直接用Time类中的所有成员了。

内部类

概念

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性

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

第一点就不给例子了。

第二点，上一个友元，友元类在访问另一个类的static的时候还要用 类的对象/类名 来访问静态成员。但是内部类不需要。

上例子：

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}
	class Date//Date天生就是Time的友元
	{
	public:
		Date(int year = 1900, int month = 1, int day = 1)
			: _year(year)
			, _month(month)
			, _day(day)
		{
			cout << _si << endl;
		}
	private:
		int _year;
		int _month;
		int _day;
	};
private:
	int _hour;
	int _minute;
	int _second;
	static int _si;
};

int Time::_si = 0;

第三点：

用Date类定义对象的时候要用到Time类。

直接用Date会报错。

记住：
B类定义在A类的里面

1. 仅受A的类域的限制，也就是在用B定义对象的时候要用A::B来定义。
2. B天生是A的友元

A就和B没啥别的关系了。

匿名对象

长这样：

匿名对象的生命周期只在当前行，过了当前行就原地去世了。## 拷贝对象时的一些编译器优化。

续着刚刚上面的内部类，还可以这样用：

这就是匿名对象。
在定义一下析构函数我们来证明一下其生命周期只有一行：

拷贝对象时的一些编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。

比如说我们前面说到的类对象定义时的隐式类型转换。本来应该是构造 + 拷贝构造，变成了仅构造。这就是编译器的优化。但有的老编译器就优化不了。

再举一个场景。

类定义如下：

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

下面的例子都是针对上面的类型来出的：

例一：

例二

例三：

例四：

例五：

例六：

反正就是某种条件下，编译器为了提高效率会进行自动优化，而且debug和release版本下优化的程度是不一样的。

上面的了解了解就ok了，我水平也没那么高，讲不了那么深。。。

几道例题

1. 计算日期到天数的转换
2. 日期差值
3. 打印日期
4. 累加天数

到这里类和对象就讲完了，上面的例题完全可以做了。

到此结束。。。