Why is there no piecewise tuple construction?

by

Question: Why doesn’t the same piecewise constructibility exist for arrays and tuples?

My recollection is that piecewise construction was added to std::pair for one reason only: to support uses-allocator construction of the pair elements, i.e. to allow an allocator to be provided and conditionally passed to the elements if they support construction with an allocator (see [allocator.uses] in the standard).

At one point during the C++0x process std::pair had twice as many constructors as it does now, with every constructor having a corresponding “allocator-extended” version taking a std::allocator_arg_t and an allocator argument e.g.

template<class T, class U>
  struct pair {
    pair();
    pair(allocator_arg_t, const Alloc&);
    template<class TT, class UU>
      pair(TT&&, UU&&);
    template<class Alloc, class TT, class UU>
      pair(allocator_arg_t, const Alloc&, TT&&, UU&&);
    // etc.

There was something of a running joke (haha, only serious) about the insane complexity of std::pair. The support for passing allocators to the elements was removed from std::pair and moved into std::scoped_allocator_adaptor, which is responsible for detecting whether the elements should be constructed with an allocator (see the construct overloads taking a pointer to std::pair in [allocator.adaptor.members]).

A nice consequence of the piecewise construction is that you can do “emplace” style initialization of pair elements, allowing pairs of non-movable, non-copyable types, but as far as I know that was not the goal of the design.

So the reason tuple doesn’t support it is that the feature was invented to simplify pair which had ballooned from a very simple type in C++03 to a laughing stock in C++0x, but doing the same for tuple was not considered as important (it was new for C++11 anyway). Also, extending scoped_allocator_adaptor to handle tuples of arbitrary numbers of elements would have made that adaptor much more complicated.

As for std::array, that’s an aggregate type (because reasons) so adding a constructor taking piecewise_construct_t is not possible without making it a non-aggregate.

More Related Contents:

  1. How do I expand a tuple into variadic template function’s arguments?
  2. Implementing comparison operators via ‘tuple’ and ‘tie’, a good idea?
  3. Pretty-print std::tuple
  4. Generic hash for tuples in unordered_map / unordered_set
  5. Template tuple – calling a function on each element
  6. Convert std::tuple to std::array C++11
  7. Can someone please explain the “indices trick”?
  8. C++11 way to index tuple at runtime without using switch
  9. How to iterate over a std::tuple in C++ 11 [duplicate]
  10. how to avoid undefined execution order for the constructors when using std::make_tuple
  11. std::tuple get() member function
  12. std::tuple memory alignment
  13. How to initialize all tuple elements by the same arguments?
  14. get part of std::tuple
  15. get part of std::tuple
  16. Invalid operands to binary expression while implementing vector [closed]
  17. reinterpret_cast creating a trivially default-constructible object
  18. Why does C++11’s lambda require “mutable” keyword for capture-by-value, by default?
  19. initializer_list and template type deduction
  20. What constitutes a valid state for a “moved from” object in C++11?
  21. Difference between pointer and reference as thread parameter
  22. Is the pass-by-value-and-then-move construct a bad idiom?
  23. Why is this code trying to call the copy constructor?
  24. Why can we use `std::move` on a `const` object?
  25. Inserting into an unordered_set with custom hash function
  26. Disable Eclipse’s error discovery. (Codan false positives)
  27. C++11 STL containers and thread safety
  28. C++11 equivalent to boost shared_mutex
  29. Why would I std::move an std::shared_ptr?
  30. std::enable_if : parameter vs template parameter

Leave a Comment