小白学习，c++基础（七）

1、const

1.1修饰成员函数
用const修饰的成员函数时，const修饰this指针指向的内存区域，成员函数体内不可以修改本类中的任何普通成员变量， 当成员变量类型符前用mutable修饰时例外。

int myFun(void) const //const修饰的是成员函数
{}//函数内部不能修改普通成员变量  mutable修饰时例外

1.2、const修饰对象叫常对象
const int num = 10;//系统不会给num开辟空间 num被放入符号表中 如果后期对&num 这时系统才会给num开辟空间

2、友元

c++允许 友元 访问 私有数据。
友元的语法：
friend关键字只出现在声明处 其他类、类成员函数、全局函数都可声明为友元 友元函数不是类的成员，不带this指针 友元函数可访问对象任意成员属性，包括私有属性。
2.1、普通全局函数作为类的有元

class Room
{
    //将goodGayVisit作为类的友元函数
    //goodGayVisit 访问 类中所有数据 但是 它不是类的成员
    friend void goodGayVisit(Room &room);
private:
    string bedRoom;//卧室
public:
    string sittingRoom;//客厅
public:
    Room()
    {
        this->bedRoom = "卧室";
        this->sittingRoom="客厅";
    }
};

// 普通全局函数 作为 类的友元
//好基友 访问 我的房间
void goodGayVisit(Room &room)
{
    cout<<"好基友访问了你的"<<room.sittingRoom<<endl;
    cout<<"好基友访问了你的"<<room.bedRoom<<endl;//ok
}
void test01()
{
    Room myRoom;
    goodGayVisit(myRoom);
}

2.2、类的某个成员函数 作为另一个类的友元

#include <iostream>

using namespace std;
class Room;//Room向前声明
class GoodGay
{
public:
    void visit1(Room &room);//此处的Room 被上方 class Room
    void visit2(Room &room);
};


class Room
{
    //如果想方 visit2作为Room类的友元 那么Visit2就可以访问 Room的私有数据
    //一定要记得 加类作用域
    friend void GoodGay::visit2(Room &room);
private:
    string bedRoom;//卧室
public:
    string sittingRoom;//客厅
public:
    Room()
    {
        this->bedRoom = "卧室";
        this->sittingRoom="客厅";
    }
};

void GoodGay::visit1(Room &room)
{
    cout<<"好基友visit1访问了你的"<<room.sittingRoom<<endl;
    //cout<<"好基友visit1访问了你的"<<room.bedRoom<<endl;//不能访问 Room私有数据
}

void GoodGay::visit2(Room &room)
{
    cout<<"好基友visit2访问了你的"<<room.sittingRoom<<endl;
    cout<<"好基友visit2访问了你的"<<room.bedRoom<<endl;
}

int main(int argc, char *argv[])
{
    Room myRoom;
    GoodGay goodGay;

    goodGay.visit1(myRoom);//只能访问客厅
    goodGay.visit2(myRoom);//客厅 卧室 都可以访问

    return 0;
}

2.3、一个类整体作为另一个类的友元
一个类的所有成员函数 访问 另一个类的私有数据

#include <iostream>

using namespace std;
class Room;//Room向前声明
class GoodGay
{
public:
    void visit1(Room &room);//此处的Room 被上方 class Room
    void visit2(Room &room);
};


class Room
{
    //将GoodGay作为Room的友元
    //GoodGay 所有成员函数 都可以访问 Room私有数据
    friend class GoodGay;
private:
    string bedRoom;//卧室
public:
    string sittingRoom;//客厅
public:
    Room()
    {
        this->bedRoom = "卧室";
        this->sittingRoom="客厅";
    }
};

void GoodGay::visit1(Room &room)
{
    cout<<"好基友visit1访问了你的"<<room.sittingRoom<<endl;
    cout<<"好基友visit1访问了你的"<<room.bedRoom<<endl;
}

void GoodGay::visit2(Room &room)
{
    cout<<"好基友visit2访问了你的"<<room.sittingRoom<<endl;
    cout<<"好基友visit2访问了你的"<<room.bedRoom<<endl;
}

int main(int argc, char *argv[])
{
    Room myRoom;
    GoodGay goodGay;

    goodGay.visit1(myRoom);
    goodGay.visit2(myRoom);

    return 0;
}

3、运算符重载

3.1、重载运算符的概述
运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
运算符重载的目的：简化操作 让已有的运算符 适应适应不同的数据类型。
语法：函数的名字由关键字operator及其紧跟的运算符组成
比如：重载+运算符 ==>operator+ 重载=号运算 ==>operator=
注意：重载运算符 不要更改 运算符的本质操作（+是数据的相加 不要重载成相减）
3.2、运算符<<的重载

#include <iostream>
#include<string.h>
using namespace std;
class Person
{
    //设置成友元函数 在函数内 访问Person类中的所有数据
    friend ostream& operator<<(ostream &out, Person &ob);
private:
    char *name;
    int num;
public:
    Person(char *name, int num)
    {
        this->name = new char[strlen(name)+1];
        strcpy(this->name,name);
        this->num = num;
        cout<<"有参构造"<<endl;
    }
    //普通的成员函数
    void printPerson(void)
    {
        cout<<"name = "<<name<<", num = "<<num<<endl;
    }
    ~Person()
    {
        if(this->name != NULL)
        {
            delete [] this->name;
            this->name = NULL;
        }
        cout<<"析构函数"<<endl;
    }
};

ostream& operator<<(ostream &out, Person &ob)//out=cout, ob =ob1
{
    //重新实现 输出格式
    out<<ob.name<<", "<<ob.num;

    //每次执行为 返回值得到cout
    return out;
}
int main(int argc, char *argv[])
{
    Person ob1("lucy",18);
    //普通的成员函数 遍历信息
    //ob1.printPerson();

    //cout默认输出方式 无法识别 自定义对象 输出格式
    //cout<<ob1<<endl;//err

    //运算符重载的调用方式1:
    operator<<(cout, ob1)<<endl;
    //运算符重载的调用方式2:
    //对方法1 进行优化 去掉operator,第一个参数 放在运算符<<的左边  第二个参数 放在运算符<<的右边
    cout<<ob1<<endl;//等价operator<<(cout, ob1);

    Person ob2("bob",19);
    cout<<ob1<<" "<<ob2<<endl;

    return 0;
}

3.3、重载+运算符：全局函数作为友元，完成运算符重载+

#include <iostream>
#include<string.h>
using namespace std;
class Person
{
    //设置成友元函数 在函数内 访问Person类中的所有数据
    friend ostream& operator<<(ostream &out, Person &ob);
private:
    char *name;
    int num;
public:
    Person()
    {
        this->name = NULL;
        this->num = 0;
        cout<<"无参构造"<<endl;
    }
    Person(char *name, int num)
    {
        this->name = new char[strlen(name)+1];
        strcpy(this->name,name);
        this->num = num;
        cout<<"有参构造"<<endl;
    }
    //成员函数 完成运算符重载 ob1用this代替 ob2用参数ob代替
    Person operator+(Person &ob)
    {
        //this ==> &ob1

        //name+name(字符串追加)
        char *tmp_name = new char[strlen(this->name)+strlen(ob.name)+1];
        strcpy(tmp_name,this->name);
        strcat(tmp_name,ob.name);

        //num+num（数值相加）
        int tmp_num = this->num+ob.num;
        Person tmp(tmp_name, tmp_num);

        //释放tmp_name的空间
        if(tmp_name != NULL)
        {
            delete [] tmp_name;
            tmp_name = NULL;
        }

        return tmp;
    }

    //普通的成员函数
    void printPerson(void)
    {
        cout<<"name = "<<name<<", num = "<<num<<endl;
    }
    ~Person()
    {
        if(this->name != NULL)
        {
            delete [] this->name;
            this->name = NULL;
        }
        cout<<"析构函数"<<endl;
    }
};

//全局函数作为友元 完成运算符重载<<
ostream& operator<<(ostream &out, Person &ob)//out=cout, ob =ob1
{
    //重新实现 输出格式
    out<<ob.name<<", "<<ob.num;

    //每次执行为 返回值得到cout
    return out;
}

void test03()
{
    Person ob1("lucy",18);
    Person ob2("bob", 19);

    //Person ob3 = ob1.operator+(ob2);
    Person ob3 = ob1+ob2;
    cout<<ob3<<endl;
}
int main(int argc, char *argv[])
{
    test03();

    return 0;
}