move semantics unused in presence of std::move

Question

With the following:

#include <iostream>
#include <fstream>
using namespace std;
int main() {
    ifstream f;
    ifstream g;
    f = std::move(g);
}

Why is ifstream::operator=(const ifstream&) being called instead of ifstream::operator=(ifstream&&) even though std::move() is called?

Update: Generally speaking, is there a way to coerce a lvalue reference to a rvalue reference?

@iammilind: yes it does, but it is protected (see section 27.7.2.1.2 Class basic_istream assign and swap) — sehe, Nov 21 '11 at 10:32

score 5 · Accepted Answer · answered Nov 21 '11 at 15:20

5

What evidence do you have that ifstream::operator=(const ifstream&) is being called? Do you get a compile error that says you're calling this private or deleted member?

If your code is calling ifstream::operator=(const ifstream&), and if your implementation is claiming to be C++11, then this is a bug in either your C++ std::lib, or compiler. When I compile your code, ifstream::operator=(ifstream&&) gets called. And this is by design.

I stuck a print statement in my implementation of ifstream::operator=(ifstream&&) just to be sure. When I did your program prints out:

basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)

answered Nov 21 '11 at 15:20

Howard Hinnant

206,506
52
449
577

It looks like this rather annoying bug has been in gcc for a while, then. Time to open a bug report. – moshbear Nov 21 '11 at 18:30
Also, which compiler did you use? – moshbear Nov 21 '11 at 18:40
Sorry, this is less a gcc bug than a libstdc++ bug, due to `basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)` isn't even defined. – moshbear Nov 21 '11 at 19:08

sehe · Answer 2 · 2011-11-21T10:49:21.840

Standard

 27.9.1.8 Assign and swap [ifstream.assign]

       basic_ifstream& operator=(basic_ifstream&& rhs);

I assume you are looking at the wrong code (nowhere is it guaranteed that the base class operator istream::operator=(istream&&) must be called)?

Update: Generally speaking, is there a way to coerce a lvalue reference to a rvalue reference?

Yes, it is what std::move does:

template <class T> typename remove_reference<T>::type&& move(T&& t) noexcept;

There is also

template <class T> typename conditional<
  !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
  const T&, T&&>::type move_if_noexcept(T& x) noexcept;

which does the same, provided that the moveconstructor is nothrow.

I forgot if it was the base class or the derived class that had `MoveAssignable`. Edited question. — moshbear, Nov 21 '11 at 10:31

move semantics unused in presence of std::move

2 Answers2