Hi Folks,

erst mal ne Runde Quelltext:

#include <iostream.h>

#include <conio.h>


void swap(int *x, int *y);


int main()

{

	int x = 5, y = 10;


	cout << "Main. Vor Vertauschung, x: " << x << " y: " << y << "\n";

	swap(&x,&y);

	cout << "Main. Nach Vertauschung, x: " << x << " y: " << y << "\n";

   getch ();

	return 0;


}


void swap (int *px, int *py)

{

	int temp;


	cout << "Swap. Vor Vertauschung, *px: " << *px << " *py: " << *py << "\n";


	temp = *px;

	*px = *py;

	*py = temp;


	cout << "Swap. Nach Vertauschung, *px: " << *px << " *py: " << *py << "\n";


}

Es geht nicht um die funktionsweise des Codes, die ist ja relativ simpel, es geht um die Übergabe der Adressen in die Funktion an die Zeiger.

Was ich jetzt nicht verstehe ist die Syntax bei der Parameterübergabe bzw. Parameterannahme ist in die Funktion Swap.

Ich mache doch

swap(&x,&y);

um die Adresse von x und y an die Pointer int *px, int *py zu übergeben. Jedoch verstehe ich nicht warum das so funzt denn:

int x = 5;

int * p_ptr;

*p_ptr = &x;

== Fehlermeldung - logisch

( Und dies mache ich ja theoretisch in dem Quelltext und dürfte eigentlich nicht laufen)

und

int x = 5;

int * p_ptr;

p_ptr = &x;

== läuft einwandfrei - auch logisch

Aber warum ist dass bei Paramterübergaben in Funktionen genau anderstrum?

Bitte um ne kleine Erklärung. Danke.

cu

alligator

Eigentlich hast Du Deine Frage selbst beantwortet, wenn Du nämlich genau hinschaust hast Du geschrieben:

void swap(int *x, int *y);

Das bedeutet es werden zwei Pointer auf int erzeugt (x und y).

dann war Dein Beispiel:

1) int x = 5;

2) int * p_ptr;

3) *p_ptr = &x;

was natürlich nicht klappt, weil p_ptr ein Zeiger ist und bei 3 der Zeiger dereferenziert wird, also der Inhalt der Speicherstelle auf die der Zeiger zeigt verändert werden soll. Richtig wäre p_ptr=&x; oder *p_ptr=x;

Wird ein Zeiger erzeugt, sieht es nur aus wie eine Dereferenzierung, aber in Wirklichkeit ist es eine Deklaration welche klar macht, daß p_ptr ein Zeiger sein soll!!!

int * p_ptr=&x; -> das ist es, was beim Funktionsaufruf passiert. Es wird ein Zeiger erzeugt und die Adresse von x übertragen. Es wird NICHT dereferenziert. Jeder spätere *p_ptr-Zugriff ist eine tatsächliche Dereferenzierung, weil die Variable schon existiert. Beim 1. mal wird also das * nur für die Unterscheidung (Deklaration) der Variable p_ptr als Zeigervariable verwendet!

Deshalb funktioniert auch diese Version korrekt:

int x = 5;

int * p_ptr; // Deklaration von p_ptr als Zeiger

p_ptr = &x; // Initialisieren des Zeigers mit einer Adresse

*p_ptr = x; // Beschreiben der Zeigervariable mit einem Wert vom Typ int (von x)

Reicht das als Erklärung aus?

Hi,

ah verstehe. Also müsste auch

int x =5;

int * p_ptr = &x;

tun, da es ja eine deklaration und keine Derefernezierung ist.

Wenn das jetzt so richtig ist, dann hab ichs gerafft )

cu

alligator

Genau!