const成员函数，内联函数，友元与static成员

一.const 成员函数

    class Date
{
public:
    void fun1()
    {
        cout << "void fun1()" << endl;
    }
    void fun2()const    //const成员函数
    //编译器对const成员函数的处理
    //void fun2(const Date *this)
    {
        cout << "void fun2()const" << endl;
    }

private:
    int _year;
    int _month;
};
int main()
{
    Date d1;
    d1.fun1();//正确
    d1.fun2();//正确
    const Date d2;
    d2.fun1();//错误
    d2.fun2();//正确
    return 0;
}

从上面的代码中可得出结论：非const对象可以调用const成员函数和非const函数，const对象只能调用const成员函数。

二.内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会调用内联函数的地方展开，没有
函数压栈的开销，内联函数提升程序运行的效率。

class Date
{
public:
    void fun()//定义在类内的成员函数默认为内联
    {
    }

    void display();
private:
    int _year;
    int _month;
    int _day;
};

inline void Date::display()// 类外定义内联成员函数
{
    cout << _year<<"-"<<_month<<"-"<<_day << endl;
}

使用内联的注意事项：
1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的的函数不适宜使用内联。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉
内联。
3. inline必须函数定义放在一起，才能成为内联函数，仅将inline放在声明前是不起不作用的。
4. 定义在类内的成员函数默认定义为内联函数。

三.友元

友元的特点和作用：
友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元，一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔，外界可以通过这个小孔窥视内部的秘密。
友元的正确使用能提高程序的运行效率，但同时也破坏了类的封装性和数据的隐藏性，导致程序可维护性变差。
友元关系不具对称性。即 A 是 B 的友元，但 B 不一定是 A 的友元。 友元关系不具传递性。即 B 是 A 的友元，C 是 B 的友元，但是 C 不一定是 A 的友元。
友元函数：

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

    }
    friend void display(Date& d);
private:
    int _year;
    int _month;
    int _day;
};

void display(Date& d)
{
    cout << d._year << "-" << d._month << "-" << d._day << endl;
}

int main()
{
    Date d1(2018,3,30);
    display(d1);
    return 0;
}

友元类：

class Time
{
public:
    friend class Date;//
private:
    int _hour;
    int _minute;
    int second;
};

class Date
{
public:
    void display()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
        //通过友元类访问Time类中的私有成员
        cout << _t._hour << "-" << _t._minute << "-" << _t.second << endl;
    }

private:
    int _year;
    int _month;
    int _day;
    Time _t;
};

四.static成员
1. 类里面static修饰的成员，成为静态类成员。
2. 类的静态成员是该类型的所有对象对象所共享。

class Date
{
public:
    Date()
    {
        count++;
    }
    static void  PrintCount()
    {
        cout << "Count:" << count << endl;
    }
private:
    int _year;
    int _month;
    int _day;
    static int count;//创建对象个数；
};
int Date::count = 0;
int main()
{
    Date d1, d2;
    Date::PrintCount();
    return 0;
}