Iterator auf Vector mit Zeigern

Es existiere ein Vector mit Zeigern.

std::vector<Foo*> f;

std::vector<Foo*>::iterator iter;

mit

iter = f.begin();

müsste ich auf den Zeiger auf das Element zugreifen können.

Doch nun müsste ich wieder dereferenzieren, wenn ich auf den Inhalt zugreifen will.

Irgendwie klappt das bei mir nicht.

Könnte jemand erklären, wie das geht?

LordJaxom

**iter

akari

Hallo

(*iter).function(x);
// oder
iter->function(x);

bis bald
akari

LordJaxom

@akari:
Bei einem boost Pointer-Container würde ich Dir recht geben

akari

Hallo

ja sorry, muß natürlich so aussehen

class foo
{
  public :

    void dosomething();
};

std::vector<foo*> f;
std::vector<foo*>::iterator iter;
...
iter = f.begin();
(*iter)->dosomething();

bis bald
akari

Okay, soweit verstanden. Nun will ich in diesem Array einen Wert suchen, mit find aus algorithm.h

Die Klasse Foo sei erweitert:

//Foo.h
class Foo
{
      private:
              int m_x;
      public:
             Foo(int x) :m_x(x) {}
             void getX()
             {
                  return m_x;
             }
             friend bool operator<(const Foo& left, const Foo& right);
};

//Foo.cpp
#include "Foo.h"

bool operator<(const Foo& left, const Foo& right)
{
    return left.m_x < right.m_x;   
}

Wie muss ich nun richtig die Parameter für find übergeben?
Wenn ich es so mache:

main()
{
std::vector<Foo*> array;
Foo* f1 = new Foo(1);
Foo* f2 = new Foo(2);
array.push_back(f1);
array.push_back(f2);

std::vector<Foo*>::iterator iter;
iter = find(array.begin(), array.end(), 2);

if  (iter != array.end())
{
    std:: cout << (*iter)->getX();
}

}

..Dann bekomme ich Compiler-Fehler:

ISO C++ forbids comparison between pointer and integer
instantiated from `_InputIterator std::find(_InputIterator, _InputIterator, const _Tp&) [with _InputIterator = __gnu_cxx::__normal_iterator<Foo**, std::vector<Foo*, std::allocator<Foo*> > >, _Tp = int]'

Oder ist der operator< falsch implementiert?

LordJaxom

Der Algorithmus find sucht genau den übergebenen Wert in dem angegebenen Bereich, also musst Du ihm ein Foo* übergeben. Der operator< wird dafür übrigens in keiner Weise benötigt. Wenn Du zwei Foo-Objekte auf Gleichheit prüfen willst, braucht die Klasse Foo einen operator== und Du musst (z.B.) find_if mit einem Funktor verwenden. Beispiel (ungetestet und nicht optimal):

struct is_my_object
{
  is_my_object( int x ): vergleichsobjekt( x ) {}
  bool operator()( Foo* other ) { return vergleichsobjekt == *other; }
  Foo vergleichsobjekt;
};

/* ... */
iter = find_if( array.begin(), array.end(), is_my_object( 2 ) );

Mhm, ich glaube ich verstehe das Prinzip.

Ich bin grad nur am Überlegen, ob das mit dem Funktor für mein Problem nicht ein bisschen overhead ist und ich es nicht einfacher ohne Verwendung der STL händisch ausprogrammiere (mit etwas schlechterer Laufzeit wahrscheinlich, was aber in meinem Fall nicht von belang wäre)...