3-V2-类和对象 -- const&内联 & 静态成员 & 友元

const修饰成员函数

在成员函数后面加一个const, const修饰this指针指向的对象, 保证调用这个const成员函数的对象在函数内不会被改变
这里写图片描述
注意:成员函数如果不修改成员变量,则加上const,成员函数如果要修改成员变量,此时就不能给其加上const修饰了
1.const对象不能调用非const成员函数,可以调用const成员函数
2.非const对象可以调用非const成员函数和const成员函数
3.const成员函数可以调用其他的const成员函数,但是不能调用其他的非const成员函数
4.非const成员函数内可以调用其他const成员函数和非const成员函数
总结一下,对象在调用成员函数的时候作用域只能缩小,不能增大.

inline内联

用inline关键字修饰的函数叫做内敛函数,编译器在进行编译的时候,会在调用该函数的地方将该函数进行展开, 没有函数的压栈过程,因此内联函数运行效率较高
1.inline是一种以空间换时间的做法, 省去了调用函数时候的压栈开销, 因此循环递归等不适宜内联函数
2.内联函数只是一个建议,编译会将其自动优化,如果涉及到的函数是递归循环等, 编译器会将内联忽略
3.定义在类内的函数默认为是内联函数

宏的优点以及缺点

宏的优点

增加代码的复用性,提高性能

宏的缺点

宏不方便调试,因为宏的展开是在预处理阶段对其进行展开的
宏的可读性较差,可维护性较差, 如果不注意会导致错误
宏无类型,安全机制较差

友元

友元函数:突破类的封装过程

在c++中友元函数允许在类外访问该雷的所有成员函数,就像成员函数一样, 友元函数只需要在该函数前面加上关键字friend
友元函数可以通过对象访问所有成员,私有和保护也一样

友元类:

有两个类 A 和 B, 其中A类的私有成员之一是B类的一个对象, 此时此时A类就是B类的友元类

class Date
{
    friend void Show(const Date& d);
    friend ostream& operator << (ostream& out, const Date& d);
    friend istream& operator >> (istream& in, Date& d);
    friend class Time;
public:
    Date(int year = 1900, int month = 1, int day = 1)
        :_year(year)
        ,_month(month)
        ,_day(day)
    {
        cout << "Date(int year = 1900, int month = 1, int day = 1)" << endl;
    }
    void Display()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
    ~Date()
    {
        cout << "~Date()" << endl;
    }
    Date(const Date& d)
    {
        this -> _year = d._year;
        this -> _month = d._month;
        this -> _day = d._day;
        cout << "Date(const Date& d)" << endl;
    }
    Date& operator = (const Date& d)
    {
        this -> _year = d._year;
        this -> _month = d._month;
        this -> _day = d._day;
        cout << "Date& operator = (const Date& d)" << endl;
        return *this;
    }
private:
    int _year;
    int _month;
    int _day;
};

class Time
{
public:
    Time(int year = 1900, int month = 1, int day = 1, int hour = 0, int minute = 0, int second  = 0)
        :_hour(hour)
         ,_minute(minute)
         ,_second(second)
    {
        _d._year = year;
        _d._month = month;
        _d._day = day;
    }
    void Show()
    {
        cout << _d._year << "-" << _d._month << "-" << _d._day << endl;
        cout << _hour << ":" << _minute << ":" << _second << endl;
    }
private:
    int _hour;
    int _minute;
    int _second;
    Date _d;
};

注意: 不是任何时候友元都比较好, 我们应该知道友元是对类的封装的一个突破, 所以应在下档的时候使用.

类的静态成员

类里面的成员用static 关键字进行修饰的都叫做静态成员. 其中静态成员是属于这个类的不属于某个对象,即static成员属于这个类的所有对象,不被某个对象所独有
静态成员函数没有隐含的this指针,那么在访问静态成员函数的时候只需要使用了类型::作用域访问符便可以调用该静态成员函数

//代码展示:
class Date
{
public:
    Date()
    {
        sCount++;
        cout << "Date() " << endl;
    }

    void Display()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

    static void PrintCount()
    {
        cout << "Date count:" << sCount << endl;
    }
private:
    int _year;
    int _month;
    int _day;
private:
    static int sCount;
};

int Date::sCount = 0;

void Test()
{
    Date d1,d2;
    Date::PrintCount();
}

注意静态成员函数不能访问非静态成员,但是非静态成员函数可以访问静态成员

几个小细节

1.匿名对象(date())存在的生命周期是它所在的那一行, 同时也要注意当我们已经自己写了拷贝构造函数的时候, 此时编译器就不会自动生成构造函数
2.等号两边两个类型不同的时候小类型会转向大类型
3.在写工程时,为什么.cpp和.h分开
(1)方便阅读
(2)封装(开源和闭源)
(3)提高编译速度