ich habe folgendes Programm: In einer while-Schleife werden einzelne Bilder aus einem Video ausgelesen. Mit einer Klasse Painter soll auf den Bilder gezeichnet werden können. Bedingung: Der Painter soll auf dem Originalbild zeichnen, also keine eigene Kopie speichern:

// Pseudocode
Painter p;
while(readFrame()) {
    Image img = readImage();
    p.setImage(img); // Soll nur Referenz speichern

    // [...] zeichnen mit Painter, Darstellung usw.
}

Wie realisiert man das am besten, so dass auch immer gleich sichergestellt wird, dass das Bild, was dem Painter zugeordnet wurde, auch stets existiert. Der beste Ansatz, der mir einfällt wäre folgender:

// Beispielcode
class PainterPointer {
public:

	PainterPointer(Image *to) : myImage(to){

	}

        void draw();
        void drawX();
        void drawY();

private:

	Image* myImage;
};

// Pseudocode
Painter p;
while(readFrame()) {
    Image img = readImage();
    p.setImage(&img); // Soll nur Referenz speichern

    // [...] zeichnen mit Painter, Darstellung usw.
}

In den zeichnen Methoden des Painters wie draw oder drawX müsste man dann immer prüfen, ob zumindest der Pointer gesetzt wurde:

void drawX() {
if(myImage) {

}
}

Gibt's da noch einen besseren Ansatz?

Irgendwie kapier ich den Sinn des zweiten Code-Stücks aber nicht. Welche Signatur hat Painter::setImage? Nimmt das ein PainterPointer-Objekt entgegen so dass der Pinter auf Image implizit konvertiert wird durch den Konvertierungs-Konstruktor oder nimmt das gleich ein Image* entgegen? In dem Fall wäre PainterPointer nutzlos.

std::auto_ptr<Image> readImage();
void Painter::SetImage(std::auto_ptr<Image> image);

// ...
Painter p;
std::auto_ptr<Image> image = readImage();
p.setImage(image);

Oder direkt:

p.setImage(readImage());

Mit deinem momentanen Ansatz wird das Bild zerstört, was den Zeiger invalidiert. (snip)

Also von der Objekt-Lifetime her ist das schon in Ordnung, da das Image-Objekt bis zum Ende des while-Blocks lebt. Wenn die Methoden, die auf dem Image-Objekt arbeiten, nur innerhalb des while-Blocks aufgerufen werden (und so versteh ich den Kommentar), ist das imho schon in Ordnung, oder überseh ich was?

Painter painter;
while (...)
{
    Image image = ...;
    painter.draw(image);
    ...
}

Oder, wenn Painter nur eine Hilfsklasse fürs Zeichnen ist, warum ist dessen Instanz bereits ausserhalb der Schleife deklariert? Ich würde es in diesem Fall eher so lösen:

while (...)
{
    Image image = ...;
    Painter painter(image);
    painter.draw();
    ...
}