Zeiger als Paramenter und wieder zurück

ble1frei

Hallo.

void feed(long** pFatman)
{
	*pFatman = (long*)malloc(10 * sizeof(long));
}

int main(int argc, char* argv[])
{
	long* pFatman = NULL;

	feed(&pFatman);

	long test = sizeof(pFatman); // test ist nur 4, soll aber 40 sein

	free(pFatman);

	return 0;
}

Ich möchte einen Zeiger per Reference an einer Funktion übergeben, in dieser Funktion Speicher allokieren und außerhalb der Funktion die Größe des Zeigers wissen.

rüdiger

void foo(int *& i) {
  i=new int[10];
}

int main() {
  int *i;
  foo(i);
  delete []i;
}

außerhalb der Funktion die Größe des Zeigers wissen.

meinst du wirklich die größe des Zeigers? Das wär einfach sizeof(int*). Oder meinst du vielleicht die größe des allokierten Speichers? Das ist nicht möglich.

Du solltest aber vielleicht eh Container oder SmartPointer für deine Aufgabe einsetzen, da diese ua. auch den Speicher automatisch freigeben und Informationen speichern, wie viel Speicher allokiert wurde.

ble1frei

Oder meinst du vielleicht die größe des allokierten Speichers?

Genau die meine ich.

Ich frage mich allerdings, warum ich nicht die Größe des allokierten Speichers bekomme, sondern nur die Größe des Pointers?

Shlo

ble1frei schrieb:

Ich frage mich allerdings, warum ich nicht die Größe des allokierten Speichers bekomme, sondern nur die Größe des Pointers?

Wie sollte denn ein Zeiger die Größe des Speicher-Blocks auf welchen er zeigt speichern und vorallem wo? Das muss schon der User tun...

operator void

pFatman ist ein Pointer und sizeof x gibt die Größe von x zurück. Das System ist einfach nur logisch. Was sollte denn sizeof(vector<Foo>) sein? Oder sizeof(shared_ptr<Foo>)?

Ich wäre hier für einen std::vector, aber wenn du unbedingt mit new[]/delete[] arbeiten möchtest, musst du dir die Größe selbst merken.

ble1frei

Ok, ihr habt mich überzeugt, dass es auch einfacher geht, allerdings habe ich mein Programm sogut wie fertig und möchte konsequenterweise nicht noch etwas umstellen. Aber beim nächsten Programm werde ich dann mit smartpointern oder mit vector arbeiten.

Allerdings gibt es noch ein (kleines) Problem:

void feed(long** pFatman)
{
	*pFatman = (long*)malloc(10 * sizeof(long));

	for(int loop=0; loop<10; loop++)
		*pFatman[loop] = loop;   // Compiler bricht ab, Speicherfehler
}

int main(int argc, char* argv[])
{
	long* pFatman = NULL;

	feed(&pFatman);

	for(int loop=0; loop<10; loop++)
		printf("%d", pFatman[loop];

	free(pFatman);

	return 0;
}

Ich würde nun gerne das Array füllen und aus main() wieder auf die Werte zugreifen, allerdings wehrt sich der PC standhaft.

Bashar

(*pFatman)[loop]

MFK

[] bindet stärker als *, also:

(*pFatman)[loop]