const&内联&友元

const
1，在成员函数后面加const， const修饰this指针所指向的对象， 也就是保证调用这个const成员函数的对象在函数内不会被改变。

Time const t1(2017 10 21);
//在t1的生命周期中，对象t1中的所有数据成员的值都不能被修改

2，如果一个对象被声明为常对象，则通过该对象只能调用它的常成员函数，而不能调用该对象的普通成员函数。

const Time t1(2017,10,20);//定义常对象t1
t1.get_time();//非法，试图调用常对象t1中的普通成员函数，

常数据成员
只能通过构造函数的参数初始化表对常数据成员进行初始化，其他任何函数都不能对常数据成员赋值。
构造函数的初始化列表
初始化列表以一个冒号开始， 接着一个逗号分隔数据列表， 每个数据成员都放在一个括号中进行初始化。

class Time
{
public:
    Time(int hour=0,int minute=0,int second=0)
    {
        cout<<"Date() - 非初始化列表 " <<endl ;
        _hour=hour;
        _minute=minute;
        _second=second;
    }
    Time(int hour,int minute,int second)
        :_hour(hour)
        ,_minute(minute)
        ,_second(second)
    {
        cout<<"Date () - 初始化列表 " <<endl ;
    }
    //相对于非初始化列表，初始化列表少调用构造函数（缺省），少调用运算符重载，因此更为高效。

哪些成员变量必须放在初始化列表里面？
1. 常量成员变量。 （ 常量创建时必须初始化）
2. 引用类型成员变量。 （ 引用创建时必须初始化）
3. 没有缺省构造函数的类成员变量。

成员变量按声明顺序依次初始化， 而非初始化列表出现的顺序。

#include<iostream>
using namespace std;
class Date
{
public :
    Date (int x)
        :_day(x )
        , _month(x)
        , _year(x )
    {
        cout<<"Date () " <<endl;
    }
    void Display ()
    {
        cout<<"year: " <<_year<< endl;
        cout<<"month: " <<_month<< endl;
        cout<<"day: " <<_day<< endl;
    }
private :

    int _year ; // 年
    int _month ; // 月
    int _day ; // 日
} ;
int main ()
{

    Date d1 (1) ;
    d1. Display () ;
    return 0;
}

常成员函数
如果将成员函数声明为常成员函数，则只能引用本类中的数据成员，而不能修改它们。

#include<iostream>
using namespace std;
class Date
{
public :
    void Display()
    {
        cout<<"Display () " <<endl;
        cout<<"year: " <<_year<< endl;
        cout<<"month: " <<_month<< endl;
        cout<<"day: " <<_day<< endl<<endl ;
    }
    void Display () const
    {
        cout<<"Display() const " <<endl;
        cout<<"year: " <<_year<< endl;
        cout<<"month: " <<_month<< endl;
        cout<<"day: " <<_day<< endl<<endl ;
    }
private:
    int _year ; // 年
    int _month ; // 月
    int _day ;
};
void Test ()
{
    Date d1 ;
    d1. Display () ;
    const Date d2;
    d2. Display () ;
}

常成员函数可以引用const数据成员，也可以引用非const 数据成员。
常成员函数不能调用另一个非const成员函数。

内联
以inline修饰的函数叫做内联函数， 编译时C++编译器会调用内联函数的地方展开， 没有函数压栈的开销， 内联函数提升程序运行的效率。（相当于c语言中的宏）
1. inline是一种以空间换时间的做法， 省去调用函数栈开销。 所以代码很长或者有循环/递归的的函数不适宜使用内联。
2. inline对于编译器而言只是一个建议， 编译器会自动优化， 如果定义为inline的函数体内有循环/递归等等， 编译器优化时会忽略掉内联。
3. inline必须函数定义放在一起， 才能成为内联函数， 仅将inline放在声明前是不起不作用的。
4. 定义在类内的成员函数默认定义为内联函数。
eg:将 max 定义为内联函数

inline int max(int a, int b)
{
 return a > b ? a : b;
}

则调用： cout<<max(a, b)<<endl;
在编译时展开为： cout<<(a > b ? a : b)<<endl;
从而消除了把 max写成函数的额外执行开销

利弊分析：
内联机制既具备宏代码的效率，又增加了安全性，而且可以自由操作类的数据成员，函数被内联后，编译器可以通过上下文相关的优化技术对结果代码执行深入优化。另一方面，如果执行函数体内的代码时间比函数调用的开销大得多，那么inline效率收益会很小。

友元
friend的意思是朋友，中文多译为友元，友元可以访问与其有好友关系的类中的私有成员，友元包括友元函数和友元类。
友元函数：
在C++中友元函数允许在类外访问该类中的任何成员， 就象成员函数一样， 友元函数用关键字friend说明。
1. 友元函数不是类的成员函数。
2. 友元函数可以通过对象访问所有成员， 私有和保护成员也一样。

#include<iostream>
using namespace std;
class Time
{
public:
    Time(int,int,int);
    friend void display ( Time & );//声明display函数为Time类的友元函数
private:
    int _hour;
    int _minute;
    int _second;
};
Time::Time(int hour,int minute,int second)//定义构造函数，分别给hour，minute，second赋初值
{
    _hour=hour;
    _minute=minute;
    _second=second;
}
void display(Time & t)
{
    cout<<t._hour<<":"<<t._minute<<":"<<t._second<<endl;
}
int main()
{
    Time t1(2017,10,19);
    display(t1);
    return 0;
}

友元类：
整个类可以是另一个类的友元。 友元类的每个成员函数都是另一个类的友元函数， 都可访问另一个类中的保护或私有数据成员。
1，友元的关系是单向的而不是双向的。
2，友元的关系不能传递。

#include<iostream>
using namespace std;    
class Time
{
// Date是Time 的友元， 所以 Date可以访问Time的所有成员。
friend class Date;
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
public:
    void Display()
    {
        cout<<"year: "<<_year<<endl;
        cout<<"month: "<<_month<<endl;
        cout<<"day: "<<_day<<endl;
        // 定义为友元类后， 可以访问Time类对象的所有成员
        cout<<"hour: "<<_t._hour<<endl;
        cout<<"minute: " <<_t. _minute<<endl ;
        cout<<"second: " <<_t. _second<<endl ;
    }
private:
    int _year;
    int _month;
    int _day;
    Time _t;
};
void Test()
{
    Date d1;
    d1. Display( );
}

利弊分析：
友元因为可以访问其它类中的私有成员，所以它一定程度上对封装原则是一个小的破坏，但是它有助于数据共享，能提高程序的效率，在使用时，要注意它的副作用，在数据共享和信息隐蔽之间选择一个恰当的平衡点。