overload - operator[] c++

C++: sobrecarga++ para el incremento previo y posterior

Question

¿Podemos sobrecargar operator++ para preincremento y post incremento? es decir, llamando a los resultados de SampleObject++ y ++SampleObject correctamente.

class CSample {
 public:
   int m_iValue;     // just to directly fetch inside main()
   CSample() : m_iValue(0) {}
   CSample(int val) : m_iValue(val) {}
   // Overloading ++ for Pre-Increment
   int /*CSample& */ operator++() { // can also adopt to return CSample&
      ++(*this).m_iValue;
      return m_iValue; /*(*this); */
   }

  // Overloading ++ for Post-Increment
 /* int operator++() {
        CSample temp = *this;
        ++(*this).m_iValue;
        return temp.m_iValue; /* temp; */
    } */
};

No podemos sobrecargar una función basada únicamente en el tipo de devolución, y aunque lo tomemos como está permitido, no resuelve el problema debido a la ambigüedad en la resolución de llamadas.

Como la sobrecarga del operador se proporciona para que los tipos incorporados se comporten como tipos definidos por el usuario, no podemos aprovechar el incremento pre y post para nuestros propios tipos al mismo tiempo.

Answer 1

por qué no podemos aprovechar el incremento pre y post para nuestros propios tipos al mismo tiempo.

Usted puede:

class CSample {
public:

     int m_iValue;
     CSample() : m_iValue(0) {}
     CSample(int val) : m_iValue(val) {}

     // Overloading ++ for Pre-Increment
     int /*CSample& */ operator++() {
        ++m_iValue;
        return m_iValue;
     }

    // Overloading ++ for Post-Increment
    int operator++(int) {
          int value = m_iValue;
          ++m_iValue;
          return value;
      }
  };

  #include <iostream>

  int main()
  {
      CSample s;
      int i = ++s;
      std::cout << i << std::endl; // Prints 1
      int j = s++;
      std::cout << j << std::endl; // Prints 1
  }

Answer 2

El patrón estándar para el preincremento y el incremento posterior para el tipo T

T& T::operator++() // pre-increment, return *this by reference
{
 // perform operation


 return *this;
}

T T::operator++(int) // post-increment, return unmodified copy by value
{
     T copy(*this);
     ++(*this); // or operator++();
     return copy;
}

(También puede llamar a una función común para realizar el incremento, o si es un simple delineador como ++ en un miembro, simplemente hágalo en ambos)

Answer 3

La versión de postfix del operador de incremento toma un parámetro int ficticio para desambiguar:

// prefix
CSample& operator++()
{
  // implement increment logic on this instance, return reference to it.
  return *this;
}

// postfix
CSample operator++(int)
{
  CSample tmp(*this);
  operator++(); // prefix-increment this instance
  return tmp;   // return value before increment
}

Answer 4

[N4687]

16.5.7

La función definida por el usuario llamada operator ++ implementa el prefijo y el operador postfix ++. Si esta función es una función miembro no estática sin parámetros, o una función no miembro con un parámetro, define el operador de incremento de prefijo ++ para objetos de ese tipo. Si la función es una función miembro no estática con un parámetro (que debe ser de tipo int) o una función no miembro con dos parámetros (el segundo de los cuales será del tipo int), define el operador de incremento postfix ++ para objetos de ese tipo. Cuando se llama al incremento postfix como resultado de usar el operador ++, el argumento int tendrá valor cero [Ejemplo:

struct X {
X&   operator++(); // prefix ++a
X    operator++(int); // postfix a++
};
struct 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++;
}