Re: Passing Temporaries to perform non const operations

From:

Victor Bazarov <v.Abazarov@comAcast.net>

Newsgroups:

comp.lang.c++

Date:

Wed, 15 Apr 2009 10:19:56 -0400

Message-ID:

<gs4qef$77g$1@news.datemas.de>

joecook@gmail.com wrote:

Altering a temporary is perfectly legal, for example:

std::vector<int> vec(40);
std::vector<int>(4).swap(vec); //legal.

I am trying to get this same functionality, but within an assignment
operator, but can't seem to find a good way to bind the temporary.

You've run into the same problem many of C++ programmers had over the
past several years. You need "move semantics". If you'd like to know
more about those, look them up.

Currently the work is under way to make "move semantics" simpler in the
language itself, with the help of rvalue references.

For example:

class Foo;
int main()
{
Foo f;
f = Foo(20);
}

#include <vector>
class Foo
{
public:
  Foo(int size=0) { m_data.resize(size);}

  // PROBLEM HERE. The temporary can't be bound to a reference to non-
const
  // But if this were 'const reference', the swap function could not
be called using it.
  void operator=(Foo& foo)
  {
    m_data.swap(foo.m_data);
  }
  std::vector<int> m_data;
};

The only work-around I could think of was this ugly code:
void operator=(const Foo& foo)
{
  std::vector<T>* tmpVec = const_cast<std::vector<T>*>(foo.m_data);
  tmpVec->swap(m_data);
}

Any better suggestions?

Wait a couple of years when your compiler implements the rvalue
references...

Check out the existing solutions for 'move semantics'. Andrei
Alexandrescu's work comes to mind (the 'MOJO' library).

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask