bereichsbasierte for-Schleife auf einem dynamischen Array?

Question

Es gibt eine Reihe basierte for-Schleife mit der Syntax:

for(auto& i : array) 

Es arbeitet mit konstanter Arrays, aber nicht mit Zeigern basierten dynamisch diejenigen, wie

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

Es gibt Fehler und Warnungen über das Scheitern der Substitution, zum Beispiel:

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

Wie verwende ich diese neue Syntax mit dynamischen Arrays?

Answer 1

Um die Verwendung der bereichsbasierte for-Schleife Sie haben, um entweder begin() und end() Mitgliederfunktionen oder Überlastung des Dritt begin() und end() Funktionen zu machen. Im letzteren Fall können Sie Ihr Angebot in einer std::pair und Überlastung begin() und end() für diejenigen, wickeln:

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; } 
    } 

Jetzt können Sie die for-Schleife wie folgt verwenden:

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

Hinweis, dass das nicht-Mitglied begin() und end() Funktionen müssen hier im std Namespace überlastet werden, da pair liegt auch im Namensraum std. Wenn Sie nicht das Gefühl, mit den Standard-Namespace wie Manipulation, können Sie einfach Ihre eigenen kleine Paar Klassen erstellen und überlasten begin() und end() in Ihrem Namensraum.

Oder eine dünne Hülle um Ihren dynamisch zugewiesenen Array erstellen und begin() und end() Member-Funktionen bieten:

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}; } 

Und Ihr Aufrufort sieht wie folgt aus:

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

Example

Answer 2

Sie können nicht Entfernungs-for-Schleife verwenden, mit dynamisch zugewiesenen Arrays, da Compiler nicht ableiten kann dieses Arrays beginnen und enden. Sie sollten immer Behälter verwenden, anstatt es zum Beispiel std::vector.

Answer 3

Sie können keine bereichsbasierte Schleife über ein dynamisch zugewiesenes Array ausführen, da Sie lediglich einen Zeiger auf das erste Element haben. Es gibt keine Informationen über seine Größe, die der Compiler zum Ausführen der Schleife verwenden kann. Die idiomatische C++ Lösung wäre, die dynamisch zugewiesen Array durch ein std::vector zu ersetzen:

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

Ein Bereich basierend für Loop funktioniert für std::array Objekte. Sie haben über die Array-Instanz suchen (arr), nicht der Typ (array):

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

Answer 4

Sehen Sie diese Seite http://www.codeproject.com/Articles/570638/Ten-Cplusplus11-Features-Every-Cplusplus-Developer und finden Sie im Kapitel "Nicht-Mitglied() und end() beginnen". Dies könnte sein, was Sie erreichen möchten.