How to overload the operator++ in two different ways for postfix a++ and prefix ++a?

How to overload the operator++ in two different ways for postfix a++ and prefix ++a?

94946 次浏览
小开

区别在于为 operator ++的重载选择什么签名。

引自相关 article on this subject in the C++ FAQ(详情请浏览此网页) :

class Number {
public:
Number& operator++ ();     // prefix ++: no parameter, returns a reference
Number  operator++ (int);  // postfix ++: dummy parameter, returns a value
};

P.S. : 当我发现这一点时，我最初看到的只是虚拟参数，但不同的返回类型实际上更有趣; 它们可能解释了为什么 ++x被认为比 x++ 一般来说更有效。

小开

声明如下:

class A
{
public:
A& operator++();    //Prefix (++a)
A operator++(int); //Postfix (a++)


};

正确实施-不要搞乱每个人都知道他们在做什么(增量然后使用，使用然后增量)。

小开
最佳答案

应该是这样的:

class Number
{
public:
Number& operator++ ()     // prefix ++
{
// Do work on this.   (increment your object here)
return *this;
}


// You want to make the ++ operator work like the standard operators
// The simple way to do this is to implement postfix in terms of prefix.
//
Number  operator++ (int)  // postfix ++
{
Number result(*this);   // make a copy for result
++(*this);              // Now use the prefix version to do the work
return result;          // return the copy (the old) value.
}
};
小开

对于类型 T，有两种方法可以重载两个(前缀/后缀) + + 运算符:

对象方法:

这是最简单的方法，使用“通用”OOP 习惯用法。

class T
{
public :
T & operator++() // ++A
{
// Do increment of "this" value
return *this ;
}


T operator++(int) // A++
{
T temp = *this ;
// Do increment of "this" value
return temp ;
}
} ;

Object non-member function:

This is another way to do this: As long as the functions are in the same namespace as the object they are referring too, they will be considered when the compiler will search for a fonction to handle ++t ; or t++ ; code:

class T
{
// etc.
} ;




T & operator++(T & p_oRight) // ++A
{
// Do increment of p_oRight value
return p_oRight ;
}


T operator++(T & p_oRight, int) // A++
{
T oCopy ;
// Copy p_oRight into oCopy
// Do increment of p_oRight value
return oCopy ;
}

重要的是要记住，从 C + + 的观点(包括 C + + 编译器的观点)来看，那些非成员函数仍然是 T 的接口的一部分(只要它们在相同的名称空间中)。

非成员函数表示法有两个潜在的优点:

  • 如果您设法在不使它们成为 T 的朋友的情况下对它们进行编码，那么您就增加了 T 的封装
  • 您甚至可以将其应用于其代码不属于您的类或结构。这是一种非侵入性的方法，可以在不修改对象声明的情况下增强对象的接口。
小开

我知道现在很晚了，但是我也遇到了同样的问题，并且找到了一个更简单的解决方案。不要误解我的意思，这是 一样解决方案中最好的一个(由 Martin York 发布)。它只是一个简单的 位。一点点。这就是:

class Number
{
public:


/*prefix*/
Number& operator++ ()
{
/*Do stuff */
return *this;
}


/*postfix*/
Number& operator++ (int)
{
++(*this); //using the prefix operator from before
return *this;
}
};

上面的解决方案稍微简单一些，因为它在后缀方法中不使用临时对象。


提交答案