Como sobrecarregar o operador ++ de duas maneiras diferentes para o postfix a ++ e prefix ++ a?

Como sobrecarregar o operador ++ de duas maneiras diferentes para o postfix a++ e prefix ++a ?

Deve ficar assim:

 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. } }; 

A diferença está em qual assinatura você escolhe para sua (s) sobrecarga (s) do operator ++ .

Citado do artigo relevante sobre este assunto no FAQ C ++ (vá lá para mais detalhes):

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

PS: Quando eu descobri sobre isso, tudo o que vi inicialmente foi o parâmetro dummy, mas os diferentes tipos de retorno são realmente mais interessantes; eles podem explicar por que ++x é considerado mais eficiente que x++ em geral .

Você tem duas maneiras de sobrecarregar os dois operadores (prefixo / postfix) ++ para um tipo T:

Método do object:

Esta é a maneira mais fácil, usando o idioma OOP “comum”.

 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 ; } } ; 

Função de não membro do object:

Esta é outra maneira de fazer isso: Contanto que as funções estejam no mesmo namespace do object que elas estão se referindo, elas serão consideradas quando o compilador procurar por uma function para manipular ++t ; ou t++ ; código:

 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 ; } 

É importante lembrar que, a partir de um ponto de vista C ++ (incluindo um ponto de vista de compilador C ++), essas funções não membros ainda fazem parte da interface de T (desde que estejam no mesmo espaço de nomes).

Existem duas vantagens potenciais da notação de function não-membro:

  • Se você conseguir codificá-los sem torná-los amigos de T, então você aumentou o encapsulamento de T
  • você pode aplicar isso mesmo a classs ou estruturas cujo código você não possui. Esta é uma maneira não intrusiva de melhorar a interface de um object sem modificar sua declaração.

Eu sei que é tarde, mas eu tive o mesmo problema e encontrei uma solução mais simples. Não me entenda mal, esta é a mesma solução que a de cima (postada por Martin York). É um pouco mais simples. Só um pouco. Aqui está:

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

A solução acima é um pouco mais simples porque não usa um object temporário no método postfix.

Declare assim:

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

Implemente corretamente – não mexa com o que todo mundo sabe que eles fazem (incremente depois use, use e incremente).