class Position
{
public:
    Position(int inX=0, int inY=0);
    int x;
    int y;
};

Ich will also den Stack daraufhin prüfen ob er leer ist (ist er aber nicht denn er wird mit push() gefüllt) und bekomme die im Titel genannte Fehlermeldung...

stack<Position*> st;
Position* pos = 0;

// push the position on the stack and assign label
st.push(new Position(x,y));
labels(x,y) = lab;

while (!(st.empty()))
{
        pos = st.pop();
        int i = pos->x;
        int j = pos->y;
}

Was mache ich denn falsch?

std::stack::pop() hat void als Rückgabewert.

bis bald
akari

stack<Position*> st;
Position* pos = 0;

// push the position on the stack and assign label
st.push(new Position(x,y));
labels(x,y) = lab;

while (!(st.empty()))
{
        pos = st.top();
        int i = pos->x;
        int j = pos->y;
        //delete pos waere an dieser stelle evtl angebracht - speicherlecks vermeiden!
        st.pop();
}

Felix

Zur Not kann man sich ja ne eigene pop() routine schreiben:

template<typename T>
T mypop(std::stack<T> st) {
  T ret = st.top();
  st.pop();
  return ret;
}

int main()
{
std::stack<myClass> st;
//...

myClass mc = mypop(st); //template parameter von mypop muss nicht angegeben werden, wird aus argument hergeleitet.
}

Ist nicht intuitiv, aber nötig, um das ganze Threadsafe zu machen. Wenn pop den Wert zurückgibt, gibt es KEINE Möglichkeit, das komplett Threadsafe zu realisieren.

Felix

hmmm ... ist Threadsafe wirklich das Kriterium ? Ich hätte eher an Exceptionsafe gedacht ....

Gruß,

Simon2.

Hier mal der Code, der abbricht:

CImg<imgType> EyeLocatorPriv::labelImage()
{
    CImg<imgType> labels(width,height,1,1);
    labels.fill(0);
    stack<Position*> st;
    Position* pos = 0;
    int lab = 1;

    for (int x=1; x<width-1;x++)
    {
        for (int y=1; y<height-1; y++)
        {
            if (redBinaryMask(x,y) == 0)
                continue;
            if (labels(x,y) > 0)
                continue;
            // push the position on the stack and assign label
            st.push(new Position(x,y));
            labels(x,y) = lab;

            while (!st.empty())
            {
                pos = st.top();
                st.pop();
                int i = pos->x;
                int j = pos->y;

                if (redBinaryMask(i-1,j-1) == 255 && labels(i-1,j-1) == 0)
                {
                    st.push(new Position(i-1,j-1));
                    labels(i-1,j-1) = lab;
                }

                if (redBinaryMask(i-1,j) == 255 && labels(i-1,j) == 0)
                {
                    st.push(new Position(i-1,j));
                    labels(i-1,j) = lab;
                }

                if (redBinaryMask(i-1,j+1) == 255 && labels(i-1,j+1) == 0)
                {
                    st.push(new Position(i-1,j+1));
                    labels(i-1,j+1) = lab;
                }

                if (redBinaryMask(i,j-1) == 255 && labels(i,j-1) == 0)
                {
                    st.push(new Position(i,j-1));
                    labels(i,j-1) = lab;
                }

                if (redBinaryMask(i,j+1) == 255 && labels(i,j+1) == 0)
                {
                    st.push(new Position(i,j+1));
                    labels(i,j+1) = lab;
                }

                if (redBinaryMask(i+1,j-1) == 255 && labels(i+1,j-1) == 0)
                {
                    st.push(new Position(i+1,j-1));
                    labels(i+1,j-1) = lab;
                }

                if (redBinaryMask(i+1,j) == 255 && labels(i+1,j) == 0)
                {
                    st.push(new Position(i+1,j));
                    labels(i+1,j) = lab;
                }

                if (redBinaryMask(i+1,j+1) == 255 && labels(i+1,j+1) == 0)
                {
                    st.push(new Position(i+1,j+1));
                    labels(i+1,j+1) = lab;
                }
            } // end while
            lab++;
        }
    }
    components = lab;
    return labels;
}

Was kann denn das sein? Läuft der Stack einfach voll? Das wäre aber doof weil normalerweise sind meine digitalen Fotos alle so 3008x2272px groß...
Jemand eine Idee?

Laut einem meiner Bücher soll man in STL-Containern keine Zeiger, sondern normale Objekte abspeichern, da die Container intern Objekte verschieben, kopieren, usw. und es deswegen zu Fehlern kommen kann.

Das wundert mich nu ein wenig. Wenn man Container mit Zeigern benutzt, werdne ja nur die Zeiger verschoben udn kopiert, was eigentlich kein Problem sein sollte. Die Objekte die dahinter stecken, bleiben ja unberuehrt.
Ausserdem, wenn Container mit Zeigern pfui sind, wie soll man dann folgendes behandeln:
- Sammlungen von abgeleiteten Objekten der selben Basisklasse (Stichwort Polymorphie)
- Sammlungen von nicht-kopierbaren Objekten

In beiden Faellen erscheinen mir Container mit Zeigern als die natuerliche Loesung, vorausgesetzt man schafft keine Speicherlecks...

Laut einem meiner Bücher soll man in STL-Containern keine Zeiger, sondern normale Objekte abspeichern, ...

Das hast Du vermutlich mißverstanden. Ich denke mal, dass dort geraten wird, "... keine Zeiger auf Objekte im Container anzulegen ..."
Das hat im Deutschen eine fiese Doppeldeutigkeit: Ich klammere mal:
"... keine (Zeiger auf Objekte) im Container anzulegen ..." (= etwas im Container ablegen)
"... keine Zeiger auf (Objekte im Container) anzulegen ..." (= Zeiger auf etwas anzulegen)

Vergleich:
A) "... (Zeiger auf Objekte) im Container ..."

vector<myType*> vec(2); // Vector von Zeigern auf myType

                        // x     &x       vec[1]   &vec[1]
                        // --------------------------------
myType x('S');          // 'S'   0x1234   0x0000   0xaffe   
vec[1] = &x;            // 'S'   0x1234   0x1234   0xaffe   
vec.resize(2000);       // 'S'   0x1234   0x1234   0xdead

// => selbst wenn die Zeiger in vec verlagert werden, behalten sie doch dieselben Wert
// => sie zeigen weiterhin dahin, wo sie sollen
// => OK

"... Zeiger auf (Objekte im Container) ..."

vector<myType> vec(2);  // Vector von myType-Objekten

                        // x     &x       vec[1]   &vec[1]   p
                        // -------------------------------------
myType x('S');          // 'S'   0x1234   0        0xaffe    -
vec[1] =  x;            // 'S'   0x1234   'S'      0xaffe    -
myType* p = &vec[1];    // 'S'   0x1234   'S'      0xaffe    0xaffe
vec.resize(2000);       // 'S'   0x1234   'S'      0xdead    0xaffe

// => Nach der Verlagerung hat zwar vec[1] noch denselben Wert (Kopiert von x) aber eine andere Adresse
// => p zeigt weiterhin auf 0xaffe, aber vec[1] liegt inzwischen auf 0xdead
// => DANGER !!!

Gruß,

Simon2.

Laut einem meiner Bücher soll man in STL-Containern keine Zeiger, sondern normale Objekte abspeichern, da die Container intern Objekte verschieben, kopieren, usw. und es deswegen zu Fehlern kommen kann. Probier doch mal den Algorithmus mit stack<Position> (ohne Zeiger). Vielleicht löst das dein Problem. Außerdem ersparst du dir dann das explizite Freigeben der Zeiger.

Mal abgesehen von der expliziten Freigabe ist diese Aussage humbug (in welchem Buch steht die?). Container von Zeigern sind aus den von pumuckl genannten Gründen durchaus gängig.

Eine Alternative wären die pointer container in boost, welche sich selbst um die Freigabe der Zeiger kümmern, oder das speichern von boost smart pointern in einem Standardcontainer.

Wenn ich keine Zeiger nutze,...

Lies nochmal !
Deine Prämisse bezieht sich hier auf eine These, der schon massiv widersprochen wurde.

Gruß,

Simon2.

Phoemuex schrieb:

Ist nicht intuitiv, aber nötig, um das ganze Threadsafe zu machen. Wenn pop den Wert zurückgibt, gibt es KEINE Möglichkeit, das komplett Threadsafe zu realisieren.

Felix

hmmm ... ist Threadsafe wirklich das Kriterium ? Ich hätte eher an Exceptionsafe gedacht ....

Gruß,

Simon2.

Du hast natürlich recht Gut, wenn man immer jemanden hat, der einen korrigiert

Felix

...
Du hast natürlich recht Gut, wenn man immer jemanden hat, der einen korrigiert

Felix

Gut ! Ich hatte schon einen Knoten im Gehirn, weil ich dachte, ich wäre zu blöd.

Danke für die Rückmeldung,

Simon2.

Hier mal die Ausgabe: http://rafb.net/p/MH74yY52.html

Ich hoffe ihr könnt damit was anfangen, wie gesagt ich bin Python verwöhnt und dort gibt es ja Garbage Collectors, vielleicht ist das ja mein Problem...

Vielleicht findet ihr den Fehler... aber nichts desto trotz scheint valgrind mir massive Speicherprobleme zu zeigen, die ich wohl durch schlechte Pointerverwaltung hin bekomme

Ich poste nochmal den Code der diese Probleme verursacht:

CImg<imgType> EyeLocatorPriv::labelImage()
{
    CImg<imgType> labels(width,height,1,1);
    labels.fill(0);
    stack<Position*> st;
    Position* pos = 0;
    int lab = 1;
    labelValues.clear();

    for (int y=1; y<height-1; y++)
    {
        for (int x=1; x<width-1;x++)
        {
            if (redBinaryMask(x,y) == 0)
                continue;
            if (labels(x,y) > 0)
                continue;
            // push the position on the stack and assign label
            st.push(new Position(x,y));
            labels(x,y) = lab;
            setLabelValue(lab);

            while (!st.empty())
            {
                pos = st.top();
                st.pop();
                int i = pos->x;
                int j = pos->y;

                if ((redBinaryMask(i-1,j-1) == 255) && (labels(i-1,j-1) == 0))
                {
                    st.push(new Position(i-1,j-1));
                    labels(i-1,j-1) = lab;
                    setLabelValue(lab);
                }

                if ((redBinaryMask(i-1,j) == 255) && (labels(i-1,j) == 0))
                {
                    st.push(new Position(i-1,j));
                    labels(i-1,j) = lab;
                    setLabelValue(lab);
                }

                if ((redBinaryMask(i-1,j+1) == 255) && (labels(i-1,j+1) == 0))
                {
                    st.push(new Position(i-1,j+1));
                    labels(i-1,j+1) = lab;
                    setLabelValue(lab);
                }

                if ((redBinaryMask(i,j-1) == 255) && (labels(i,j-1) == 0))
                {
                    st.push(new Position(i,j-1));
                    labels(i,j-1) = lab;
                    setLabelValue(lab);
                }

                if ((redBinaryMask(i,j+1) == 255) && (labels(i,j+1) == 0))
                {
                    st.push(new Position(i,j+1));
                    labels(i,j+1) = lab;
                    setLabelValue(lab);
                }

                if ((redBinaryMask(i+1,j-1) == 255) && (labels(i+1,j-1) == 0))
                {
                    st.push(new Position(i+1,j-1));
                    labels(i+1,j-1) = lab;
                    setLabelValue(lab);
                }

                if ((redBinaryMask(i+1,j) == 255) && (labels(i+1,j) == 0))
                {
                    st.push(new Position(i+1,j));
                    labels(i+1,j) = lab;
                    setLabelValue(lab);
                }

                if ((redBinaryMask(i+1,j+1) == 255) && (labels(i+1,j+1) == 0))
                {
                    st.push(new Position(i+1,j+1));
                    labels(i+1,j+1) = lab;
                    setLabelValue(lab);
                }
            } // end while
            lab++;
        }
    }

    // remove components with less than 25 pixels
    for (map<int,int>::iterator it = labelValues.begin(); it != labelValues.end();)
    {
        if (it->second <= 25)
            labelValues.erase(it++);
        else
            ++it;
    }

    // update labels
    cimg_forXY(labels,x,y)
    {
        if (labelValues.find(labels(x,y)) == labelValues.end())
            labels(x,y) = 0;
    }
    return labels;
}

Irgendwas scheint wohl schief zu laufen beim pushen auf den Stack, denn die for-Schleifen können definitiv nicht über das Ziel hinaus schießen...