类和对象（下）

静态成员变量为所有类对象所共享 ，不属于某个对象，不存在对象中，存放在静态区

静态成员变量不能给缺省值 （缺省值是给初始化列表的），它在静态区不在对象中，不走初始化列表

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

类静态成员变量可用 类名::静态成员 或者 对象.静态成员 来访问（公有静态成员变量）

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

7.静态成员函数可用 类名::静态函数 来访问（公有静态成员函数）

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

3.示例

class A

{

public:

A(int a = 1)

:_a(a)

{}

static int& GetCount()//静态成员函数无this指针

{

return _n;

}

private:

int _a;

static int _n;//静态成员变量属于private私有

};
int A::_n = 0;//类外定义，无需static关键字（类似类成员函数的声明与定义分离）

int main()

{

A a;

cout << A::GetCount() << endl;

return 0;

}

2.友元

1.友元函数

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

class Date

{

friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, 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;

};

ostream& operator<<(ostream& out, const Date& d)

{

_cout << d._year << "-" << d._month << "-" << d._day;

return out;

}

istream& operator>>(istream& in, Date& d)

{

_cin >> d._year;

_cin >> d._month;

_cin >> d._day;

return in;

}

特性

友元函数可访问类的私有和保护成员，但不是类的成员函数

友元函数不能用const修饰

友元函数可以在类定义的任何地方声明，不受类访问限定符限制

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用原理相同

2.友元类

友元类的所有成员函数都可以访问另一个类中的私有成员。
友元关系是单向的，不具有交换性。

友元关系不能传递。B是A的友元，C是B的友元，不能说明C是A的友元。

友元关系不能继承，继承章节详细介绍
class Time

{

//声明Date类是"我"的友元，Date类可以访问"我"的私有成员

friend class Date;

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)

{

// 直接访问Time类私有的成员变量

_t._hour = hour;

_t._minute = minute;

_t._second = second;

}

private:

int _year;

int _month;

int _day;

Time _t;

};

3.内部类

1.概念

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。

2.特性

1.内部类是一个独立的类 ，与其外部类呈现平行关系，仅仅受到类域和访问限定符（private限定，内部类可以设定为外部类的专属类）的限制

2.内部类天生就是外部类的友元类，内部类可以访问外部类的私有成员（反之不可）

4.匿名对象

1.概念

省略类名创建类对象

class A

{

public:

A(int a = 1)

: _a(a)

{}

private:

int _a;

};

int main()

{

A();
A(10);

return 0;

}

2.特性

1.匿名对象，生命周期只在当前这一行

2.匿名对象的创建，不能省略括号，即使不需要传参（c++11以后可以直接 A; 创建匿名对象）

3.匿名对象具有常性（类似临时对象）

3.应用

//便于直接调用类成员函数

// 方式1：创建命名对象 s1，调用成员函数

Solution s1;

int res1 = s1.Sum_Solution(10);

// 方式2：创建匿名对象 Solution()，直接调用成员函数

int res2 = Solution().Sum_Solution(10);

5.拷贝消除（建议）

类和对象(中) 已经说明一种拷贝消除的情况：连续的构造+拷贝构造 ------> 优化为直接构造

还有一种场景：连续的拷贝构造+拷贝构造 ------> 优化为一个拷贝构造

cpp 复制代码

//DEBUG版本
class A
{
public:
    A(int a = 1)
        : _a(a)
    {}
private:
    int _a;
};

A f2()
{
    A aa;
    return aa;
}

int main() 
{
    A ret = f2();
    //1.打破优化
    //const A& ret = f2();

    //2.赋值拷贝,不会优化，建议不要这样写
    //A ret;
    //ret = f2();

    return 0;
}

注意：Release版本优化等级更高

6.类对象析构顺序

栈帧空间定义的类对象，满足后进先出的原则，后定义的先析构

全局定义的类对象，mian函数前就构造了

局部的静态类对象，在第一次调用的时候构造，第二次调用不会构造（静态变量只会初始化一次）