＜＜和＞＞操作符、取地址重载、const关键字

---

自定义类型<<和>>重载

在内置类型中，<<和>>可以自动识别

在自定义类型冲，运算符重载，<<和>>也可以重载，我们首先来认识一下，<<和>>

//>>流插入  将键盘输入的内容，赋值到变量中
//<<流提取	 将cout后面的内容输出到屏幕中

int main()
{
    
    
    int a;
    double b;
    Date date;//自定义类型输出的形式，系统无法规定(自定义类型的成员变量不同)，所以需要<<和>>重载
    cin>>a>>b;//系统可以自动识别类型
    cout<<a<<" "<<b<<endl;
    return 0;
}

<iostream>是C++中的输入输出流，istream是输入流，ostream是输出流（这样理解即可）

std::ostream::operator<<我们看到编译器对于内置类型进行了处理，接下来以Date类为例子，进行操作符<<重载

对于<<和>>总结

1.可以直接支持内置类型是因为库中实现了

2.可以直接支持自动识别类型是因为函数重载，传入对应类型的参数就可以调用对应的函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//Date
class Date
{
    
    
public:
     void operator<<(ostream& out);//我们使用的成员函数，所以默认this占用一个成员形参，调用这个函数的形式为  对象名.operator<<（cout）
    Date(int year, int month, int day)
    {
    
    
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
void Date::operator<<(ostream& out)
{
    
    
    out << _year << " " << _month << " " << _day << endl;
}
int main()
{
    
    
    Date date1(2010, 10, 10);
    Date date2(1012, 1, 10);
    Date date3(2001, 10, 10);

    date1.operator<<(cout);  //等同于date1<<cout
    //但是这一种明显不是我们需要的cout<<int  这种类型，所以我们要实现的是cout<<date1
    return 0;
}

为了实现cout<<date1 这样的写法，我们要使得ostream形参在前面，Date对象在后面，但是如果是在成员函数中，this对象总是占据第一个位置，date1.operator<<(cout) 实际上就是相当于，传递两个参数，第一个参数是this（date1），第二个参数才是为cout，所以为了解决这个问题（先调用cout（cout在前面）），我们应该使用全局函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//Date
class Date  //我们使用全局函数可以使得第一个参数为cout 从而实现cout<<date1 
{
    
    			//但是全局函数不在类中，无法使用私有成员变量，所以我们应该使用friend(在不破化原有封装性的基础上，打开一个口子，只是使得这个函数成为类似于共有函数（可以访问d的私有成员）)
public:
    friend ostream& operator<<(ostream& out, const Date& d);//传入形参为ostream类型，也就是输出流，传引用，那么
    Date(int year, int month, int day)
    {
    
    
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
//但是我们知道 cout<<int<<int  是库里支持的所以我们应该返回ostream来实现这个功能
ostream& operator<<(ostream& out, const Date& d)
{
    
    
    out << d._year << " " << d._month << " " << d._day << endl;//调用这个函数就可以输出我们规定的内容
    return out;
}//传引用返回
int main()
{
    
    
    Date date1(2010,10,10);
    Date date2(1012, 1, 10);
    Date date3(2001, 10, 10);

    cout << date1<<date2<<date3;
    return 0;
}

所以上面这个代码是最为符合库中对于内置类型的重载的，使用ostream&返回，并使用全局函数来实现cout在前，实例化成员在后，且可以连续<<

>>和<<是一个道理，都是istream&为返回值，然后使用传参先是istream& in 然后再是第二个参数const Date& d

//例子如下
class Date{
    
    
    public:
    friend istream& operator>>(istream& in,const Date& d);
    private:
    	int _year;
    	int _month;
    	int _day;
};
     istream& operator>>(istream& in,const Date& d)
     {
    
    
         //需要进行判断是否是合理的年月日，根据自定义类型成员变量的需求进行更改
         //这里就不去写判断日期是否合理
        int year, month, day;
		in >> year >> month >> day;
     }
int main()
{
    
    
    Date d;
    ///然后就可以实现流插入————插入进去，流提取————提取出来
    cin>>d;
    Date d1,d2,d3;
    cin>>d1>>d2>>d3;
    return 0;
}

上文就是对于流插入和流提取的运算符重载，主要内容就是使用istream&/ostream& 引用返回，使得第一个变量位置给了istream& in/ostream& out，第二个形参位置给了自定义类型

iostream是c++的标准库，里面包括但不限于istream（标准输入类）ostream（标准输出类）

const关键字

const的基本用法为，修饰变量或者是指针，使得其不能改变数值，或指向

//在C++中多了一种对于const的用法
class Date{
    
    
  public:
    Date(int year,int month,int day)
    {
    
    
        _year=year;
        _month=month;
        _day=day;
    }
    void Print() const  //使用const来修饰的是this指针  也就是 const Date* this,使得this指向的成员变量不能被改变
    {
    
    
        cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
    }
  private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    
    
    
    return 0;
}

const修饰指针的时候，如：const Date* this，不能改变的是this的成员变量，指针的指向是可以变化的

const修饰变量的时候，如：Date* const this，不能改变的是指针的指向，但是this的成员变量是可以变化的

const同时修饰指针和变量的时候，如：const Date* const this,指针的指向和this的成员变量都不能改变

请思考下面的几个问题：

1. const对象可以调用非const成员函数吗？
2. 非const对象可以调用const成员函数吗？
3. const成员函数内可以调用其它的非const成员函数吗？
4. 非const成员函数内可以调用其它的const成员函数吗？

对于上述问题，我们通过下面代码测试的得到答案

1.const对象不能调用非const的成员函数

2.非const对象是可以调用非const修饰的成员函数/const修饰的成员函数

3.const成员函数内，不能调用非const成员函数

4.非const成员函数内，可以调用非const修饰的成员函数/const修饰的成员函数

#define _CRT_SECURE_NO_WARNINGS

#include<iostream>

using namespace std;

//在C++中多了一种对于const的用法
class Date {
    
    
public:
    Date(int year, int month, int day)
    {
    
    
        _year = year;
        _month = month;
        _day = day;
    }
    void Print() const  //使用const来修饰的是this指针  也就是 const Date* this,使得this指向的成员变量不能被改变
    {
    
    
        cout << _year << "-" << _month << "-" << _day << endl;
        //这是const修饰的成员函数
        Print2();//说明不能调用非const函数
    }
    void Print2() {
    
    
        Print();//说明可以调用const修饰的函数
    }
    void plus_year()
    {
    
    
        _year++;
    }
    
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    
    
    Date d1(1, 1, 1);
    const Date d2(2, 2, 2);//创建两个变量，分别为非const和const修饰
    d1.Print();
    d2.Print();//调用const修饰的函数，说明是可以的

    d1.plus_year();
    d2.plus_year();//const修饰的成员不能调用非const修饰的成员
    return 0;
}

下面的对于const的一些小问题，权限可以变小，但是不能放大

int main()
{
    
    
    const int a=10;
    int b=a;  //这一个是正确的，因为只是将a的数值拷贝赋值给b，b的改变不会影响a，所以正确
    
    const int c=10;
    int& d=c;	//这是错误的，因为d引用c，使得d可以改变c（c不能被改变），const变量权限小于普通变量，涉及到权限放大，所以这是错误的
    
    const int e=10;
    int*pf=&e;	//错误，这个和引用是类似的，都是涉及到权限放大
    return 0;
}

取地址重载（类的默认构造函数）

前面四个类中默认的成员函数都已经学习，我们来学习一下剩下这两个取地址重载的默认成员函数

取地址重载主要就是针对普通成员和const对象取地址，但是这两个会自己去实现，实际上使用默认的即可

class Date{
    
    
  public:
    Date* operator&()  //对于普通成员
    {
    
    
        cout<<"非const"<<endl;
        return this;//取地址，返回的是指针类型
    }
    Date* operator&() const
    {
    
    
        cout<<"const"<<endl;
        return this;//对于const修饰的成员
    }
};
int main()
{
    
    
    Date d1;
    const Date d2;
   	Date* d3=&d1;
    const Date* d4=&d2;
    return 0;
}

一般来说，使用编译器默认的取地址重载即可，但是对于一些特殊情况是可以使用取地址重载的，比如说，只是取出来这个this对象中某一成员变量的地址，获取指定的内容的时候