不可复制类型的std :: initializer_list替代品

Question

I know that trying to use a std::initializer_list<NonCopyable> leads to an error because the elements are copied into the temporary array represented by the initializer_list . I have also read some explanation on why it would not be alright to have rvalue references in the list, which I'm fine with.

The problem is that I would like to pass noncopyable things not in order to move from them, but only const -access them, so the argument about rvalues does not apply. What can I do to retain, if possible, the list initialization syntax and the reference semantics (no wrappers, no raw pointers)?

NonCopyable a{...}, b{...};
ListInitialized c{a, b};

I think I'm missing something extremely obvious here.

Update:

This works(*),

ListInitialized(std::initializer_list<std::reference_wrapper<NonCopyable>>) {...}

but won't accept rvalues. It would be nice if I could simply pass a list of anything that could go into const NonCopyable& .

_{(*) I know I wrote "no wrappers" but this affects neither the calling code nor the iteration over the list.}

Answer 1

You can give ListInitialized a variadic constructor template:

struct ListInitialized
{
  template <class... T>
  ListInitialized(const T... &arg);
};

If you need to make sure it can only be instantiated with the correct type, consider suitable SFINAE :

struct ListInitialized
{
  template <
    class... T,
    class Sfinae = std::enable_if_t<std::is_same<std::decay_t<T>, NonCopyable> &&...
  >
  ListInitialized(const T... &arg);
};

Answer 2

In addition to the comments and answers above, I found that this minimalistic wrapper fulfills my needs:

#include <initializer_list>
#include <utility>

struct S {
  S() { }
  S(const S&) = delete; // Non-copyable
  void f() const { }
};

template<class T>
class const_reference_wrapper {
public:
  const_reference_wrapper(const T& ref_) : ref(ref_) { }
  operator const T&() const { return ref; }
private:
  const T& ref;
};

struct T {
  T(std::initializer_list<const_reference_wrapper<S>> l) : c(l.size()) {
    for(const S& i : l)  // note: const auto& can't be used here, but it would be the same for std::reference_wrapper
      i.f();  // we can do something with the elements
  }

  int c;
};

int main() {
  S a, b;
  T t{a, b, S{}};  // we can mix lvalues and rvalues with a natural syntax
  return t.c;  // correctly returns 3
}

Of course, care needs to be taken to ensure that any rvalue passed through this will live through the time it is being referenced.