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

[red floyd]

Adrian Hawryluk wrote:

Old Wolf wrote:

>>
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.

It is, if you don't overload it. If you overload it, then the
evaluation order is undefined, as I understand it. Similarly, if you
overload && or ||, the "short-circuit" behavior does not occur.

[josh]

On 12 Mar, 13:16, Michael DOUBEZ <michael.dou... @free.frwrote:

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

so the compiler is doing:
o1.operator+(01 ).operator,(03 = 02.operator+(01 ))
and evaluating it to 5
but when we define overloaded operators the rules "should" be that
they have the same precedence and the same associativity and the same
arity of
the PDO and so really I don't understand why here the rules seems to
be "could"....
Here in the code it seems that it doesn't save the first evaluating
operation on o1...
may be only for the comma operators is there an exception rule????

[josh]

On 12 Mar, 11:17, "josh" <xdevel2...@yah oo.comwrote:

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;

}

the precedence, associativity and arity of overload operator, as rule,
"should" be the same for the PDO but here for the comma it doesn't
seem so...
if I add to my class an overload of * and than I make i.e.
o1 + o2 * 03 the evaluation order is correct and in fact will be FIRST
o2 * o3 and SECOND
o1 + (the mul result).
So I think that the compiler when meet that expression will do:
o1.operator+(o2 .operator*(o3))
but it should do the same with:
(o1.operator+(o 1)).operator,(o 3 = 02.operator+(o1 ))
so it should evaluate from left to right as the same PDO rule...
so what's wrong?

[josh]

On 12 Mar, 13:16, Michael DOUBEZ <michael.dou... @free.frwrote:

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

the precedence, associativity and arity of overload operator, as rule,
"should" be the same for the PDO but here for the comma it doesn't
seem so...
if I add to my class an overload of * and than I make i.e.
o1 + o2 * 03 the evaluation order is correct and in fact will be FIRST
o2 * o3 and SECOND
o1 + (the mul result).
So I think that the compiler when meet that expression will do:
o1.operator+(o2 .operator*(o3))
but it should do the same with:
(o1.operator+(o 1)).operator,(o 3 = 02.operator+(o1 ))
so it should evaluate from left to right as the same PDO rule...
so what's wrong?

[Kai-Uwe Bux]

josh wrote:

On 12 Mar, 11:17, "josh" <xdevel2...@yah oo.comwrote:

>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;

}

the precedence, associativity and arity of overload operator, as rule,
"should" be the same for the PDO but here for the comma it doesn't
seem so...

Precedence and arity do match. I have no idea, what you mean by
associativity. Anyhow, what an overloaded comma operator lacks is the
sequence point that the built-in comma operator gives you.

if I add to my class an overload of * and than I make i.e.
o1 + o2 * 03 the evaluation order is correct and in fact will be FIRST
o2 * o3 and SECOND

This is false: the evaluation order is unspecified. This is unrelated to
overloading. It is unspecified for built-in types, as well. See clause
[5/4].

o1 + (the mul result).
So I think that the compiler when meet that expression will do:
o1.operator+(o2 .operator*(o3))
but it should do the same with:
(o1.operator+(o 1)).operator,(o 3 = 02.operator+(o1 ))
so it should evaluate from left to right as the same PDO rule...
so what's wrong?

Your code has undefined behavior since it modifies the same object several
times without sequence points. The overloaded comma operator does not give
you the sequence point that forces left-to right evaluation.
Best

Kai-Uwe Bux

[josh]

On 13 Mar, 04:28, red floyd <no.s...@here.d udewrote:

Adrian Hawryluk wrote:

Old Wolf wrote:

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.

It is, if you don't overload it. If you overload it, then the
evaluation order is undefined, as I understand it. Similarly, if you
overload && or ||, the "short-circuit" behavior does not occur.

have you read it on the 14482 iso spec.?

[liam_herron]

BTW - What is POD?

[Rolf Magnus]

liam_herron wrote:

BTW - What is POD?

Plain Old Data.

[red floyd]

josh wrote:

On 13 Mar, 04:28, red floyd <no.s...@here.d udewrote:

>Adrian Hawryluk wrote:

>>Old Wolf wrote:
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.

It is, if you don't overload it. If you overload it, then the
evaluation order is undefined, as I understand it. Similarly, if you
overload && or ||, the "short-circuit" behavior does not occur.

have you read it on the 14482 iso spec.?

I believe so. I'm at home right now, and my copy of 14882 is at work,
so it'll have to wait, unless other posters wish to comment on that.

[josh]

Precedence and arity do match. I have no idea, what you mean by

associativity.

when I say about associativity I mean that if we have in an expression
more operators
of equal precedence i.e. * / % than it will be evaluated from left-to-
rigth
int a = 4 / 2 * 8 -first 4/2 and SECOND 2 * 8

if I add to my class an overload of * and than I make i.e.
o1 + o2 * 03 the evaluation order is correct and in fact will be FIRST
o2 * o3 and SECOND

This is false: the evaluation order is unspecified. This is unrelated to
overloading. It is unspecified for built-in types, as well. See clause
[5/4].

This is not false! the evaluation order is the same of PDO. It is
unspecified
only if I have in an expression the same operators i.e.
int a = 4 + 6 + b + f -here is not sure that the compiler goes from
left to right
it is guaranted only for && !! , ?: operators

Best