make_pair like trick for noncopyable classes

Question

make_pair can create pairs without mentioning the types. I want to use the same trick for my class, but it inherits from boost::noncopyable, so this does not compile:

template<class Iter>
struct bit_writer : boost:noncopyable
{
    Iter iter;
    bit_writer(Iter iter)
    : iter(iter)
    {}
};

template<class Iter>
bit_writer<Iter> make_bit_writer(Iter iter)
{
    return bit_writer<Iter>(iter);
}
vector<char> vec;
auto w = make_bit_writer(vec);

Any alternative? I tried making make_bit_writer a friend, and then run out of ideas.

Assuming you don't want to return via some sort of pointer (preferably a smart pointer), is it possible to make bit_writer a move-only class? As it is, you're basically telling the compiler to create a temporary and return it, but the temporary can neither be moved nor copied. — Dave S, Jul 27 '12 at 21:07

Flexo · Accepted Answer · 2012-08-01T18:14:07.877

If you have C++11 you can do this using something like:

#include <functional>
#include <utility>
#include <type_traits>

struct noncopyable_but_still_moveable {
  noncopyable_but_still_moveable(const noncopyable_but_still_moveable&) = delete;
  noncopyable_but_still_moveable(noncopyable_but_still_moveable&&) = default;
  noncopyable_but_still_moveable() = default;
  noncopyable_but_still_moveable& operator=(const noncopyable_but_still_moveable&) = default;
  noncopyable_but_still_moveable& operator=(noncopyable_but_still_moveable&&) = default;
};

template <typename T>
struct test : noncopyable_but_still_moveable {
  test(T) {}
  // the rest is irrelevant 
};

template <typename T>
test<T> make_test(T&& val) {
  return test<typename std::remove_reference<T>::type>(std::forward<T>(val));
}

int main() {
  auto && w = make_test(0);
}

Note that I've replaced boost::noncopyable with a type that has a deleted copy constructor. This is the C++11 way of making something non-copyable and is needed because the boost class was also not moveable. Of course you could just put that inside the class itself and not inherit any more.

Without C++11 you'll want to use something like Boost move to emulate these semantics.

I changed your last line to auto&& w = make_test(0); so I can call non const members on w. Is the change safe? — Bruno Martinez, Jul 31 '12 at 18:50
@BrunoMartinez - updated. Turned out my answer was wrong originally. Some input from the C++ chat room helped fix it. — Flexo, Aug 01 '12 at 18:14

Puppy · Answer 2 · 2012-08-01T18:01:36.563

2

You will need C++11 and to update your class for move semantics. There is no other solution to the proposed problem.

class test {
public:
    test(test&&);
    // stuff
};
test make_test(...) {
    return test(...);
}
int main() {
    // Both valid:
    auto p = make_test(...);
    auto&& p2 = make_test(...);
}

edited Aug 01 '12 at 18:01

answered Aug 01 '12 at 17:50

Puppy

144,682
38
256
465

make_pair like trick for noncopyable classes

2 Answers2