C ++: перегрузка ++ для приращения до и после

c++ operator-overloading

52177 просмотра

5 ответа

Можем ли мы перегрузить operator++для предварительного увеличения и последующего увеличения? т.е. зовет SampleObject++и ++SampleObjectрезультаты правильно.

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

Мы не можем перегрузить функцию, основанную только на типе возвращаемого значения, и даже если мы примем это как разрешенное, это не решит проблему из-за неоднозначности в разрешении вызова.

Поскольку обеспечивается перегрузка операторов для того, чтобы встроенные типы вели себя как пользовательские типы, почему мы не можем одновременно использовать до и после приращения для наших собственных типов.

Автор: null Источник Размещён: 12.11.2019 09:34

Ответы (5)


76 плюса

Постфиксная версия оператора приращения принимает фиктивный intпараметр для устранения неоднозначности:

// 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
}
Автор: juanchopanza Размещён: 06.03.2013 10:02

20 плюса

Стандартный шаблон для предварительного увеличения и последующего увеличения для типа 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;
}

(Вы также можете вызвать обычную функцию для выполнения приращения, или, если это простая однострочная строка вроде ++ для члена, просто сделайте это в обоих)

Автор: CashCow Размещён: 06.03.2013 12:29

12 плюса

почему мы не можем одновременно использовать до и после увеличения для наших собственных типов.

Ты можешь:

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
  }
Автор: Andy Prowl Размещён: 06.03.2013 10:06

7 плюса

[N4687]

16.5.7

Пользовательская функция под названием operator ++ реализует оператор префикса и постфикса ++. Если эта функция является нестатической функцией-членом без параметров или не-функцией с одним параметром, она определяет оператор приращения префикса ++ для объектов этого типа. Если функция является нестатической функцией-членом с одним параметром (который должен иметь тип int) или функцией, не являющейся членом, с двумя параметрами (второй из которых должен иметь тип int), она определяет оператор приращения постфикса ++ для объектов этого типа. Когда приращение постфикса вызывается в результате использования оператора ++, аргумент int будет иметь нулевое значение

Пример:

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++;
}
Автор: 陳 力 Размещён: 25.11.2017 07:08

0 плюса

#include<iostream>
using namespace std;

class increment{
int a;
public:
increment(int x)
{ a=x; }

void operator ++(){
cout<<"pre-increment:";
cout<<++a;}

void operator ++(int){                  /*post version of increment operator takes  int as a dummy parameter*/

 cout<<endl<<"post-increment:";
 cout<<a++;}
};


int main(){
increment o1(4);   
increment o2(4);
++o1;       //pre-increment
o2++;       //post-increment

}

ВЫХОД:
прединкремент: 5
постинкремент: 4

Автор: Aayush Kumar Размещён: 07.03.2019 09:19
Вопросы из категории :
32x32