#include
using namespace std;
class Date {
public:
    Date(int year = 0, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
    {}
    ostream& operator<<(ostream& out)
    {
        out << _year << "-" << _month << "-" << _day << endl;
        return out;
    }
private:
    int _year=2022;
    int _month=7;
    int _day=31;
};
int main()
{
    Date d;
    d << cout;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

• 为了符合我们平时的习惯，让cout占据第一个操作数，我们就不能将这个函数写成成员函数，要写在类外面作为普通函数
• 可以在类外我们就无法访问Date的private成员，无法实现打印，这时候我们就需要将这个函数写成Date类的友元函数
• 方法是 friend关键字+函数的声明，在类的任意地方加上都行

#include
using namespace std;
class Date {
    friend ostream& operator<<(ostream& out, const Date& d);
public:
    Date(int year = 0, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
    {}
private:
    int _year=2022;
    int _month=7;
    int _day=31;
};
ostream& operator<<(ostream& out, const Date& d)
{
    out << d._year << "-" << d._month << "-" << d._day << endl;
    return out;
}
int main()
{
    Date d;
    cout<<d;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

• 说明：

1. 友元函数可访问类的私有和保护成员，但不是类的成员函数
2. 友元函数不能用const修饰
3. 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4. 一个函数可以是多个类的友元函数
5. 友元函数的调用与普通函数的调用和原理相同

2. 友元类

• 友元类和友元函数差不多，就是声明A类是B类的友元类，那么A类中的所有成员函数都可以使用B类中的private成员
• 其实就是将A类中所有的成员函数都变成了B类的友元函数
• 下面就通过友元类让Time类的成员打印Date类的成员

#include
using namespace std;
class Time;
class Date {
friend Time;
public:
    Date(int year = 0, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
    {}
private:
    int _year=2022;
    int _month=7;
    int _day=31;
};
class Time
{
public:
    Time(int hour = 1)
        :_hour(hour)
    {}
    void print(const Date& d)
    {
        cout << d._year << "-" << d._month << "-" << d._day << endl;
    }
private:
    int _hour;
};
int main()
{
    Date d(2022,7,31);
    Time t;
    t.print(d);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

• 注意：

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

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

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

3. C++11中的内部类

• 如果我们在一个类A中再定义一个类B，那么B类就是A类的内部类
• 此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类，外部类对内部类没有任何优越的访问权限
• 内部类天生就是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类中
  的所有成员，但是外部类不是内部类的友元

#include
using namespace std;
class Date {
public:
    Date(int year = 0, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
    {}
    class Time
    {
    public:
        Time(int hour = 1)
            :_hour(hour)
        {}
        void print(const Date& d)
        {
            cout << d._year << "-" << d._month << "-" << d._day << endl;
        }
    private:
        int _hour;
    };
private:
    int _year=2022;
    int _month=7;
    int _day=31;
};

int main()
{
    Date d(2022,7,22);
    Date::Time t;
    t.print(d);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

三：static成员

1. 初始化

• 声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量，用static修饰的成员函数，称之为静态成员函数
• 静态的成员变量一定要在类外进行初始化
• 并且定义时不用加上static，但是要加上域名和::表明初始化的是类中的静态成员变量

#include
using namespace std;
class Date {
public:
    Date(int year = 0, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
    {}
    static int GetCount()
    {
        return count;
    }
private:
    int _year;
    int _month;
    int _day;
    static int count;
};
int Date::count = 1;
int main()
{
    cout << Date::GetCount();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2. 特性

1. 静态成员为所有类对象所共享，不属于某个具体的实例
2. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
3. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员（非静态成员函数可以访问静态成员函数）
4. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值