关于enum && 运算符重载

枚举：
C++中的枚举提供了另一种创建符号常量的方式，它允许定义新类型，但必须严格的限制执行。
enum spectrum{red,orange,yellow,green,blue,violet,indigo,ultraviolet};
这条语句完成两项任务：
1、 spectrum称为一种新类型的名称，spectrum称为枚举，就像struct变量
2、 将red、orange等作为符号常量，它们对应的数值0~7，这些常量被称为枚举量
在默认的情况下，将整数值赋给枚举量，第一个枚举量的值为0，第二个枚举量的值为1，依次类推。

枚举变量：
spectrum band;
1、 不进行强制类型转换
只能将定义枚举时使用的变量赋给这种枚举的变量
band=blue; //valid
band=200; //invalid
因此，spectrum变量受到限制，只有8个可能的值。如果试图将一个非法值赋给它，则有些编译器会报错。
对于枚举只定义了【赋值运算符】，没有算术运算
band=orange; //valid
++band; //invalid
band=orange+red; //invalid
2、 进行强制类型转换
枚举量是整型，可以被提升为int类型。但是int类型不能转换为枚举类型。
int color=blue; //valid 枚举类型被提升为int类型
band=3; //invalid int不能转换为枚举类型 即使3在枚举范围内
color=3+red; //valid

如果int值是有效的[就是枚举范围]，则可以通过强制类型转换，将它赋值给枚举变量。
band=spectrum(3); //valid,将int类型的3转换为枚举变量类型
band=spectrum(400003); //invalid 范围的错误

3、 设置枚举量的值
1、可以使用赋值运算符显示地设置枚举量的值
enum bits{one=1,two=2,four=4,eight=8};
2、指定的值必须是整型，也可以只显示地定义其中一些枚举量的值：
enum bigstep{first,second=100,third};
这里的first默认情况下为0，后面没有初始化的枚举量的值比前面的枚举量大1，因此third=101;
3、可以创建多个值相同的枚举量
enum aa{zero,null=0,one,numero_uno=1};

4、 枚举的取值范围
通过C++强制转换类型，增加了可赋给枚举变量的合法值。每个枚举都有取值范围，通过强制类型转换，可以将取值范围中的任何整数值赋给枚举变量，即使这个值不是枚举值。
enum bits{one=1,two=2,four=4,eight=8};
bits myflag; //myflag枚举变量
myflag=bits(6); //valid,6不是枚举值，但是在取值范围内

【取值范围计算】
首先找出上限，
找到大于这个最大值的，最小的2的幂，将它减去1，得到的便是取值范围的上限。
例如，bigstep的最大值为101，在2的幂中，比这个数大的最小值是128，因此取值范围上限是127。
[64=2^6<101<27=128] 128-1=127
然后是下限，
如果最小值不小于0，则取值范围的下限是0；
否则采用与寻找上限相同的方法，但是要加上负号。加1
例如：如果最小的枚举量是-6，而比它小的、最大的的幂是-8，因此下限是-7。
[-8=-2^3<-6<-22=-4] -8+1=-7

运算符重载：
例如：将运算符用于地址，将得到存储在这个地址中的值；但将它用于两个数字时，得到将是它们的乘积；
要重载运算符，需使用被称为运算符函数的特殊函数形式。
operatorop(argument-list)
例如：operator+() 重载+运算符
operator() 重载*运算符
operator 重载[]数组索引运算符
op必须是有效的C++运算符，不能虚构一个新的符号。

Demo:
//加法运算符
#include
using namespace std;

class Time
{
public:
Time();
Time(int h,int m=0);
void AddMin(int m);
void AddHr(int h);
void Reset(int h=0,int m=0);
Time operator+(const Time& t) const;
void show() const;
private:
int hours;
int minutes;
};
Time::Time()
{
hours = minutes = 0;
}
Time::Time(int h,int m)
{
hours = h;
minutes = m;
}
void Time::AddHr(int h)
{
hours += h;
}
void Time::AddMin(int m)
{
minutes += m;
hours += minutes / 60;
minutes = minutes % 60;
//minutes %= 60;
}
void Time::Reset(int h, int m)
{
hours = h;
minutes = m;
}
/*
operator+()是由Time对象调用，它将第二个Time对象作为参数，并返回一个Time对象。
total=coding.operator+(fixing);
但是将该方法命令为operator+()后，也可以使用运算符表示法：
total=codeing+fixing;
这两种方法都将调用operator+()方法。注意，在运算符表示法中，运算符左侧的对象(这里为coding)是调用对象，
运算符右边的对象(这里是fixing)是作为参数被传递的对象。
/
/
返回值不能是引用，函数将创建一个新的对象(sum),来表示另外两个Time对象的和。
返回对象（如代码所做那样）将创建对象的副本，而调用函数可以使用它。
然而，如果返回类型是Time&,则引用的将是sum对象。
但是由于sum对象是局部变量，在函数结束时将被删除，因此引用将指向一个不存在的对象。
使用返回类型Time意味着程序将在删除sum之前构造它的拷贝，调用函数将得到该拷贝。

【警告：不要返回指向局部变量或临时变量的引用。函数执行完毕后局部变量和临时对象将消失，引用将指向不存在的数据】
*/

Time Time::operator+(const Time& t) const
{
Time sum;
sum.minutes = minutes + t.minutes;
sum.hours = hours + t.hours+sum.minutes/60;
sum.minutes %= 60;
return sum;
}

void Time::show() const
{
cout << hours << “hours,” << minutes << “minutes”;
}
int main()
{
Time planning;
Time coding(2,40);
Time fixing(5,55);
Time total;

cout << "planning time = ";
planning.show();
cout << endl;

cout << "coding time = ";
coding.show();
cout << endl;

cout << "fixing time = ";
fixing.show();
cout << endl;

total = coding + fixing;
//运算符定义
cout << "coding+fixing=";
total.show();
cout << endl;

Time morefixing(3,28);
cout << "more fixing time = ";
morefixing.show();
cout << endl;

//函数定义 operator+
total = morefixing.operator+(total);
cout << "morefixing.operator+(total)";
total.show();
cout << endl;

system("pause");
return 1;

}
/*
运行结果：
planning time = 0hours,0minutes
coding time = 2hours,40minutes
fixing time = 5hours,55minutes
coding+fixing=8hours,35minutes
more fixing time = 3hours,28minutes
morefixing.operator+(total)12hours,3minutes
*/

重载运算符：作为成员函数 还是 非成员函数
一般来说，非成员函数应是友元函数，这样它才能直接访问类的私有数据。
例如：
Time operator+(const Time& t) const; //成员函数
friend Time operator+(const Time& t) const; //友元函数
[友元函数虽然写在类里加上friend,但是在类外定义的时候，不需要加上Time:: ，因为友元函数不是类成员]

对于成员函数，一个操作数通过this指针隐式地传递；另一个操作数作为函数参数显式地传递；【成员版本所需参数数目少一个】
对于友元版本来说，两个操作数都作为参数来传递。【形参参数与运算符使用的操作数数目相同】