ich möchte in einer Funktion ein Bild erstellen. Die Größe des Bildes ist aber erst zur Laufzeit bekannt. Dafür habe ich mir nun eine Funktion erstellt. Das ganze läuft vom Prinzip her folgendermaßen:

void erstelle_bild( /* einige Parameter */, Image* img_y, Image* img_u, Image* img_v )
{
  /* mach dies und das */

  img_y = new Image( rows, cols );
  img_u = new Image( rows, cols );
  img_v = new Image( rows, cols );

  /* an dieser Stelle sind die Zeiger auf die Bilder nutzbar */
}

int main(int argc, char** argv)
{
  Image* img_y = NULL;
  Image* img_u = NULL;
  Image* img_v = NULL;

  erstelle_bild( /* einige Parameter */, img_y, img_u, img_v );

  /* hier zeigen die Pointer img_y, img_u, img_v immernoch auf NULL */
}

Wo ist mein Denkfehler? Was muss ich ändern, damit ich auf die Speicherbereiche der Bilder nach der Erstellung auch noch in der main zugreifen kann?

Vielen Dank im voraus. mbu.

Einfach img_y, img_u, img_v benutzen.

Das hat er ja getan, mit dem Ergebnis, immer noch Nullzeiger zu haben.

Einfach img_y, img_u, img_v benutzen.

Entschuldige, aber kann Dir da nicht ganz folgen. An welcher Stelle soll ich das benutzen? In der main? Aber die kann ich ja nicht benutzen, wenn die Zeiger auf NULL zeigen.

#include <iostream>

void func(int *x, int *y)
{
	x = new int(3);
	y = new int(5);
	std::cout << x << " " << y << std::endl;    // Ausgabe: 00063CE0 00063D00
}

int main()
{
	int *a = NULL, *b = NULL;
	func(a, b);
	std::cout << a << " " << b << std::endl;    // Ausgabe: 00000000 00000000 (!!)
}

Hier wäre mal ein Doppelpointer angebracht.

void erstelle_bild( /* einige Parameter */, Image** img_y, Image** img_u, Image** img_v )
{
  /* mach dies und das */

  *img_y = new Image( rows, cols );
  *img_u = new Image( rows, cols );
  *img_v = new Image( rows, cols );

  /* an dieser Stelle sind die Zeiger auf die Bilder nutzbar */
}

int main(int argc, char** argv)
{
  Image* img_y = NULL;
  Image* img_u = NULL;
  Image* img_v = NULL;

  erstelle_bild( /* einige Parameter */, &img_y, &img_u, &img_v );

  /* hier zeigen die Pointer img_y, img_u, img_v immernoch auf NULL */
}

EDIT:

Nexus. Nein.
Du übergibst ja eine einen Zeiger per value und der ist 0. Also wird kopiert.
Schön nun speicherst du in einem Kopieren Objekt einen Zeiger auf Image. Das hat aber keine Auswirkung auf den Zeiger, den du mal kopiert hast. Also brauchst du einen Zeiger, weil du ja nicht per value, sondern ber reference übergeben willst. Und das geht mit Pointer genau so, wie immer. Mit einem Pointer. Sieht komisch aus, ist aber so.

void erstelle_bild( /* einige Parameter */, Image*& img_y, Image*& img_u, Image*& img_v )
{
  /* mach dies und das */

  img_y = new Image( rows, cols );
  img_u = new Image( rows, cols );
  img_v = new Image( rows, cols );

  /* an dieser Stelle sind die Zeiger auf die Bilder nutzbar */
}

int main(int argc, char** argv)
{
  Image* img_y = NULL;
  Image* img_u = NULL;
  Image* img_v = NULL;

  erstelle_bild( /* einige Parameter */, img_y, img_u, img_v );

  /* hier zeigen die Pointer img_y, img_u, img_v immernoch auf NULL */
}

Ich habe sozusagen eine Referenz auf einen Pointer erstellt. Damit funktioniert das ganze auch. Allerdings sieht der Parameter Image& img_y* etwas eigenartig aus.

Ich habe sozusagen eine Referenz auf einen Pointer erstellt. Damit funktioniert das ganze auch. Allerdings sieht der Parameter Image& img_y* etwas eigenartig aus.

Genau. Und wenn du die Begrünung haben willst, siehe mein Edit von oben oder auch Jockelx.
Referenzen sind hier sogar noch schöner, als Pointer. Ist im Prinzip aber Dasselbe.

Aber ehrlich gesagt finde ich Doppelpointer schöner als Pointer auf Referenz (auch wenn man ihn explizit dereferenzieren muss).