对类重载操作符，永远是对类的对象自身起作用，而不可能对于类的成员。当调用操作符的时候，编译器会解析调用操作符的对象的类型。
fm.myName++;
这样实际上是在对MyName调用++操作符，而MyName类型是一个枚举，对枚举重载运算符是必须使用全局定义的（稍后会讲如何全局定义），所以你的
定义完全不可能达到你的期望。
++和--运算符各有两种，第一种是前置，第二种是后置。如何区分这两种形式也让C++标准委员会的人伤透了脑筋，最后他们终于想出了一个没有办法，那就
是让后置比前置多一个int参数加以区别，尽管这个int什么也不做，没有任何意义，请看：
class A
{
public:
A& operator++( void ) {
m = m + 1; return *this;} //前置
const A&
operator++( int ); { int n = m; m = m - 1;
return *this;} // 后置
private:
int m;
};
这里面有几个问题：
一，因为后置运算符的int参数什么也不做，所以我们没有必要为其定义具名实参，空着就可以了，这样的语法是允许的。
二，在C++中对于一个int型变量i的操作：
(++i)++; //允许
++(i++);
//不允许
因此我们需要模仿内置内型的形为，让前置返回非常量，而后置返回常量。
三，我们必须返回引用，因为必竟这是基于类自身的形为，而且用户可能会对于你返回的对象做一些其它的操作，比如：
A a;
(++a).somefunc(); // 假设somefunc是非const成员函数，并对数据成员做了修改
a.show(); //打印出了数据成员
如果你返回的不是引用，那么打印出的数据成员可能与你的想象不符
四，前置的概念是先算后用，后置的概念是先用再算，所以代码上有较大区别，但如果重载的是一个模版的话，我们必须要考虑在后置类型中的构造行为是否会与实
例化的类型有冲突，比如用户的类类型有一个private的默认构造……扯的太远了。
下面讲一下如何定义全局重载操作符，还是用++来说话。比如你有一个类的定义如下：
class
B
{
public:
int m;
};
这也许是你使用的别的类库中的一个类，但你还是想为它重载++，那么你可以这样定义两个全局函数：
B& operator++( B& lhs ) // 前置++
{
lhr.m = lhr.m + 1;
return
lhr;
}
const B& operator++( B&
lhs, int ) // 后置++
{
int n
= lhs.m;
lhs.m = lhs.m + 1;
return lhs;
}
可以看到，全局的运算符比起局部的运算符重载多了一个参数，那就是参数表的头一个，指向需要操作的对象的引用。这样的行为和局部运算符重载其实很类似，重
载的局部运算符实际上的头一个参数也是指向自身的指针，也就是传说中的this指针，只不过被隐藏起来了罢了。
==========================
一、什么是操作符重载？
一看到重载，很容易就让人联想到成员函数重载，函数重载可以使名称相同的函数具有不同的实际功能，只要赋给这些同名函数不同的参数就可以了，操
作符重载也是基于这一机制的。系统为我们提供了许多操作符，比如“＋”，“[
]”等，这些操作符都有一些默认的功能，而操作符重载机制允许我们给这些操作符赋予不同的功能，并能够按照普通操作符的使用格式来使用自己定义功能的操作符（即重载的操作符）
。
定义之后，我们就可以按照平常使用操作符的格式来使用我们自己的重载操作符了。
操作符重载一般在类内部定义，就像成员函数一样定义，这叫做类成员重载操作符。当然也可
以在类外定义
，即非类成员操作符重载。
二、为什么要使用操作符重
载？
举例说明，比如类String，该类有这样一个功能，可以将两个字符串连接成一个字符串，为此，我们可以给类String定义一个成员函数实现
此功能，可以给该函数取一个形象的名字，比如concatenate或append，但是相比较，这两个名字都不如操作符“+=”形象直观。在这种情况
下，我们就可以定义操作符“+=”的重载，来实现此功能。
也就是说，如果要定义一个函数，而这个函数的功能与操作符的功能比较类似时，这个时候我们就可以定义重载操作符，而不使用通常的成员函数定义。
这里所说的操作符重载，指的是与系统定义的操作符重载，而不是说定义两个“
+=
”，这两个重载，这一点需要清楚。
但是这四个操作符不能用于重载：
:: * ? :
三、如何声明操作符重载？
同普通函数类似，只不过它的名字包括关键字
operator
，以及紧随其后的一个预
定义操作符
。例如：
String& operator+=(const String&)
;
String& operator+=(const char*)
;
注意：上面的括号表示形式参数，即使操作符重载不需要参数，也应该写上一个空的“(
)”，而不是将其省略，这一点其实和普通函数的声明是类似的。其实，声明的唯一区别就是名字不同而已
。
四、怎样使用操作符重载？
两种操作符重载：类成员操作符重载和非类成员操作符重载。
1、类成员操作符重载
已知类String中声明了两个“==”操作符重载，分别是：
bool operator==(const char*) const;
bool operator==(const String&) const;
其中第一个重载的操作符允许我们比较一个String类对象是否等于一个C风格字符串，第二个允许我们比较两个String类对象是否相等。
示例代码：
#include<String.h>
int main()
{
String flower;
If(flower==”lily”) //
正确：调用bool operator==(const
char*) const;
……
else
if(“tulip”==flower) //
错误
…….
}
关键看一下，为什么第二个重载操作符的使用是错误的？
因为：只有在左操作数是该类类型的对象时，才会考虑使用作为类成员的重载操作符。
因为这里的”tulip”不是String类型对象，所以编译器试图找到一个内置操作符，它可以有一个C风格字符串的左操作数，然而事实上并不
存在这样的操作符，所以编译时产生错误。
疑问：我们可以使用
String类的构造函数将一个C风格字符串，转换成一个String对象，为什么编译器不能做以上转换呢？即
if(String(“tulip”)==flower);//
这样就是正确的
答：为了效率和正确
性
重载操作符并不要求两个操作数的类型一定相同。可能有这样一个类Text，这个类的构
造函数的参数及其成员重载操作符的参数都与String类一致，如果使编译器能够自动将C风格字符串转换成某个类型的对象，那么编译器首先会检索所有的类
定义，选择能够提供正确构造函数和重载操作符的类进行转换，这无疑会增加程序的编译时间，还有就是类String和类Text均合适，编译器也不知道该将
C风格字符串转换成String还是Text对象了。
对于类成员重载操作符
，隐式的this指针被用作隐式的第一个参数，对于
成员操作符，flower==”lily”
会被编译器重写为：
flower.operator==(“lily”);
2、非类成员操作符重载
为了解决上面的问题，我们可以考虑使用非类成员操作符代替类成员操作符，这样做的好处是左操作数不必非要是某个类的类型对象
了，对
于需要两个操作数的操作符重载，我们就可以定义两个参数了
。比如：
bool operator==(const String&,const String&);
bool operator==(const String&,const char*);
可以看到，这两个全局重载操作符比成员操作符多了一个参数。
这样定义之后，还是上面的代码，当调用flower==”lily”时，会调用上面的bool operator==(const
String&,const char*);。
然而“tulip”==flower会调用哪个操作符重载呢，我们并没有定义bool operator==(const
char*,const
String&);，我们是不是必须定义这样一个全局操作符重载呢？答案是否定的，因为当一个重载操作符是一个名字空间函数时，对于操作符的第一
个和第二个参数，即等于操作符的左右两个操作数都会考虑转换，就像
int vi=1; double vd=2.0; vi=vi+vd; 会先将vd转换成int型，再做加法一样
这意味着，编译器将解释第二个用法如下：
bool operator==(String(“tulip”),flower)。这样会增加系统转换开销。
因此，如果需要频繁比较C风格字符串和String对象，那么最好定义上面的操作符重载，如果不频繁，我们只需定义下面一个就够了：
bool operator==(const String&,const String&);
分析：什么时候定义类成员操作符重载，什么时候定义非类成员操作符重载？
答：（1）如果一个重载操作符是类成员，那么只有当跟它一起使用的左操作数是该类对象时，它才会被调用，如果该操作符的左操作数必须是其他类
型，那么重载操作符必须是非类成员操作符重载。
（2）C++要求，赋值（=），下标（[
]），调用（()）和成员访问箭头（->）操作符必须被指定为类成员操作符，否则错误。
我们只能为类类型或枚举类型的操作数定义重载操作符，我们可以这样实现：把重载操作符声
明为类的成员，或者声明为非类成员重载操作符但同时至少有一个类或者枚举类型的参数（按值传递或按
引用传递）。
这句话的意思，实际是说我们不能修改内置类型的操作符重载或添加操作符重载，比如下面的声明便是错误的：
int operator+(int,int);
这改变了内置类型int的+操作符的功能，所以错误。
操作符重载相关知识点：
五、友元（friend）
考虑到类成员操作符重载可以访问类中的私有变量，但是非类成员重载操作符却不能很方便的访问类的私有成员，为了方便起见，我们可以通过使用友元（
friend
）
的方式，方便的访问类的私有成员。
举例：
class String
{
friend
bool
operator==(const String&,const String&);
friend
bool
operator==(const String&,const char*);
public:
//……..
private:
//………
}
注意：
friend
声明紧跟在类名之后，而不是放在
public
、
private
或
protected
中，因为友元不是授权类的成员，并且该关键字只能出现在类中。
经过上述声明之后，我们的非类成员重载操作符就可以直接方位String类的私有成员了。当然我们也可以不使用友元，而使通过该类的共有成员函
数来间接访问该类的私有成员也是可以的，内联函数inline就不错，效率也不低。
由此看来，声明友元（
friend
）主要是为了方便高效的访问类的私有成员变量。
分析：什么时候应该使用友元：
（1）
某个类不提供公有的访问私有成员的函数。
（2）
使用共有成员函数访问私有成员变量效率比较差
时。
友元除了用在非成员的重载操作符外，一个名字空间函数（比如全局函数），另一个在此之前定义的类
的成员函数或者一个完整的类，均可以声明为某个类的成员。
如下声明：
class B;
class A
{
friend class B;
public:
//…….
Private:
//……
}
通过上述声明，类A的成员函数可以访问所有的类B的私有成员，同样类B的成员函数可以访问所有类A的私有成员。
六、
类类型对象的隐式类型转换
我们知道，系统提供的内置类型有隐式类型转换的功能，实际上我们也可以为自己编写的类提
供隐式类型转换功能。这样，当我们在使用这种类的对象时，如果需要，编译器会自动调用该类的类型转换函数，实现类型转换功能。
C++提供了这样一种机制，通过它，每个类都可以定义一组“可被应用在该类型对象上的转换”
举例：
class SmallInt
{
public:
SmallInt(int ival):val(ival){};
operator int(){return
value;} ;//
类型转换操作符
SmallInt->int
private:
int value;
}
在上例中，操作符int()是一个转换函数，它定义了一个用户转换，实现在类类型和转换函数中指定的类型之间的转换，本例中，目标类型是
int。
经过上面的定义后，SmallInt对象便可以用在任何可以使用int的地方，例如：
SmallInt si（3）;
si+3.1415926;
这样，首先调用SmallInt转换函数，产生int型值3，然后将3变为3.0，和3.1415926相加。
实际上，上面类中定义转换函数还有一个好处就是：
省略了为该类定义重载操作符，尤其是重载操作符参数类型多样时。
1、
转换函数
格式：operator type( ); //
参数必须为空，且
( )
不能省略，并且无返回值类型。
说明：type
表
示目标类型，它可以用内置类型，类类型或
typedef
名取代，但不允许表示数组，转换函数必须是类的成员函数，并且不能指定返回类型和参数表。
显式的强制类型转换会导致调用转换函数
，如果被转换值的类型是一个类类
型，它有一个转换函数，并且该转换函数的类型是强制转换所指定的类型，则调用这个类的强制转换函数。
比如：
char* tokName=static_cast<char*>(tok);//tok
表
示对象，它所属的类提供一个到char*的转换函数。
2、
用构造函
数作为转换函数
在一个类的构造函数中，凡是只带有一个参数的构造函数，例如
SmallInt
的构造函数SmallInt（int），都定义了一组隐式转换，把构造函数的参数类型转换成该类类
型。
注意：是将int转换成SmallInt型。和前面说的转换函数功能正好相反。
举例：
void calc(SmallInt);
int vi;
calc(vi);
这时，编译器就会隐式调用类SmallInt的构造函数SmllInt（int），将vi转换成SmallInt对象，然后再将这个对象传递给
函数calc( )。
可以这样理解：
{
SmallInt temp=SmallInt(i);
Calc(temp);
}
这个大括号指出temp这个临时对象的生命周期。
注意：编译器不会使用一个显式构造函数（关键字explicit标志）来执行隐式类型转换，但是却可以使用这样的构造函数来进行强制转换（即
static_cast<>）。
转自http://blog.youkuaiyun.com/btooth/archive/2006/07/26/981245.aspx
扫一扫
426
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
