Initialisieren Sie std :: array mit einem Bereich (Paar von Iteratoren)

Question

Wie kann ich eine aus einem Bereich initialisieren (wie durch ein Paar von Iteratoren definiert)?

Etwas wie folgt aus:

vector<T> v; 
... 
// I know v has exactly N elements (e.g. I just called v.resize(N)) 
// Now I want a initialized with those elements 
array<T, N> a(???); // what to put here? 

Ich dachte array einen Konstruktor nimmt ein Paar von Iteratoren haben würde, so dass ich array<T, N> a(v.begin(), v.end()) tun könnte, aber es scheint, überhaupt keine Konstrukteure zu haben!

Ich weiß, ich kann copy den Vektor in das Array, aber ich würde lieber das Array mit dem Vektor Inhalt direkt initialisieren, ohne Standard-Konstruktion es zuerst. Wie kann ich?

Answer 1

Mit Random-Access-Iteratoren, und eine bestimmte Größe zur Compile-Zeit unter der Annahme, können Sie ein pack of indices, dies zu tun verwenden:

template <std::size_t... Indices> 
struct indices { 
    using next = indices<Indices..., sizeof...(Indices)>; 
}; 
template <std::size_t N> 
struct build_indices { 
    using type = typename build_indices<N-1>::type::next; 
}; 
template <> 
struct build_indices<0> { 
    using type = indices<>; 
}; 
template <std::size_t N> 
using BuildIndices = typename build_indices<N>::type; 

template <typename Iterator> 
using ValueType = typename std::iterator_traits<Iterator>::value_type; 

// internal overload with indices tag 
template <std::size_t... I, typename RandomAccessIterator, 
      typename Array = std::array<ValueType<RandomAccessIterator>, sizeof...(I)>> 
Array make_array(RandomAccessIterator first, indices<I...>) { 
    return Array { { first[I]... } }; 
} 

// externally visible interface 
template <std::size_t N, typename RandomAccessIterator> 
std::array<ValueType<RandomAccessIterator>, N> 
make_array(RandomAccessIterator first, RandomAccessIterator last) { 
    // last is not relevant if we're assuming the size is N 
    // I'll assert it is correct anyway 
    assert(last - first == N); 
    return make_array(first, BuildIndices<N> {}); 
} 

// usage 
auto a = make_array<N>(v.begin(), v.end()); 

Dies setzt voraus, einen Compiler der Lage, die Zwischen Kopien eliding. Ich denke, diese Annahme ist keine große Sache.

Tatsächlich kann es auch mit Eingabe-Iteratoren gemacht werden, da die Berechnung jedes Elements in einer braced-init-Liste vor der Berechnung des nächsten Elements (§8.5.4/4) sequenziert wird.

// internal overload with indices tag 
template <std::size_t... I, typename InputIterator, 
      typename Array = std::array<ValueType<InputIterator>, sizeof...(I)>> 
Array make_array(InputIterator first, indices<I...>) { 
    return Array { { (void(I), *first++)... } }; 
}  

Da *first++ hat keine I drin, wir brauchen eine Dummy-I die Expansion Pack zu provozieren. Komma-Operator zur Rettung, mit void(), Warnungen über Mangel an Effekten zum Schweigen zu bringen, und auch überladene Kommas zu verhindern.

Answer 2

Wie Sie bemerkt haben, hat std :: array überhaupt keine Konstruktoren (außer für den vom Compiler generierten Standardkonstruktor).

Dies wurde mit Absicht gemacht, so dass es wie ein C-Array statisch initialisiert werden kann. Wenn Sie das Array ohne einen statischen Initialisierer füllen möchten, müssen Sie Ihre Daten kopieren.

Answer 3

Sie können BOOST_PP_ENUM wie verwenden:

include <boost/preprocessor/repetition/enum.hpp> 

#define INIT(z, i, v) v[i] 

std::vector<int> v; 

//fill v with at least 5 items 

std::array<int,5> a = { BOOST_PP_ENUM(5, INIT, v) }; //MAGIC 

Hier wird die letzte Zeile erweitert, wie:

std::array<int,5> a = {v[0], v[1], v[2], v[3], v[4]}; //EXPANDED LINE 

das ist, was Sie wollen.