文章目录
- 自定义类型<<和>>重载
- 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的成员变量都不能改变
请思考下面的几个问题：
- const对象可以调用非const成员函数吗？
- 非const对象可以调用const成员函数吗？
- const成员函数内可以调用其它的非const成员函数吗？
- 非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对象中某一成员变量的地址，获取指定的内容的时候
