Thread: Question regarding pointers

I think you misunderstand what a reference is.
T* -> pointer
&obj -> Address of obj
T& -> reference

int a;
int* b = &a; // &a = Address of a. int* b = b is a pointer to int
int& c = a; // int& c = c is a reference to int.
a& // Not valid syntax

Try doing

stellarobjekt obj;
++(++obj)

an see what it prints.

Ah now I see, without the & it just returns twice a copy of stellarobject incremented by one, while the other one with the & updates itself twice and gets the 2.

There's just one thing that still bothers me, the id++ basically messes around with the object variable id in both cases, why is it that in the other case it "forgets" the first incrementation?
I mean, it's still acting inside the class.

Code:

stellarobjekt&  operator++(){ //Durch das & braucht man keine Temporärvariable,  sondern weist die Änderung direkt dem betreffenden Objekt zu.
         id++;                    //stellaerobjekt returns a reference to * this  itself, while stellarobject without & would just return a copy
        return(*this);
    }

Why isn't it behaving like this one?

Code:

void increment(){
id++;
}

Let's break that statement down to two lines.

This

stellarobjekt obj;
++(++obj)

can be seen as

Code:

stellarobjekt obj;
{
	stellarobjekt tmp = ++obj;
	++tmp;
}

So what does this do?
stellarobjekt tmp = ++obj;
This basically increments the original obj and takes its return value and stores it in a temporary. That temporary is then incremented. But because tmp is a copy of obj, obj is not affected.

Change the class to return a reference and the code becomes

Code:

stellarobjekt obj;
{
	stellarobjekt& tmp = ++obj;
	++tmp;
}

Now tmp is a reference to obj, so obj is incremented instead of a temporary.

No, &stellarobject and stellarobject & are not the same.

Don't get hung up on the fact they both use an ampersand. The meanings are completely different. It is context that determines the meaning.

Code:

stellarobjekt &foo(stellarobjekt &p)
{
     return p;
}

declares a function named foo() that returns a reference to a stellarobjekt, accepts an argument that is a reference to a stellarobjekt (named p). The return statement means that reference returned by the function is the one passed by the caller (p).

It gets worse, as & is also the address-of operator

Code:

stellarobjekt *foo(stellarobjekt &p)
{
     return &p;
}

In this case, foo() returns a pointer to a stellarobjekt. The argument is a reference to a stellarobjekt. The return value is the address of the object passed (p).

It is also possible to do

Code:

stellarobjekt foo(stellarobjekt &p)
{
     return p;
}

In this case, foo() returns the value of a stellarobjekt (not a reference to a pointer). p, again, is a reference. The "return p;", however, causes the caller to receive a copy of p.

Originally Posted by Chris L. Tailor

So to put it all in a nutshell:

In the average case id++ is equal to id = id+1

What average case? What do you mean by "equal to"?

If by "equal to" you mean "has same effect as", the answer is "sometimes". Depending on the context where it is done, the behaviours can be different.

The expressions "j = id++" and "j = id = id + 1" give different results for j, but both increment id.

Originally Posted by Chris L. Tailor

Inside the operation overload function a++ means something totally different,
<snip>
correct?

Not really, no.

Given the expression "a++", what typically happens is something like (in pseudocode).

Code:

if (a is a basic type that can be incremented) then 
    a is incremented and the result of the expression is the previous value of a.
else if (only one declared operator++() function makes sense in that context)
    that function is called, so its results and side-effect are provided
else if (more than one operator++() function can potentially make sense in that context)
    compiler complains about ambiguity and rejects the code
else
    the compiler complains about an invalid expression and rejects the code
endif

Conventionally, it is a good idea to make an operator++() function do something that can be described as "incrementing its operand" (which is *this if the operator++() is a member function, and an argument if not a member function). However, it is quite possible to write an operator++() that decrements. Doing such things is generally considered bad practice.

The general good practice with all operators is "logically behaves like int". So your implementation of an operator++() should notionally increment its operand and return (depending on whether you are incrementing pre or post increment) return either a reference to the operand or its previous value. So typical implementations of operator++() will look like

Code:

Something &Something::operator++()     // preincrement  (also known as prefix form)
{
     // do whatever is necessary to increment *this
     return *this;
}

Something Something::operator++(int)     // post-increment (or postfix form)
{
     Something temp(*this);
     // do whatever is necessary to increment *this
     return temp;
}

Similarly for non-member forms.

Well, I understand the implementation, I just wonder why this

Code:

void increment(){ id++; }

and, for instance, this

Code:

stellarobject operator++(){
stellarobject pointer(*this);
id++ 
return(*this);
}

which both use id++, behave different.It seems that id++ has a different meaning in the latter.

I thought, what Elysia was trying to tell me, went kinda like this:

Code:

stellarobjekt obj;
{
stellarobjekt& tmp = ++obj;
++tmp;
}

In the latter function id++ only increments a copy of *this, which it then returns, it isn't influencing the attributes of the object directly like in my example with void increment() .

Originally Posted by Chris L. Tailor

Well, I understand the implementation,

Well, that's a large part of your problem. You think you understand, but the questions you're asking demonstrate quite clearly that you don't.

Because you think you understand, you are misinterpreting the advise you are receiving.

Originally Posted by Chris L. Tailor

I just wonder why this

Code:

void increment(){ id++; }

and, for instance, this

Code:

stellarobject operator++(){
stellarobject pointer(*this);
id++ 
return(*this);
}

which both use id++, behave different.It seems that id++ has a different meaning in the latter.

Why? If id is the same thing (say, an int member of stellarobject) then the statement "id++" has the same effect in both cases.

The difference is that you are not understanding the significance of the lines above and below it

Code:

stellarobject operator++()
{
    stellarobject pointer(*this);
    id++ 
    return(*this);
}

Firstly, you have misnamed "pointer". It is actually a second object that is a copy of *this. It is not a pointer to *this, or to anything else.

All the function is doing is creating a copy of *this, incrementing this->id, and then returning a second copy of *this. The first copy created (which you have misnamed as pointer) is being destroyed as the function returns. Since this->id has been incremented, the copy returned to the caller has the same value of id that (as far as the caller is concerned) is incremented (assuming the copy constructor of your class is not broken through your misunderstanding as well).

Originally Posted by Chris L. Tailor

I thought, what Elysia was trying to tell me, went kinda like this:

Code:

stellarobjekt obj;
{
stellarobjekt& tmp = ++obj;
++tmp;
}

In the latter function id++ only increments a copy of *this, which it then returns, it isn't influencing the attributes of the object directly like in my example with void increment() .

Well .... you've clearly misunderstood what Elysia told you.

You need to read this whole thread again. Except you need to admit that YOU DO NOT UNDERSTAND before you read it again, otherwise you will keep misinterpreting the advice given.

Originally Posted by Chris L. Tailor

The function, which returns a stellarobject& is only really needed when you want that ++(++obj) returns a 2, that's the case which Elysia described, right?

I provided a good example of why you should do it. It does not represent the only case where it is necessary. Depending on your code and implementation, you may find that your code generates bugs if you don't do it this way, because this is what we expect.

I think, I just misinterpreted what Elysia meant with ++(++obj), I thought ++(++obj) is the same as ++obj; ++obj; , but I was wrong.

It's not.
Again, you can see the operators as function calls:

(obj.operator++()).operator++();

What you must understand here is that the result return from the first expression "(obj.operator++())" is used when the next function call is done.
Therefore,
++(++obj)
does not mean
++obj
++obj
But rather,
stellarobjekt temp = ++obj;
++temp;

You can also see it like

f(g());

vs

g();
f();

Clearly they are not the same. The result of g() is fed into f().