Iteratori per gli array di dimensioni diverse

Question

Il seguente codice compila bene sul mio sistema:

#include <array> 
#include <type_traits> 

static_assert(std::is_same<std::array<int, 5>::iterator, 
          std::array<int, 7>::iterator>::value, ":("); 

è che il comportamento garantito dalla norma? Il tipo iteratore è indipendente dalla dimensione dell'array?

Se è garantito, esiste un modo per astrarre dal tipo di elemento e ignorare la dimensione?

template<typename T, size_t n> 
void foobar(std::array<T, n>::iterator it) 

Cioè, esiste un modo per scrivere il codice specifico matrice sopra senza menzionare la dimensione n?

Si noti che non voglio ricorrere a T*, anche se in modalità di rilascio l'iteratore probabilmente è un T*.

Answer 1

No, non è garantito. Ogni tipo di array array<T, size_t> ha un typedf nidificato denominato iterator il cui tipo è definito dall'implementazione.

Answer 2

La semplice risposta è renderla un po 'più generica. Perché vuoi solo consentire gli iteratori da un std::array?

template <typename Iterator> 
void foobar(Iterator it) 

Nella seconda parte del codice, il tipo e le dimensioni Tn sono in un contesto non deducibile. Concettualmente più std::array tipi potrebbero avere lo stesso iterator tipo, o come si parla può essere solo T*, e sarebbe impossibile trovare quale possibile std::array avuto un T* come iterator

Answer 3

No, non ci sono garanzie. Lo standard dice solo

typedef implementation-defined iterator; 

Il tipo iteratore potrebbe essere un puntatore normale, una classe che è un membro del array, o di una classe separata avvolgendo il puntatore pianura.

Se si tratta di una classe membro, lo sarà dipende dalla dimensione dell'array. Altrimenti probabilmente no.