Zum Inhalt springen

Empfohlene Beiträge

Geschrieben

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

Geschrieben

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?

Dein Kommentar

Du kannst jetzt schreiben und Dich später registrieren. Wenn Du ein Konto hast, melde Dich jetzt an, um unter Deinem Benutzernamen zu schreiben.

Gast
Auf dieses Thema antworten...

×   Du hast formatierten Text eingefügt.   Formatierung wiederherstellen

  Nur 75 Emojis sind erlaubt.

×   Dein Link wurde automatisch eingebettet.   Einbetten rückgängig machen und als Link darstellen

×   Dein vorheriger Inhalt wurde wiederhergestellt.   Editor leeren

×   Du kannst Bilder nicht direkt einfügen. Lade Bilder hoch oder lade sie von einer URL.

Fachinformatiker.de, 2024 by SE Internet Services

fidelogo_small.png

Schicke uns eine Nachricht!

Fachinformatiker.de ist die größte IT-Community
rund um Ausbildung, Job, Weiterbildung für IT-Fachkräfte.

Fachinformatiker.de App

Download on the App Store
Get it on Google Play

Kontakt

Hier werben?
Oder sende eine E-Mail an

Social media u. feeds

Jobboard für Fachinformatiker und IT-Fachkräfte

×
×
  • Neu erstellen...