Non-copyable elements in vector

by

Yes you can have std::vector<NotCopyable> if NotCopyable is movable:

struct NotCopyable
{
    NotCopyable() = default;
    NotCopyable(const NotCopyable&) = delete;
    NotCopyable& operator = (const NotCopyable&) = delete;

    NotCopyable(NotCopyable&&) = default;
    NotCopyable& operator = (NotCopyable&&) = default;
};

int main()
{
    std::vector<NotCopyable> v;
    NotCopyable nc;

    v.push_back(NotCopyable{});
    v.emplace_back();
    v.push_back(std::move(nc));
}

Live example.

More Related Contents:

  1. push_back vs emplace_back
  2. What does the standard library guarantee about self move assignment?
  3. When should std::move be used on a function return value? [duplicate]
  4. Reusing a moved container?
  5. Move assignment operator and `if (this != &rhs)`
  6. Is a moved-from vector always empty?
  7. Why does std::move prevent RVO (return value optimization)?
  8. How to actually implement the rule of five?
  9. How to declare a vector of atomic in C++
  10. Does moving leave the object in a usable state?
  11. std::optional specialization for reference types
  12. Why do we copy then move?
  13. Initializer-list-constructing a vector of noncopyable (but movable) objects
  14. Is a `=default` move constructor equivalent to a member-wise move constructor?
  15. What is the default hash function used in C++ std::unordered_map?
  16. Is an object guaranteed to be moved when it is returned?
  17. Why do you use std::move when you have && in C++11? [duplicate]
  18. Is there any case where a return of a RValue Reference (&&) is useful?
  19. How do I erase elements from STL containers?
  20. What happens when you call data() on a std::vector?
  21. C++11 virtual destructors and auto generation of move special functions
  22. Comparing 3 modern c++ ways to convert integral values to strings
  23. When is explicit move needed for a return statement?
  24. Move out element of std priority_queue in C++11
  25. Why can’t I replace std::map with std::unordered_map
  26. Why would I std::move an std::shared_ptr?
  27. Why isn’t std::array::size static?
  28. const auto std::initializer_list difference between Clang and GCC
  29. What is use of the ref-qualifier `const &&`?
  30. C++11 std::to_string(double) – No trailing zeros

Leave a Comment