Basato su intervallo per il loop su un array dinamico?

Question

V'è una serie basata su ciclo for con la sintassi:

for(auto& i : array) 

Funziona con le matrici costanti, ma non con quelli dinamici basati puntatore, come

int *array = new int[size]; 
for(auto& i : array) 
    cout<< i << endl; 

Dà errori e gli avvertimenti circa il fallimento di sostituzione, ad esempio:

Error] C:\Users\Siegfred\Documents\C-Free\Temp\Untitled2.cpp:16:16: error: no matching function for call to 'begin(int*&)'

Come si utilizza questa nuova sintassi con gli array dinamici?

Answer 1

Per usufruire del gamma-based per-loop è necessario fornire sia begin() e end() funzioni membro o sovraccaricare il non membro begin() e end() funzioni. In quest'ultimo caso, si può avvolgere la vostra gamma in un std::pair e sovraccarichi begin() e end() per chi:

namespace std { 
     template <typename T> T* begin(std::pair<T*, T*> const& p) 
     { return p.first; } 
     template <typename T> T* end(std::pair<T*, T*> const& p) 
     { return p.second; } 
    } 

Ora è possibile utilizzare il ciclo for in questo modo:

for (auto&& i : std::make_pair(array, array + size)) 
     cout << i << endl; 

nota, che le funzioni non membro begin() e end() devono essere sovraccaricate nello spazio dei nomi std qui, poiché lo pair risiede anche nello spazio nomi std. Se non hai voglia di manomettere lo spazio dei nomi standard, puoi semplicemente creare la tua piccola classe di coppia e sovraccaricare lo begin() e lo end() nel tuo spazio dei nomi.

Oppure, creare un sottile involucro intorno al vostro array allocato in modo dinamico e fornire begin() e end() membri funzioni:

template <typename T> 
    struct wrapped_array { 
     wrapped_array(T* first, T* last) : begin_ {first}, end_ {last} {} 
     wrapped_array(T* first, std::ptrdiff_t size) 
      : wrapped_array {first, first + size} {} 

     T* begin() const noexcept { return begin_; } 
     T* end() const noexcept { return end_; } 

     T* begin_; 
     T* end_; 
    }; 

    template <typename T> 
    wrapped_array<T> wrap_array(T* first, std::ptrdiff_t size) noexcept 
    { return {first, size}; } 

e il vostro sito chiamata simile a questo:

for (auto&& i : wrap_array(array, size)) 
     std::cout << i << std::endl; 

Example

Answer 2

Non è possibile utilizzare range-for-loop con matrici allocate dinamicamente, poiché il compilatore non può dedurre l'inizio e la fine di questo array. È necessario utilizzare sempre i contenitori anziché, ad esempio std::vector.

std::vector<int> v(size); 
for(const auto& elem: v) 
    // do something 

Answer 3

Non è possibile eseguire un ciclo basato su una gamma di array allocato dinamicamente, perché tutto quello che hai è un puntatore al primo elemento. Non ci sono informazioni riguardo alle sue dimensioni che il compilatore può usare per eseguire il ciclo. La soluzione idiomatica C++ sarebbe quella di sostituire l'array allocato dinamicamente da un std::vector:

std::vector<int> arr(size); 
for(const auto& i : arr) 
    std::cout<< i << std::endl; 

Una gamma basati per ciclo funziona per std::array oggetti. Bisogna guardare oltre l'istanza array (arr), non il tipo (array):

std::array<int,10> arr; 
for(const auto& i : arr) 
    std::cout<< i << std::endl; 

Answer 4

consultare questa pagina http://www.codeproject.com/Articles/570638/Ten-Cplusplus11-Features-Every-Cplusplus-Developer e trovare il capitolo "non membro begin() e la fine()". Questo potrebbe essere ciò che vuoi ottenere.