[SOLVED] dynamische Erzeugung eines Objekts

mbu

Hallo,

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.

drakon

Einfach img_y, img_u, img_v benutzen.

Nexus

drakon schrieb:

Einfach img_y, img_u, img_v benutzen.

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

mbu

drakon schrieb:

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.

Nexus

Die Problematik ist nicht zu unterschätzen, das verstehe ich ehrlich gesagt selbst nicht ganz. Die Zeiger sollten ja ihre Adresse auch nach Beenden der Funktion noch haben...

#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 (!!)
}

drakon

Sorry, nicht richtig gelesen.

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.

mbu

Hm, ich habe gerade noch was anderes ausprobiert:

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.

Der Pointer wird ja auch als Value übergeben. Wie soll der sich da ändern?
Du musst den schon als Refernz übergeben, wenn du das wirklich so machen willst, also
void erstelle_bild( Image*& img_y, Image*& img_u, Image*& img_v )

drakon

mbu schrieb:

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.

mbu

Super, alles klar. Dass der Pointer by value übergeben wird, macht natürlich Sinn. Da war also der Denkfehler. Vielen Dank.

Nexus

Wieder was Neues gelernt, und ich dachte, ich würde mich mit Zeigern auskennen

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