🌏构造函数中的初始化列表

class
{
public:
	Date(int year, int month, int day)// 成员变量定义处  给变量开空间
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	// 成员变量声明处  
	int _year;
	int _month;
	int _day;
};

注意：

每个成员变量只能在初始化列表中出现一次
类中包含定义时必须初始化的成员时，必须使用初始化列表

const成员变量（常量）
引用成员变量（引用必须在定义时初始化）
无默认构造函数（无参、全缺省和编译器给的默认构造函数）的自定义类型成员变量

class AA
{
public:
    AA(int a)// AA类无默认构造函数，必须使用初始化列表
    {
        _a = a;
    }
private:
    int _a;
};
class Date
{
    Date(int year = 1, int month = 1, int day = 1, int i = 10)
        :_a(10)
        ,_ref(i)
        ,_aa(10)
    {
        _year = year;
        _month = month;
        _day = day;
    }


    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
    
private:
    // 成员变量声明的地方 还未申请空间
    int _year;
    int _month;
    int _day;
	
	// 以下三个成员变量都是必须在定义时初始化
    const int _a;
    int _ref;
    AA _aa;
};

一个小问题

🌏explicit关键字

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

int main()
{
    Date d1 = { 2022, 1, 21 };

    return 0;
}

explicit Date(int year, int month， int day)
        :_year(year)
        ,_month(month)
        ,_day(day)
    {}

🌏static成员

特性：

静态成员属于整个类，且不占类的大小
静态成员变量是在类内声明，类外定义的
静态成员可以直接通过::指定类域来访问
静态成员函数中没有this指针，不能访问非静态的成员

我们实现一个类，计算该程序创建了多少个对象

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

    // 静态成员函数  无this指针，可以直接用::指定类域访问
    // 只能访问静态成员变量和函数
    static int GetCount()
    {
        return _sCount;
    }

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
    
private:
    // 成员变量声明的地方
    int _year;
    int _month;
    int _day;

    // 静态成员变量属于整个类（所有类）生命周期在整个程序运行期间
    // 可以直接用::指定类域访问
    static int _sCount;// 类内声明，类外初始化定义
};

// 静态必须要在类外初始化定义
int Date::_sCount = 0;

🌏C++11中新的初始化方式

class Date
{
public:

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
    
private:
    // 成员变量声明的地方
    // 注意，这里不是定义，而是声明，在声明是给缺省值
    int _year = 1;
    int _month = 1;
    int _day = 1;
    static int _sCount;// 静态成员变量不能像上面一样
};

// 静态必须要在类外初始化定义
int Date::_sCount = 0;

🌏友元

💎友元函数


class Date
{
    // 友元函数
    // 不能用const修饰  const修饰的是非静态的成员函数 一个类可以是很多函数的友元
    friend ostream& operator<<(ostream& out, const Date& d);
    friend istream& operator>>(istream& in, Date& d);
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
    
private:
    int _year;
    int _month;
    int _day;
};



// 全局
ostream& operator<<(ostream& out, const Date& d)
{
    out << d._year << "-" << d._month << "-" << d._day << endl;

    return out;
}

istream& operator>>(istream& in, Date& d)
{
    in >> d._year >> d._month >> d._day;

    return in;
}

特性：

不能用const修饰
const修饰的是非静态的成员函数
一个类可以是很多函数的友元

💎友元类

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

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
    
private:
    int _year;
    int _month;
    int _day;
};

class Time
{
    // 友元类
    // Date类是Time类的友元   Date可以访问Time的私有成员  单向  不能传递
    friend class Date;
public:
    Time(int hour, int minute, int second)
        :_hour(hour)
        , _minute(minute)
        , _second(second)
    {}
private:
    int _hour;
    int _minute;
    int _second;
};

🌏内部类

特性：

外部类天生就是内部类的友元类，内部类具有访问外部类私有属性的权限，但外部类却没有访问内部类的私有属性的权限
内部类只是受外部类的类域的限制，内部类并不属于外部类，也就是sizeof(外部类)=内部类

class A
{
private:
    static int _a;
    int _b;
public:
    // 内部类
    // B天生就是A的友元   B可以访问A的私有成员，但是A不可以访问B的私有
    // sizeof(A) = 4    A中成员变量b  a属于整个类，不占对象的大小  内部类B和在全局定义的基本一致，知识受A类域的限制
    class B
    {
    public:
        void f()
        {

        }
    private:
        int _a;
    };
};

int A::_a = 10;