舱位声明：

class unaryOperators 
{
    public:
        int i;

        unaryOperators (int tempI = 0)
        {
            i = tempI;
        }

        unaryOperators operator++ (int);
        unaryOperators operator++ ();
};

此全局定义是否与重载运算符的后缀或前缀版本相对应？为什么？

unaryOperators operator++ (unaryOperators &one)
{   
    return one; 
}

unaryOperators& operator++ (unaryOperators &one)
              ^^

是非成员前缀一元增量运算符.

非成员后缀一元增量运算符将另外的int作为策略强制参数.

unaryOperators operator++ (unaryOperators &one,int)

参考：

C 03标准13.5.7增量和减量[over.inc]

The user-defined function called operator++ implements the prefix and postfix ++ operator. If this function is a member function with no parameters,or a non-member function with one parameter of class or enumeration type,it defines the prefix increment operator ++ for objects of that type. If the function is a member function with one parameter (which shall be of type int) or a non-member function with two parameters (the second of which shall be of type int),it defines the postfix increment operator ++ for objects of that type. When the postfix increment is called as a result of using the ++ operator,the int argument will have value zero.125)

[Example:
class X {
   public:
      X& operator++(); // prefix ++a
      X operator++(int); // postfix a++
};
class Y { };
Y& operator++(Y&); // prefix ++b
Y operator++(Y&,int); // postfix b++

void f(X a,Y b) {
++a; // a.operator++();
a++; // a.operator++(0);
++b; // operator++(b);
b++; // operator++(b,0);
a.operator++(); // explicit call: like ++a;
a.operator++(0); // explicit call: like a++;
operator++(b); //explicit call: like ++b;
operator++(b,0); // explicit call: like b++;
}
—end example]

我正在阅读 the C++ FAQ.在那里,我发现操作符重载使用的指南中有一点：

If you provide constructive operators,they should allow promotion of the left-hand operand (at least in the case where the class has a single-parameter ctor that is not marked with the explicit keyword). For example,if your class Fraction supports promotion from int to Fraction (via the non-explicit ctor Fraction::Fraction(int)),and if you allow x – y for two Fraction objects,you should also allow 42 – y. In practice that simply means that your operator-() should not be a member function of Fraction. Typically you will make it a friend,if for no other reason than to force it into the public: part of the class,but even if it is not a friend,it should not be a member.

为什么作者写的是operator-()不应该是成员函数？

如果我将operator-()作为成员函数,还有什么后果呢？

这里是作为成员函数的运算符的分数：

class Fraction{    Fraction(int){...}    Fraction operator -( Fraction const& right ) const { ... }};

有了它,这是有效的代码：

Fraction x;Fraction y = x - 42;

其等效于x.operator-(Fraction(42));但这不是：

Fraction z = 42 - x;

因为42没有成员函数运算符(当然,它甚至不是一个类).

但是,如果您将运算符声明为自由函数,则转换操作将适用于其两个参数.所以这

Fraction z = 42 - x;

变成这样

Fraction z = Fraction(42) - x;

这相当于运算符 – (分数(42),x)).

我想重载operator<<对于任意数组,使得代码cout<< my_arr会起作用.首先,我试图重载operator<<的第二个参数.在const T(& arr)[N]上,其中T和N是模板参数.但是测试代码会发现副作用：const char []也匹配类型规范,新的重载与流类中定义的重载冲突.示例代码：

#include <cstddef>
#include <iostream>

template<typename T,std::size_t N>
std::ostream& operator<<(std::ostream& os,const T (&arr)[N])
{
    /* do stuff */
    return os;
}

int main()
{
    std::cout << "noooo\n"; /* Fails: ambiguous overload */
}

这样的阵列打印运算符是否仍然可以实现？

当然：

template<typename T,std::size_t N>
typename std::enable_if<!std::is_same<T,char>::value,std::ostream&>::type
operator<<(std::ostream& os,const T (&arr)[N])
{
    // ...
}

这将使用SFINAE在T为char时禁用您的重载.

对于C 03,Boost有enable_if和is_same.或者只是自己滚动：

template<class T,class U> struct is_same { 
    enum { value = false }; 
};
template<class T> struct is_same<T,T> { 
    enum { value = true }; 
};

template<bool,class T> struct enable_if {};
template<class T> struct enable_if<true,T> { 
    typedef T type; 
};