Wie überprüft man, ob der Iterator initialisiert ist?

Wenn ich einen default-Konstruktor ein iterator, wie Sie überprüfen, wenn es zugewiesen wurde später auf?

Für Hinweise, was ich tun konnte : 

int *p = NULL;
///some code
if ( NULL == p ) {
  //do stuff
}

Wie mache ich das oben für Iteratoren?
Ist es überhaupt möglich?

#include <iostream>
#include <list>

int main ()
{
    std::list<int>::iterator it;

  if ( NULL == it ) //this fails
  {
      std::cout<<"do stuff" << std::endl;
  }
}

InformationsquelleAutor der Frage BЈовић | 2011-08-05

  1. 16

    Ich es geschafft, zu finden im aktuellen standard (c++03 ). 24.1 p 5 sagt :

    Nur wie ein regulärer Zeiger auf ein array garantiert, dass es eine
    Zeigerwert verweist hinter das Letzte element des Arrays, also für jede
    iterator-Typ es ist eine iterator-Wert, die Punkte hinter der letzten
    element von einem entsprechenden Behälter. Diese Werte werden genannt
    past-the-end-Werte. Werte, die der iterator i, für die der Ausdruck
    i definiert ist, wird aufgerufen, dereferenceable. Die Bibliothek übernimmt nie
    dass past-the-end-Werte sind dereferenceable. Iteratoren können auch
    singuläre Werte, die nicht im Zusammenhang mit container.     [Beispiel:
    Nach der Erklärung von einer nicht initialisierten Zeiger x (als int     x;),
    x muss immer angenommen werden, haben einen einzigartigen Wert eines Zeigers. ]
    Ergebnisse der meisten Ausdrücke sind nicht definiert für singuläre Werte; die
    einzige Ausnahme ist eine Zuordnung einer nicht-singulären Wert, um einen iterator
    das hat einen einzigartigen Wert.     In diesem Fall sind die singulären Wert ist
    überschrieben die gleiche Weise wie jeder andere Wert. Dereferenceable Werte
    sind immer nicht - singular.

    (Hervorhebung von mir)

    Die Antwort ist also : Nein, es ist nicht möglich.

    InformationsquelleAutor der Antwort BЈовић

  2. 3

    Meisten Iteratoren haben keine globalen special-Werte in der gleichen Weise, dass alle Zeiger können NULL sein. Typischerweise, obwohl, arbeiten Sie mit bestimmten Behälter, und wenn Sie halten ein iterator pro container, dann können Sie end() the sentinel-Wert:

    std::list<int> mylist;
std::list<int>::iterator it = mylist.end();

/* do stuff */

if (it == mylist.end()) { ... }

    Ich bin mir nicht sicher, ob Einfügung/Löschung erlischt die end() iterator, obwohl, so dass, wenn Sie planen, ändern Sie Ihre container, vielleicht speichern Sie eine Kopie der ursprünglichen Zweck zu:

    std::list<int>::iterator end = mylist.end(), it = end;

if (it == end) { ... }

    Obwohl wieder ich bin nicht wirklich sicher, ob es gut definiert ist, zu vergleichen zwei ungültige Iteratoren (in dem Fall, dass die beiden zu tun bekommen, für ungültig erklärt).

    InformationsquelleAutor der Antwort Kerrek SB

  3. 1

    In C++, nicht initialisierte lokale Variablen haben können alle Wert ich.e es enthält einfach Müll. Das bedeutet, Sie nicht überprüfen Sie es gegen wohldefinierte Wert, um zu bestimmen, wenn die variable nicht initialisiert ist, oder nicht.

    Nicht nur, dass, wenn die variable nicht initialisiert ist und schreiben Sie diese in:

    if ( NULL == it ) //this fails

    dann ruft es zu undefiniertem Verhalten.

    InformationsquelleAutor der Antwort Nawaz

  4. 1

    Diese Frage wurde bereits behandelt, in Stackoverflow. Die Quintessenz ist, dass der Standard-Konstruktor initialisiert einen iterator, um eine singular valueund die nur addmissible Vorgang ist, ordnen Sie es mit einem anderen iterator-Wert. Insbesondere ist es nicht möglich, die Abfrage des Wertes solcher nicht initialisiertes iterator. Deshalb ist es ein guter Programmierstil, initialisiert den iterator auf einen bestimmten Wert einer bestimmten container, die dann getestet werden können.

    InformationsquelleAutor der Antwort Jiri

  5. 1

    Da es keinen Standardwert für Iteratoren (wie es ist NULL für Zeiger), in der situation wo ich brauche einen gemeinsamen default-Wert für eine Object::iterator (vor der eigentlichen Objekt erstellt wurde) erstelle ich eine dummy-variable, und verwenden Sie seine ::end() als Standard.

    Update : Das funktioniert nur bei "Release", denn in der DEBUG (oder mit _HAS_ITERATOR_DEBUGGING=1) Vergleichsoperatoren überprüfen Sie, ob beide Iteratoren auf das selbe Objekt zeigen/container.

    Beispielsweise für vector<int> ich tun würde :

    class A
{
public :
    A() :  myIterator1(dummyVector.end()), myIterator2(dummyVector.end()) {}
    //needed iterators
    vector<int>::iterator myIterator1;
    vector<int>::iterator myIterator2;

    static const vector<int> dummyVector;
}

#define  IT_NULL A::dummyObject.end()

void maint() {
    A::dummyObject = vector<int>(); //initialize the Null iterator

    A a;
    if(a.myIterator1 == IT_NULL) cout << "Iterator not yet initialized";
}

    InformationsquelleAutor der Antwort code7amza

  6. 0

    Können Sie nicht. ll, die Sie tun können, ist, vergleichen, Liste gegen Ende

    it != mylist.end();

    InformationsquelleAutor der Antwort cprogrammer

  7. 0

    Vielleicht sollten Sie sich immer die Zuweisung eines vordefinierten Wert, wie NULL, nach dem erstellen der iterator. Später können Sie leicht überprüfen, gegen NULL.
    Dadurch wird Ihr code mehr tragbar, da Sie nicht davon abhängen, welche Startwerte die nicht initialisierten Variablen werden am Anfang.

    InformationsquelleAutor der Antwort vsz

  8. 0
    if(std::list<int>::iterator() == it)

    Aber ich vermute,... kann es vorkommen, dass ein Gültiger iterator übergeben konnte Vergleich.
    Besser, diese Situationen zu vermeiden. Wenn es unmöglich ist, lagern Sie den iterator durch einen Zeiger.

     std::auto_ptr<std::list<int>::iterator> it;

    InformationsquelleAutor der Antwort kan

  9. 0

    Der beste Weg, dies zu tun ich denken kann, ist so etwas wie

    #include <utility>
#include <map>
#include <typeinfo>
#include <string>



namespace nulliterators {

typedef std::map<std::string, void*> nullcntT;
nullcntT nullcontainers;

template<class containerT>
typename containerT::iterator iterator() {
  containerT* newcnt = new containerT();
  std::string cnttypename = typeid(*newcnt).name();
  nullcntT::iterator i = nullcontainers.find(cnttypename);
  if (i==nullcontainers.end()) {
    nullcontainers.insert(make_pair(cnttypename, newcnt));
    return newcnt->end();
   }else{
    delete newcnt;
    return (static_cast<containerT*>(i->second))->end();
  }
}

}
template<class containerT>
typename containerT::iterator nulliterator() { return nulliterators::iterator<containerT>(); }


#include <list>
#include <iostream>


int main(){

  std::list<int>::iterator nullinitized = nulliterator< std::list<int> >();
  std::list<int> somelist;
  std::list<int>::iterator initialized = somelist.end();

  if (nullinitized == nulliterator< std::list<int> >())
    std::cout << "nullinitized == nulliterator< std::list<int> >()\n";  //true
   else
    std::cout << "nullinitized != nulliterator< std::list<int> >()\n";

  if (initialized == nulliterator< std::list<int> >())
    std::cout << "initialized == nulliterator< std::list<int> >()\n";
   else
    std::cout << "initialized != nulliterator< std::list<int> >()\n";  //true

  return 0;
}

    aber es ist nicht gerade eine sichere Lösung (weil Sie sich auf die non-const-global Container in nullcontainers).

    InformationsquelleAutor der Antwort leftaroundabout

  10. 0

    Soweit ich weiß muss man immer initialisieren Sie Ihre Iteratoren und der einfachste Weg ist, um Sie gleich 'container'.Ende()
    In bestimmten Fällen sieht es aus wie Arbeit, wir hatten einige Probleme mit code, der arbeitete mit VC6 und aufgehört zu arbeiten mit VC2010. Schauen Sie sich dieses Beispiel kompiliert mit g++, wo es funktioniert für den Vektor, aber nicht für die Karte:

    # Test iterator init, compile with: g++ test-iterator.cpp -o test-iterator
#include <iostream>
#include <vector>
#include <map>

int main()
{
    std::vector<int> vec;
    std::vector<int>::iterator it;

    if (it != vec.end())
    {
            std::cout << "vector inside!" << std::endl;
    }
    else
    {
            std::cout << "vector outside!" << std::endl;
    }

    std::map<int, int> mp;
    std::map<int, int>::iterator itMap;

    if (itMap != mp.end())
    {
            std::cout << "map inside!" << std::endl;
    }
    else
    {
            std::cout << "map outside!" << std::endl;
    }

    return 0;
}

    InformationsquelleAutor der Antwort Pedro Ferreira

  11. 0

    Ich habe folgende Lösung:

    const MyList_t::const_iterator NullIterator(NULL);
const_iterator MyList_t::MyIterator;

    Dann ist eine überprüfung möglich:

    if (NullIterator != MyIterator) {}

    InformationsquelleAutor der Antwort Thomas Horn

Schreibe einen Kommentar