类和对象（下）

一、再谈构造函数

1.初始化列表

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

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

注意：

1.每个成员变量在初始化列表中只能出现一次（初始化只能出现一次）

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

3.尽量避免使用成员初始化成员

4.类中包含以下成员，一定要放在初始化列表位置进行初始化：

（1）引用成员变量

（2）const成员变量

（3）类类型成员（该类有非缺省的构造函数）

 2.构造函数的作用   

    不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用

class Date
{
 public:
    Date(int year)        //单参数
        :_year(year)
    {}
 private:
    int _year;
    int _month;
    int _day;
}

void test()
{
    Date d1(2018);     
    d1=2016             //编译器背后会用2016构造一个无名对象，赋给d1
}

注意：实际上编译器会做以下几件事：

创建一个临时对象   Date  tmp(2018)  ————》 d1=tmp;

但这样代码的可读性不好，可以用explicit修饰构造函数，将会禁止单参构造函数的隐式转换

注意：C++11可在类成员声明时直接初始化

二、友元

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

1.友元函数

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

test.h
#ifndef __FRIEND_H__
#define __FRIEND_H__

#include <iostream>
using namespace std;

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);  //重载<<运算符
public:
	/*ostream& operator<<(ostream& out)
	{
		out << _year << "-" << _month << "-" << _day;
		return out;
	}*/
 //若不用friend,this永远指向第一个对象，导致第二个参数是输出流，结果是反的 “d1<<cout”
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

test.cpp
#include "friend.h"

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "-" << d._month << "-" << d._day;
	return out;
}

int main()
{
	Date d1(1,5,3);
	cout << d1;
	return 0;
}

说明：

（1）友元函数可以访问类的私有成员，但不是成员函数

（2）友元函数不能用const修饰。

（3）在成员函数中，const只能修饰this指针指向的对象

（4）友元可以在类的任意地方声明，不受访问限定符的限制

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

2.友元类

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

class Date   //前置声明
class Time
{
	friend class Date;     //Date类中的成员函数可以访问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
{
	void setTime(int hour, int minute, int second)
	{
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

友元的优缺点：

优点：可以让一个类去操作另一个类

缺点：破环了类的封装性和隐藏性

注意：

（1）友元关系是单向的

       例如：Date类是Time类的友元，那么Date类中的成员函数就可以访问Time类的私有成员变量，但Time类不能访问Date类中的私有成员

（2）友元的关系不能传递

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

三、static成员

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

class A
{
public:
	A()
	{
		++_count;
	}
	A(const A& t)
	{
		++_count;
	}
	~A()
	{
		--_count;
	}
	static int GetCount()
	{
		return _count;
	}
private:
	static int _count;
};

int A::_count = 0;
#endif 

#include "static.h"

int main()
{
	A a;
	cout << A::GetCount() << endl;
	return 0;
}

特性：

1.静态成员为所有类对象所共享，不属于某个具体的实例

（其放在静态区，不占用对象本身的空间，且不能在声明时赋值）

2.静态成员变量只能在类外进行定义，定义时不添加static关键字

3.该类的对象可以访问该类的静态成员

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

5.静态成员和类的普通成员一样，也有public,private,protected，3种访问级别，可以有返回值

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

           非静态成员函数可以调用类的静态成员函数。 （突破类域即可）