overloading of ","

[josh]

Hi, I coded the following but It does not return what I expect, why?

#include <iostream>

using namespace std;

class Other
{
public:
int i;

Other(int x=1)
{
i = x;
}

Other *operator-() { return this;}

Other &operator+ (Other t)
{
i += t.i;

return *this;
}

Other &operator,(Othe r oth)
{
i = oth.i;

return *this;
}

};

int main()
{
Other o0, o1, o2(4), o3(5);

o0->i = 100;

cout << o0.i << "\n" << o0->i << "\n";

// HERE it returns 5 AND not 6 WHY ??????????????? ????
Other ox = (o1 + o1, o3 = o2 + o1);
// ------------------
cout << ox.i << endl;

return 0;
}

[Michael DOUBEZ]

josh a écrit :

Hi, I coded the following but It does not return what I expect, why?

#include <iostream>

using namespace std;

class Other
{
public:
int i;

Other(int x=1)
{
i = x;
}

Other *operator-() { return this;}

Other &operator+ (Other t)
{
i += t.i;

return *this;
}

Other &operator,(Othe r oth)
{
i = oth.i;

return *this;
}

};

int main()
{
Other o0, o1, o2(4), o3(5);

o0->i = 100;

cout << o0.i << "\n" << o0->i << "\n";

// HERE it returns 5 AND not 6 WHY ??????????????? ????
Other ox = (o1 + o1, o3 = o2 + o1);

Because you have 5.
The expression evaluates:
Other ox = ( (o1 + o1) , (o3 = o2 + o1) );

Or with names
Other ox = o1.operator+(o1 ).operator,(o3. operator=(o2.op erator+(o1)));

Since o3 is 5, then o1 is also 5 and ox is 5.

The reason is overloaded operator, doesn't have the same precedence as
POD operator,. Is is very confusing.

// ------------------
cout << ox.i << endl;

return 0;
}

Michael

[bnonaj]

josh wrote:

Hi, I coded the following but It does not return what I expect, why?

#include <iostream>

using namespace std;

class Other
{
public:
int i;

Other(int x=1)
{
i = x;
}

Other *operator-() { return this;}

Other &operator+ (Other t)
{
i += t.i;

return *this;
}

Other &operator,(Othe r oth)
{
i = oth.i;

return *this;
}

};

int main()
{
Other o0, o1, o2(4), o3(5);

o0->i = 100;

cout << o0.i << "\n" << o0->i << "\n";

// HERE it returns 5 AND not 6 WHY ??????????????? ????
Other ox = (o1 + o1, o3 = o2 + o1);
// ------------------
cout << ox.i << endl;

return 0;
}

I suspect that this could be undefined behaviour as the + operators have
equal precedence and the order they are evaluated depends on the
compiler. evaluation order is '+', '=', ',' based on precedence and
hence the code is not safe.

JB

[Adrian Hawryluk]

Michael DOUBEZ wrote:

josh a écrit :

>Hi, I coded the following but It does not return what I expect, why?

#include <iostream>

using namespace std;

class Other
{
public:
int i;

Other(int x=1)
{
i = x;
}

Other *operator-() { return this;}

Other &operator+ (Other t)
{
i += t.i;

return *this;
}

Other &operator,(Othe r oth)
{
i = oth.i;

return *this;
}

};

int main()
{
Other o0, o1, o2(4), o3(5);

o0->i = 100;

cout << o0.i << "\n" << o0->i << "\n";

// HERE it returns 5 AND not 6 WHY ??????????????? ????
Other ox = (o1 + o1, o3 = o2 + o1);

Because you have 5.
The expression evaluates:
Other ox = ( (o1 + o1) , (o3 = o2 + o1) );

Or with names
Other ox = o1.operator+(o1 ).operator,(o3. operator=(o2.op erator+(o1)));

Since o3 is 5, then o1 is also 5 and ox is 5.

The reason is overloaded operator, doesn't have the same precedence as
POD operator,. Is is very confusing.

That is not the only thing confusing! Your use of operator,() is the so
obfuscated! Why on Earth would you want to do something like that?
What possible reason could you have?

On a side note, why isn't operator,() the same precedence as the regular
',' operator? I thought that all user defined operators had the same
precedence as the builtins.
Adrian
--
=============== =============== =============== =============
Adrian Hawryluk BSc. Computer Science
----------------------------------------------------------
Specialising in: OOD Methodologies in UML
OOP Methodologies in C, C++ and more
RT Embedded Programming
__--------------------------------------------------__
----- [blog: http://adrians-musings.blogspot.com/] -----
'--------------------------------------------------------'
My newsgroup writings are licensed under the Creative
Commons Attribution-Noncommercial-Share Alike 3.0 License
http://creativecommons.org/licenses/by-nc-sa/3.0/
=============== =============== =============== =============

[red floyd]

josh wrote:

Hi, I coded the following but It does not return what I expect, why?

#include <iostream>

using namespace std;

class Other
{
public:
int i;

Other(int x=1)
{
i = x;
}

Other *operator-() { return this;}

Other &operator+ (Other t)
{
i += t.i;

return *this;
}

Other &operator,(Othe r oth)
{
i = oth.i;

return *this;
}

};

int main()
{
Other o0, o1, o2(4), o3(5);

o0->i = 100;

cout << o0.i << "\n" << o0->i << "\n";

// HERE it returns 5 AND not 6 WHY ??????????????? ????
Other ox = (o1 + o1, o3 = o2 + o1);
// ------------------
cout << ox.i << endl;

return 0;
}

You are modifying and evaluating the same object (o1) between sequence
points. Your program's behavior is therefore undefined.

Please see the FAQ on ++i,i++, and following (39.15 and 39.16)

http://www.parashift.com/c++-faq-lit...html#faq-39.15

[Michael DOUBEZ]

Adrian Hawryluk a écrit :

Michael DOUBEZ wrote:

>josh a écrit :

>>Hi, I coded the following but It does not return what I expect, why?
[snip]
// HERE it returns 5 AND not 6 WHY ??????????????? ????
Other ox = (o1 + o1, o3 = o2 + o1);

Because you have 5.
The expression evaluates:
Other ox = ( (o1 + o1) , (o3 = o2 + o1) );

Or with names
Other ox = o1.operator+(o1 ).operator,(o3. operator=(o2.op erator+(o1)));

Since o3 is 5, then o1 is also 5 and ox is 5.

The reason is overloaded operator, doesn't have the same precedence as
POD operator,. Is is very confusing.

That is not the only thing confusing! Your use of operator,() is the so
obfuscated! Why on Earth would you want to do something like that? What
possible reason could you have?

Mostly for learning what not to do I guess.

blitz++ has matrix initalisation with comma overloading.

>
On a side note, why isn't operator,() the same precedence as the regular
',' operator? I thought that all user defined operators had the same
precedence as the builtins.

Concerning the precedence, it is sloppy writing from my part: it doesn't
have the same ordering properties but the precedence is kept (the lowest
if I remember correctly). The point is: in POD, the comma operator is a
sequence point and evaluates from left to right, the lhs of comma being
discarded while when overloaded, it is just another function (no
sequence point).
(++i),(i*=2) is defined behavior with POD while with Operator,(): it is UB.

This was the case up in the OP.

Michael

[red floyd]

red floyd wrote:

josh wrote:

>Hi, I coded the following but It does not return what I expect, why?

#include <iostream>

using namespace std;

class Other
{
public:
int i;

Other(int x=1)
{
i = x;
}

Other *operator-() { return this;}

Other &operator+ (Other t)
{
i += t.i;

return *this;
}

Other &operator,(Othe r oth)
{
i = oth.i;

return *this;
}

};

int main()
{
Other o0, o1, o2(4), o3(5);

o0->i = 100;

cout << o0.i << "\n" << o0->i << "\n";

// HERE it returns 5 AND not 6 WHY ??????????????? ????
Other ox = (o1 + o1, o3 = o2 + o1);
// ------------------
cout << ox.i << endl;

return 0;
}

You are modifying and evaluating the same object (o1) between sequence
points. Your program's behavior is therefore undefined.

Please see the FAQ on ++i,i++, and following (39.15 and 39.16)

http://www.parashift.com/c++-faq-lit...html#faq-39.15

Further explanation:

Because operator+ modifies its object **AND** you've overloaded
operator, it's equivalent to calling operator,(x++,x ) -- undefined behavior

[Rolf Magnus]

Adrian Hawryluk wrote:

>The reason is overloaded operator, doesn't have the same precedence as
POD operator,. Is is very confusing.

That is not the only thing confusing! Your use of operator,() is the so
obfuscated! Why on Earth would you want to do something like that?
What possible reason could you have?

Actually, all the overloaded operators in the OP's code are doing confusing
things.

[Old Wolf]

On Mar 13, 10:07 am, red floyd <no.s...@here.d udewrote:

// HERE it returns 5 AND not 6 WHY ??????????????? ????
Other ox = (o1 + o1, o3 = o2 + o1);

You are modifying and evaluating the same object (o1) between sequence
points. Your program's behavior is therefore undefined.

Not true, there is a sequence point before and after every
function call -- in particular, operator+ and operator,

Further explanation:

Because operator+ modifies its object **AND** you've overloaded
operator, it's equivalent to calling operator,(x++,x ) -- undefined behavior

Not equivalent at all. It's equivalent to h(x.f(x), g(x))
which is fine (even if f modifies x).

To answer OP's question: the behaviour is unspecified because
overloaded comma operator does not retain the ordering of the
builtin comma operator. What's happening in this case is that
(o3 = o2 + o1) is being executed, and then (o1 + o1), and then
the overloaded comma operator is called with both of those results.
A different compiler might evaluate (o1 + o1) first, resulting in
o5 == 6.

[Adrian Hawryluk]

Old Wolf wrote:

On Mar 13, 10:07 am, red floyd <no.s...@here.d udewrote:

>>> // HERE it returns 5 AND not 6 WHY ??????????????? ????
Other ox = (o1 + o1, o3 = o2 + o1);
You are modifying and evaluating the same object (o1) between sequence
points. Your program's behavior is therefore undefined.

Not true, there is a sequence point before and after every
function call -- in particular, operator+ and operator,

>Further explanation:

Because operator+ modifies its object **AND** you've overloaded
operator, it's equivalent to calling operator,(x++,x ) -- undefined behavior

Not equivalent at all. It's equivalent to h(x.f(x), g(x))
which is fine (even if f modifies x).

To answer OP's question: the behaviour is unspecified because
overloaded comma operator does not retain the ordering of the
builtin comma operator. What's happening in this case is that
(o3 = o2 + o1) is being executed, and then (o1 + o1), and then
the overloaded comma operator is called with both of those results.
A different compiler might evaluate (o1 + o1) first, resulting in
o5 == 6.

So does that mean that the comma operator's evaluation order of left to
right is not implemented correctly on the compiler? I thought that it
was defined as left to right.
Adrian

--
=============== =============== =============== =============
Adrian Hawryluk BSc. Computer Science
----------------------------------------------------------
Specialising in: OOD Methodologies in UML
OOP Methodologies in C, C++ and more
RT Embedded Programming
__--------------------------------------------------__
----- [blog: http://adrians-musings.blogspot.com/] -----
'--------------------------------------------------------'
My newsgroup writings are licensed under the Creative
Commons Attribution-Noncommercial-Share Alike 3.0 License
http://creativecommons.org/licenses/by-nc-sa/3.0/
=============== =============== =============== =============