(入门自用）C++-类与对象（下）--静态成员变量--友元-0805

初始化列表

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

};

自定义类型成员,推荐使用初始化列表初始化。

初始化列表可以认为是成员变量定义的地方。

【注意】

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

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量

const 成员变量

自定义类型成员 ( 且该类没有默认构造函数时 )

原因 ：仅在初始化列表是初始化，构造函数内是赋值

class Time
{
public:
    Time(int hour = 0)
    {    
        _hour=hour;
    }
private:
    int _hour;
};

class Date
{
public:
    Date(int year,int hour,int& x)
        :_t(hour)
        ,_N(10)
        ,_ref(x)
    {
        //函数体内初始化
        _ref++;//x与y也跟着++
    }
private:
    int _year;
    Time _t;
    const int _N;
    int& _ref；
}

int main()
{
    int y=0;
    Date d(2022,1);
    return 0;
}

建议：能使用初始化列表就使用.

注意：

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

静态成员

只能在类外面定义初始化

class A
{
public:
    A()
    {++_scount;}
    A(const A& t) 
    {++_scount;}
    
    //静态成员函数——没有this指针 不能访问非静态成员
    static int GetCount()
    {
        //_a=1;
        return _scount;
    }
private:
    _a；
    //静态成员变量，属于整个类，生命周期整个程序,存在于静态区
    static int _scount://声明
};

//类外面定义初始化
int A::_scount=0;//不用加static

int main()
{
    A a1;
    A a2;
    //cout << a1._scount << endl1;
    //cout << a2._scount << endl1;
    //cout << A::_scount << endl1;
    //私有的 访问不了
    cout << A::GetCount() <<endl;

    return 0;
}

特性

1. 静态成员 为 所有类对象所共享 ，不属于某个具体的对象，存放在静态区

2. 静态成员变量 必须在 类外定义 ，定义时不添加 static 关键字，类中只是声明

3. 类静态成员即可用 类名 :: 静态成员 或者 对象 . 静态成员 来访问

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

5. 静态成员也是类的成员，受 public 、 protected 、 private 访问限定符的限制

6.静态成员突破类域就可以访问。

 

使用

静态成员函数可以成功调用静态成员变量 。

静态成员函数不能用来调用非静态成员变量。

因为静态成员变量每个类只有一份是让整个类去使用的，所以可以被调用。但由于静态成员函数没有this指针，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。

设计一个只能在栈上定义对象的类

class StackOnly
{
public:
    static Stackonly CreateObj()//静态的可以不用对象就调用
    {
        StackOnly so;
        return so;
    }
private:
    StackOnly(int x,int y)
        :_x(x);
        ,_y(y)
    {}
private:
    int _x=0;
    int _y=0;
};

int main()
{
    //StackOnly so1;//栈
    //static StackOnly so2;//静态区
    StackOnly so3=StackOnly::CrreateObj();
    return 0;
}

静态成员函数不可以调用非静态成员函数。

非静态成员函数可以调用类的静态成员函数。

友元

友元函数说明:

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

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

class Date
{
 friend ostream& operator<<(ostream& _cout, const Date& d);
 friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
private:
    int _year;
    int _month;
    int _day;
};

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

友元类

A是B的友元类，A可以访问B类的所有成员变量。B不能访问A的成员变量。

class Time
{
 friend class 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
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 
 void SetTimeOfDate(int hour, int minute, int second)
 {
 // 直接访问时间类私有的成员变量
 _t._hour = hour;
 _t._minute = minute;
 _t._second = second;
 }
 
private:
 int _year;
 int _month;
 int _day;
 Time _t;
};

注意：

• 友元关系是单向的，不具有交换性。
• 比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time
• 类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
• 友元关系不能传递，如果B是A的友元，C是B的友元，则不能说明C时A的友元。
• 友元关系不能继承

内部类

一个类定义到另一个类的内部，就成为内部类。

B定义在A的里面。1.B受A的类域限制 2.B天生是A的友元(B能访问A，A不能访问B）

int main()
{
    cout << sizeof(A) <<endl; //A类的大小跟B类无关，除非使用过了B类的类型
    A a;//A类可以随意创建对象
    A：:B b；//B类受A的类域限制
    return 0;
}