C++：类和对象3

再谈构造函数

• 初始化列表
  例如：

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

虽然上面的构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
若要初始化类对象成员，可采用以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式，这种称为初始化列表，但是采用这种方式会产生一些问题，因为初始化列表中的成员出现次序，并不代表真正的初始化次序，成员变量的初始化次序是其在类中的声明次序，例如：

class Date
{
public:
	Date(int year=1900, int month=3, int day=3)
		: _year(year)
		//初始化，赋值不是初始化，因为初始化只能进行一次，而赋值可以进行多次
		, _month(_day)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d(2019, 3, 2);
	return 0;
}

它的结果是2019，随机值，2，因为他是按照类中成员的声明顺序来初始化的，在初始化_month时，由于_day还没有初始化，因此为随机值。因此最好不要使用成员去初始化成员，因为在一些情况下有的成员还没有初始化。
注意

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
   引用成员变量，因为引用必须在定义时初始化，并且不能重新赋值
   常量成员，包括const成员变量，因为常量只能初始化，不能赋值
   没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数初始化，例如：

class Time
{
public:
	Time(int hour, int minute, int second)
	:_hour(hour)
	, _minute(minute)
	, _second(second)
	{
		cout << "Time(int,int,int)" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year)
	:_year(year)//const修饰的变量必须在初始化列表中初始化
	,_t(0,0,0)//没有默认构造函数的类类型必须在初始化列表处初始化
	, _day1(_day)//引用类型必须在初始化列表中初始化，因为引用在定义时必须初始化，而且引用不能重新赋值
//在初始化列表中，不能使用this指针，因为此时对象还没有构造好，this指针是指向对象的，因此不能使用
	{
		_month = 2;
		_day = 2;
	}
	void Display()
	{
		cout << this->_year << endl;
		cout << this->_month << endl;
		cout << this->_day << endl;
		cout << this->_day1 << endl;
	}

private:
	const int _year;
	int _month;
	int _day;
	int& _day1;
	Time _t;
};
void Test()
{
	Date d(2020);
	d.Display();
}
int main()
{
	Test();
	return 0;
}

构造了一个Time类，它没有默认构造函数，显式构造函数是非全缺省构造函数，当在Date类中定义一个Time类的对象_t时，必须在Date类的初始化列表中对_t进行初始化，且const修饰的_year必须在初始化列表中初始化，引用类型也必须在初始化列表中初始化。

3.在初始化列表中，不能使用this指针，因为this指针是指向对象的，当前初始化列表中对象还没有构造成功，因此不能使用。在构造函数体中可以使用，因为此时对象已经构造完成。
4.在编译器编译期间，已经为主函数分配了栈空间，主函数在运行期间所需要的栈的大小用ebp和esp两个寄存器标记，这个空间已经包含了函数体的局部对象，但其实在构造函数调用之前，对象是不存在的，也就是没有构造对象，但已经分配好了对象所需空间。

• explicit关键字
  用explicit修饰构造函数，将会禁止单参构造函数的隐式转换，也就是explicit只能修饰单参构造函数，意思是表明该构造函数是显式的，与之对应的是implicit，它的作用是类构造函数默认情况下声明为隐式的，例如：

class String
{
	//没有使用explicit关键字，即构造函函数默认为隐式的
public:
	String(int size)
	{
		_size = size;
		_str = (char*)malloc(size + 1);
		memset(_str, 0, size + 1);
	}
	String(const char* str = "")
	{
		if (str == nullptr)
			str = "";
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
		_size = strlen(_str);
	}
	int _size;
	char* _str;
};
void Test()
{
	String s1(20);//正确
	String s2 = 10;//正确，为String分配10个字节大小的内存
	//String s3;//错误，因为没有默认构造函数
	String s4("hello");//正确
	String s5 = "world";//正确，调用的是String(const char* str)
	String s6 = 'a';//正确，调用的是String(int size)，这里是size等于'a'的ASCII码值
	s1 = 2;//正确
	s2 = 3;//正确
	s4 = s5;//编译可以，但是如果析构函数中有free释放_str内存指针可能会报错，因为出现了浅拷贝问题
}

上述代码中，为什么String s2=10是正确的？因为在C++中，构造函数只有一个参数时，那么在编译时会有一个缺省的转换操作，将这个构造函数对应的数据类型的数据转换为该类对象，例如：String s2=10就会转换为

String s2(10);
或
String temp(10);
String s2=temp;

但是上述代码中的_size是字符串内存分配空间的大小，那么String s2=10和String s6='a’就会很奇怪，不容易理解，因此这时就会使用到explicit关键字，此时加上explicit：

class String
{
public:
	explicit String(int size)//使用了explicit关键字，即构造函函数设置为显式的
	{
		_size = size;
		_str = (char*)malloc(size + 1);
		memset(_str, 0, size + 1);
	}
	String(const char* str)
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
		_size = strlen(_str);
	}
	int _size;
	char* _str;
};
void Test()
{
	String s1(20);//正确
	//String s2 = 10;//错误，explicit取消了隐式转换
	//String s3;//错误，因为没有默认构造函数
	String s4("hello");//正确
	String s5 = "world";//正确，调用的是String(const char* str)
	//String s6 = 'a';//错误，本应调用String (int size)，且size等于'a'的ASCII码值，但是explicit取消了隐式转换
	//s1 = 2;//错误，因为explicit取消了隐式转换
	//s2 = 3;//错误，原因同上
	s4 = s5;//编译可以，但是如果析构函数中有free释放_str内存指针可能会报错，因为出现了浅拷贝问题
}
int main()
{
	Test();
	return 0;
}

值得注意的是，explicit关键字只对单参构造函数有效，如果类构造函数有2个或以上的参数，explicit无效，当然有一个例外就是==如果除了第一个参数以外其他参数都有默认值时，explicit关键字依然有效，此时调用构造函数时如果只传入一个参数，等于只有一个参数的构造函数；

• 什么情况下，编译器生成默认的构造函数？
  分为四个场景，（目前只能看一个场景）
  例如创建了一个A类和一个B类，A类中有缺省的构造函数，B类没有显式定义任何构造函数，编译器会生成默认的构造函数。
  例如：

class 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:

private:
	int _year;
	int _month; 
	int _day;
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

它会调用日期类的构造函数，而没有显式定义构造函数，会调用编译器默认生成的构造函数。

• static成员
  当我们问到类总共创建了多少个对象(面试题)，首先会想到在类内定义计数变量，但是这样只能知道每个成员函数中计数变量的个数，因此我们可以设置一个全局变量，来计数，但是它有个缺点是不安全，因为这个全局变量容易被其他人访问；而C++中有另外一种方法，使用static来使所有对象共享计数变量，例如：

class Test
{
public:
	Test()
	{
		_count++;
	}
	Test(Test& t)
	{
		_count++;
	}
	~Test()
	{
		_count--;
	}
public:
	static int _count;
};
int Test::_count = 0;
void test()
{
	Test t1, t2;
	cout << &t1._count << endl;
	cout << &t2._count << endl;
    //这两个地址一样，说明所有对象共享
	cout << Test::_count << endl;//类名+作用域限定符访问
}
int main()
{
	test();
	return 0;
}

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态的成员变量一定要在类外进行初始化。
因此可得普通成员变量和static成员变量的区别有以下：
普通成员变量可以在初始化列表中初始化，而static成员变量不能在初始化列表中初始化；普通成员变量每个对象中都包含，而static成员变量只有一份，没有具体包含在哪里；普通成员变量必须通过对象访问，而static成员变量可以通过对象直接访问，也可以通过类名+作用域访问符的方式直接访问。这两种访问方式没有区别，不过编译器最终都是按照第二种方式读取。注意：static修饰的成员变量要在类外初始化
那么普通的成员函数与static修饰的成员函数的区别：
在static修饰的成员函数中没有this指针，而普通成员函数有隐藏的this指针，这是最根本的区别。普通的成员函数可以调用静态成员函数，而静态成员函数不能调用普通成员函数，因为在调用期间普通成员函数要传this指针，而静态成员函数没有this指针。
那么可得static成员特性有以下：
3. 静态成员为所有类对象所共享，不属于某个具体的实例
4. 静态成员变量必须在类外定义，定义时不添加static关键字
5. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
6. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
7. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别
8. 计算类的大小时不计算静态成员变量

• 友元
  *类具有封装、继承、多态、信息隐藏的特性，只有类的成员函数才能访问到类的额私有成员，非成员函数孩子能访问类的公有成员，为了使类的私有成员可以被非成员函数访问到，唯一的做法就是将类的私有成员定义为public，但是这又会破坏类的信息隐藏特性，因此引入了友元函数；
  友元分为：友元函数和友元类，它提供了一种突破封装的方式，有时候提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
  友元函数：
  比如：

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void printDate()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	void operator<<(ostream& _cout)//ostream是cout的类型
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int  main()
{
	Date d(2019, 8, 6);
	d.printDate();
	//cout << d;//不能这样使用，cout只能用于内置类型，对于自定义类型无法使用
	//d << cout;//这时this指针默认是第一个参数，也就是左操作数了
	return 0;
}

如果我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。operator>>同理。
例如：

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void printDate()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	//void operator<<(ostream& _cout)//ostream是cout的类型
	//{
	//	_cout << _year << "-" << _month << "-" << _day << endl;
	//}
	friend ostream& operator<<(ostream& _cout, const Date& d);//友元函数的声明
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout,const Date& d)//友元函数
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
int  main()
{
	Date d(2019, 8, 6);
	d.printDate();
	//cout << d;//不能这样使用，cout只能用于内置类型，对于自定义类型无法使用
	//d << cout;
	cout << d << endl;//定义了友元函数，可以这样使用,这个函数是有返回值的，返回的是cout
	return 0;
}

分析：此友元函数有两个参数，第一个是ostream&，第二个是输出的内容；它必须要有返回值ostream&，支持连续输出；要少做格式化操作，例如：换行（用户自己来决定）；将该函数作为类的友元函数。
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

• 运用友元函数实现输入输出运算符重载

class Date
{
	friend istream& operator>>(istream& _cin,  Date& d);//声明
	friend ostream& operator<<(ostream& _cout, const 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;
};
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
int main()
{
	Date d;
	cin >> d;
	cout << d << endl;
	//输入输出运算符都有两个参数，一个是cout或cin，一个是输入或输出的内容
	//其中输出的内容不能修改，用const修饰，输入的内容可以修改，不用const
	return 0;
}

友元函数的特性：
1、友元函数可访问类的私有成员，但不是类的成员函数
2、友元函数不能用const修饰，因为const主要修饰的是this指针，它不是类的成员函数，没有this指针。
3、友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4、一个函数可以是多个类的友元函数
5、友元函数的调用与普通函数的调用和原理相同

• 友元类
  友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
  说明：
  1、友元关系是单向的，不具有交换性。
  例如：

class Time
{
	friend class Date;//友元类
public:
	Time(int hour , int minute , int second )
		:_hour(hour)
		, _minute(minute)
		, _second(second)
	{
		cout << this->_hour << endl;
	}
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)
		, _t(0,0,0)
	{}
	void printDate()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
		cout << _t._hour << ":" << _t._minute << ":" << _t._second << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
int main()
{
	return 0;
}

上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
2、友元关系不能传递
如果B是A的友元，C是B的友元，则不能说明C是A的友元。

• 内部类
  如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
  注意：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
  特性：
  1、 内部类可以定义在外部类的public、protected、private都是可以的。
  2、 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。外部类的静态成员变量相当于内部类的全局变量
  3、 sizeof(外部类)=外部类，和内部类没有任何关系。
  例如：

class A
{
	class B
	{
	public:
		B(int b)
			:_b(b)
		{}
		void testfunc()
		{
			//内部类是外部类的友元类，内部类可以访问外部类的私有成员
			A a(10);
			a._a = 10;
			//外部类的静态成员变量相当于内部类的全局变量
			_c = 10;
		}
	private:
		int _b;
	};
public:
	A(int a)
		:_a(a)
		, _b(0)
	{}
private:
	int _a;
	static int _c;
	B _b;
};
int A::_c = 0;//在类外初始化A类中的静态成员变量
int main()
{
	cout << sizeof(A) << endl;//8，sizeof(外部类)=外部类，和内部类没有任何关系
	return 0;
}

分析：最后的结果是8，它只计算外部类A的大小，和内部类B没有关系
源代码（github）：
https://github.com/wangbiy/C-/tree/master/test_2019_8_5_2/test_2019_8_5_2
例题：
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

class Solution {
    class Sum
        {
         public:
            Sum()
            {
                ++count;
                sum+=count; 
            }
            static int GetSum()
            {
                return sum;
            }
            static void ReSet()
            {
               count=0;
                sum=0;
            }
        private:
            static int count;
            static int sum;
            
        };
public:
    int Sum_Solution(int n) {
        Solution::Sum::ReSet();
        Sum s[n];//此处应当动态分配，还没有涉及此类知识，暂时先用此法
        return Solution::Sum::GetSum();    
    }
};
int Solution::Sum::count=0;
int Solution::Sum::sum=0;

分析：题目要求不得使用循环，if语句等方法，可使用static修饰的成员变量来进行计数，因为static修饰的成员变量不仅安全，而且它修饰的成员变量只有一份，在Solution类中定义内部类，实现各个功能，注意，static修饰的成员变量必须在类外进行初始化，在每次计数时，应当将上次计数的数据销毁。