C++Talk.NET

Brian Clarkson · Guest

Hello.

I came across this problem while porting some code from vc++ to gcc.
From my shaky understanding of the ANSI C++ standard, temporaries are
guaranteed to stick around at least until right before execution of the
next line (or up until the semicolon). However, it seems that a
non-const reference to a temporary is forbidden. Isn' t this way too
strict?

I have distilled the issue to the following example:

****begin test.cpp****

#include <iostream>
using namespace std;

class vector {
public:
vector(int x_, int y_) : x(x_), y(y_) {}
vector(const vector& xx) : x(xx.x), y(xx.y) {}
vector& operator=(const vector& xx) { x = xx.x; y = xx.y; return
*this; }

friend vector operator+(const vector& a, const vector& b);
public:
int x, y;
};

vector operator+(const vector& a, const vector& b) {
// vector tmp(a.x + b.x, a.y + b.y);
// return tmp;
return vector(a.x + b.x, a.y + b.y);
}

void f(vector& v)
{
cout << "vector = (" << v.x << ", " << v.y << ")" << endl;
}

int main()
{
vector a(1, 2);
vector b(2, 3);

f(a+b); // this line generates an error

return 0;
}

****end test.cpp****

Which when compiled gives the following output:

g++ test.cpp

test.cpp: In function `int main()':
test.cpp:32: error: could not convert `operator+(const vector&, const
vector&)((&b))' to `vector&'
test.cpp:23: error: in passing argument 1 of `void f(vector&)'

If f() is defined as f(const vector&) then this example compiles, but
it seems to me that operating on a reference to the temporary that is
generated from (a+b) should be safe since we are finished with it
before the semicolon.

Is there a better way to do this? (i.e. no explicit temporaries and no
unnecessary copies)

Thanks in advance.

Brian

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ]

jacobsson@gmail.com · Guest

Temporary objects are lvalues in VC7, i.e., they can be passed as
non-const references. In GCC, temporary objects are rvalues and can
only be passed as const references:

class X;

void foo(X& x)
{
x.y = 2;
}

void bar()
{
// BAD: temporary X object is not an lvalue
foo(X(10));
}

daniel

Brian Clarkson wrote:

msalters · Guest

Brian Clarkson wrote:

Ian McCulloch · Guest

msalters wrote:

Howard Hinnant · Guest

In article <35niefF312m05U1 (AT) news (DOT) dfncis.de>,
[email]ianmcc (AT) physik (DOT) rwth-aachen.de[/email] (Ian McCulloch) wrote:

kanze@gabi-soft.fr · Guest

Brian Clarkson wrote:

John Nagle · Guest

Ian McCulloch wrote:

akrylik · Guest

Proxy! That's exactly what I want to use the temporary for, I just
didn't know that is what it's called. (FYI, I want to be able to write
expressions using temporary "views" of vectors, like in matlab: x(2:4)
= y(1:5)+5 and so on.)

So here is something weird (to me at least). I tried Howard's
suggestion and added a type conversion operator to the vector example
like this:

class vector {
public:
vector(int x_, int y_) : x(x_), y(y_) {}
vector(const vector& xx) : x(xx.x), y(xx.y) {}
vector& operator=(const vector& xx) { x = xx.x; y = xx.y; return
*this; }

operator vector&(){return *this;}

int x, y;
};

And compiling gives the following result:

Ian McCulloch · Guest

John Nagle wrote:

Motti Lanzkron · Guest

Howard Hinnant wrote:

Ben Hutchings · Guest

John Nagle wrote:
<snip>

Ian McCulloch · Guest

Howard Hinnant wrote:

msalters · Guest

Ben Hutchings wrote: