Bereich basiert für Schleifen auf null Strings beendet

Question

ich irgendwie diesen Bereich für Schleifen basierend angenommen würde C-Strings

void print_C_str(const char* str) 
{ 
    for(char c : str) 
    { 
     cout << c; 
    } 
} 

Dies ist jedoch nicht der Fall ist, die Standard-[stmt.ranged] (6.5.4) sagt, dass bereichsbasierte-für Unterstützung arbeitet in einer von 3 Möglichkeiten:

1. der Bereich ist ein Array
2. der Bereich wird eine Klasse mit einer abrufbaren begin und end Verfahren
3. Es ist ADL erreichbar in einem zugehörigen Namensraum (plus std Namespace)

Wenn ich begin und end Funktionen für const char* im globalen Namespace füge ich noch Fehler auftreten (von beiden VS12 und GCC 4.7).

Gibt es eine Möglichkeit, range-based-for-Schleifen mit C-Stil-Strings zu arbeiten?

Ich habe versucht, eine Überlastung zu namespace std das Hinzufügen und das hat funktioniert, aber nach meinem Verständnis ist es illegal Überlastungen namespace std hinzufügen (ist das richtig?)

Answer 1

Wenn Sie einen trivialen Iterator für nullterminierte Strings schreiben, können Sie dies tun, indem Sie eine Funktion für den Zeiger aufrufen, der einen speziellen Bereich zurückgibt, anstatt den Zeiger selbst als Bereich zu behandeln.

template <typename Char> 
struct null_terminated_range_iterator { 
public: 
    // make an end iterator 
    null_terminated_range_iterator() : ptr(nullptr) {} 
    // make a non-end iterator (well, unless you pass nullptr ;) 
    null_terminated_range_iterator(Char* ptr) : ptr(ptr) {} 

    // blah blah trivial iterator stuff that delegates to the ptr 

    bool operator==(null_terminated_range_iterator const& that) const { 
     // iterators are equal if they point to the same location 
     return ptr == that.ptr 
      // or if they are both end iterators 
      || is_end() && that.is_end(); 
    } 

private: 
    bool is_end() { 
     // end iterators can be created by the default ctor 
     return !ptr 
      // or by advancing until a null character 
      || !*ptr; 
    } 

    Char* ptr; 
} 

template <typename Char> 
using null_terminated_range = boost::iterator_range<null_terminated_range_iterator<Char>>; 
// ... or any other class that aggregates two iterators 
// to provide them as begin() and end() 

// turn a pointer into a null-terminated range 
template <typename Char> 
null_terminated_range<Char> null_terminated_string(Char* str) { 
    return null_terminated_range<Char>(str, {}); 
} 

Und Nutzung sieht wie folgt aus:

for(char c : null_terminated_string(str)) 
{ 
    cout << c; 
} 

Ich glaube nicht, dass dies irgendeine Aussagekraft verliert. Eigentlich denke ich, dass dieser klarer ist.

Answer 2

Ein C-String kein Array ist, ist es nicht eine Klasse, die hat begin/end Mitglieder, und Sie werden nichts von ADL finden, weil das Argument ein Primitiv ist. Argumentiert sollte dies klar unqualifizierte Suche sein, mit ADL, würde eine Funktion im globalen Namespace finden. Aber angesichts der Formulierung denke ich, dass das nicht möglich ist.

Answer 3

Eine mögliche Problemumgehung besteht darin, die nullterminierte Zeichenfolge in einem anderen Typ zu umbrechen. Die einfachste Implementierung ist wie folgt (es ist weniger performant als R. Martinho Fernandes Vorschlag, da es ruft strlen, aber es ist auch deutlich weniger Code).

class null_terminated_range { 
    const char* p: 
public: 
    null_terminated_range(const char* p) : p(p) {} 
    const char * begin() const { return p; } 
    const char * end() const { return p + strlen(p); } 
}; 

Verbrauch:

for(char c : null_terminated_range(str))