Overloading ++ Operator

Here is my simple Code
http://phpfi.com/246184 I am trying to overload teh ++ operator
I am getting this Following error

Code:

---

root@mPC:~/desktop# g++ -o op_overload op_overload.cpp
op_overload.cpp:15: error: postfix ‘Point Point::operator++(const Point&)’ must take ‘int’ as its argument
op_overload.cpp:22: error: postfix ‘Point Point::operator++(const Point&)’ must take ‘int’ as its argument
op_overload.cpp: In member function ‘Point Point::operator++(const Point&)’:
op_overload.cpp:23: error: increment of data-member ‘Point::x’ in read-only structure
op_overload.cpp:24: error: increment of data-member ‘Point::y’ in read-only structure

---

can anyone help me please ??

Code:

---

Point Point::operator++(const Point& pt){

---

Try taking the const out.

Its all Same

I believe that it would be more common to write it as:

Code:

---

Point& Point::operator++()
{
    ++x;
    ++y;
    return *this;
}

---

You might want to read an FAQ on operator overloading.

Code:

---

p_overload.cpp:15: error: postfix ‘Point Point::operator++(const Point&)’ must take ‘int’ as its argument

---

The compiler thinks you want to create the postfix ++ operator.
that has a funny signature, you have to give it a dummy int parameter

Code:

---

Point & Point::operator++(int)

---

laserlights example creates the prefix ++ operator
Kurt

So what would be the Prototype ??

Code:

---

Point operator++();

---

Thanks Worked

Code:

---

#include <iostream>
//using simple Overloading ON Simple Objects Without New
using namespace std;
class Point{
        private:
                int x, y;
        public:
                Point(){}//default Constructor
                Point(int, int);//Constructor
                Point(const Point&);//Copy Constructor
                void desc(const char* txt){
                        cout<<"describing "<<txt<<endl;
                        cout<<"x = "<<this->x<<"\t"<<"y = "<<this->y<<endl;
                }
                Point& operator++();//The Operator Overloader Prototype
                ~Point(){cout<<"destructing"<<endl;}
};
Point::Point(int a, int b){
        this->x = a;
        this->y = b;
}
//operator Overloader function declearation
Point& Point::operator++(){
        ++x;
        ++y;
        return *this;
}
int main(){
        Point pt(4, 10);
        pt.desc("pt");
        return 0;
}

---

Quote:

---

So what would be the Prototype ??

---

If you read the material at the link I posted, you would see that the suggested prototype for the prefix operator++ is:

Code:

---

Point& operator++();

---

And the suggested prototypes (pick one) for the postfix operator++ are:

Code:

---

Point operator++(int);
// or
void operator++(int);

---

Note that in all cases they are member functions.

Quote:

---

Originally Posted by noobcpp

So what would be the Prototype ??

Code:

---

Point operator++();

---

---

prefix

Code:

---

Point & operator++();

---

postfix

Code:

---

Point & operator++(int);

---

and it should return a reference, it doesnt make much sense to return an object from that operators.
Kurt

Quote:

---

and it should return a reference, it doesnt make much sense to return an object from that operators.

---

Not for the postfix operator++ though. Typically one would create a temporary of the original value, increment the original value, and then return the temporary. If one returned a reference, then it would a reference to an object that is now out of scope.

Come to think of it, the result of a postfix operator++ for primitive types should be an rvalue, so perhaps it would be even better to write:

Code:

---

const Point operator++(int);

---

Quote:

---

Originally Posted by laserlight

Not for the postfix operator++ though. Typically one would create a temporary of the original value, increment the original value, and then return the temporary. If one returned a reference, then it would a reference to an object that is now out of scope.

---

True, I should think a little bit more before replying.
Kurt

"Do as the ints do."
Scott Meyers recommends this strategy for ++:

Code:

---

class Foo
{
public:
  Foo& operator ++();
  const Foo operator ++(int);
};

Foo &Foo::operator ++()
{
  // class-specific increment logic
  return *this;
}

const Foo Foo::operator ++(int)
{
  Foo t(*this);
  ++*this;
  return t;
}

---

See Item 6 of More Effective C++ for the full reasoning.

Why int is required as an argument for Postfix ??

They just needed some way to distinguish between prefix and postfix, so since doing that won't harm anything else they decided it would be the best option.

What we are doing is

Code:

---

Point& Point::operator++(){
        ++x;
        ++y;
        return *this;
}

---

here & of *this means Reference of Pointer Means teh Object So It should also work

Code:

---

Point Point::operator++(){
        ++x;
        ++y;
        return this;
}

---

But Its not working. Why??
ya I've also changed teh Prototype to This

Code:

---

Point operator++();

---

But Still not working. Why ??

this is a pointer, it has the type Point*. If you wanted to return a pointer (Point*) you could return this (but you shouldn't here). If you want to return a reference (Point&), you must dereference the pointer with *this like you did. If you want to return an object (Point), you must also dereference the pointer with *this, and then a copy is automatically made and returned.

No I must use Point& else Its Firing wired Linker errors.

This is what I've done For Postfix
Why its firing Errors ??

Code:

---

Point& operator++(int);

---

Code:

---

Point& Point::operator++(int m=0){//What Argument would I use here what int ??
        x++;
        y++;
        return *this;
}

---

And I am using it in this way

Code:

---

Point y = pt++;

---

If you are getting errors, post the errors exactly as they appear.

In your post (#15) above, your code was different between the two versions. In the Point& version you returned *this. In the Point version you returned this. Both should return *this.

If you are getting linker errors, that means you are doing something else wrong, but I can't tell what without looking at the code and the errors.

Quote:

---

No I must use Point& else Its Firing wired Linker errors.

---

That is probably due to an inconsistency between your class declaration and its implementation.

Quote:

---

Why its firing Errors ??

---

Look at CornedBee's example. You could implement your post-increment operator++ as:

Code:

---

const Point Point::operator++(int)
{
    Point temp(*this);
    ++*this;
    return temp;
}

---

If it does not work, then either your copy constructor or pre-increment operator++ is incorrect.

Quote:

---

What Argument would I use here what int ??

---

Anything if you are calling the operator by its name as a function, nothing if you are using it as an operator. For example:

Code:

---

// Assume pt is a Point object.
pt++; // Post-increment operator used as an operator.
pt.operator++(123); // Post-increment operator called by name as a function.
// Note that 123 is just an example, you can use any other int values too.

---

Note also that since it is post-increment (or postfix notation, if you prefer), your example usage will result in y being a copy of pt, and pt being post-incremented. As such, make sure that you are checking for the right thing.

OK now this is my Compleate Code http://phpfi.com/246304

Code:

---

const Point operator++(int);

---

Code:

---

const Point Point::operator++(int){
        Point tmp(*this);
        ++*this;
        return tmp;
}

---

And I am getting this error

Code:

---

/tmp/ccF6kXes.o: In function `Point::operator++(int)':
op_overload.cpp:(.text+0xd9): undefined reference to `Point::Point(Point const&)'
collect2: ld returned 1 exit status

---

You did not implement the copy constructor for Point. As a quick fix, you can just remove it and let the compiler generate it for you.

Oh! I see
This is teh declearation of My Copy Constructor

Code:

---

Point(const Point&);//Copy Constructor

---

Would I Implement it in this way ??

Code:

---

Point::Point(const Point& pt){
this = *pt;
}

---

Just this ??Or I need to Specifi Any Return Type ??

The best way would be to remove it because the compiler generated one works correctly. If you implement it yourself, then you have to make sure it stays updated and correct, which can be a source of hard to find bugs.

If you were to implement it yourself, you would initialize each member variable with the member variable of the other object.

>> Or I need to Specifi Any Return Type ??
Like all other constructors, there is no return type.

I also need to learn Copy constructor
Can you give me an example ??

OK I've made this
default constructor

Code:

---

Point::Point(const Point& pt){
        *this = pt;
}

---

And here is My Compleate code now http://phpfi.com/246309
Now When I run this Programm Post fix ++ works same as Prefix ++ Operatotr there is No Difference
here is teh Output of the Program

Code:

---

describing pt  x = 4  y = 10
describing pt after Pre Incrementing    x = 5  y = 11
describing y    x = 6  y = 12
describing pt after Post Increment      x = 6  y = 12
destructing
destructing

---

Quote:

---

Originally Posted by noobcpp

Now When I run this Programm Post fix ++ works same as Prefix ++ Operatotr there is No Difference

---

Shure there is a difference. You're just testing it the wrong way
try like this

Code:

---

int main(){
        Point pt(4, 10);
        pt.desc("pt initialized          ");
        Point px = ++pt;
        px.desc("px returned from pre inc");
        pt.desc("pt after Pre Incrementing");
        Point py = pt++;
        py.desc("py returned from post inc");
        pt.desc("pt after Post Increment");

}

---

Kurt

Wow Its Working Thanks.

That's not a really sensible way to implement the copy constructor. Here's a good one:

Code:

---

Point::Point(const Point &o) : x(o.x), y(o.y) {}

---

But that's still not smart. Daved is right: remove it, because the compiler-generated one does the right thing. And because you're violating the rule of three. (Just a guideline, but an important one.)

Like with pointers, you need to learn not only how, but also when and why. You implement copy constructors when you need them. And, by the rule of three, you also implement the copy assignment operator and the destructor, because you will need them too in such a situation.

If you want an example where you need these, implement a resizing array similar to std::vector.