Hallo,

ich habe hier mal ein Bsp-Progarmm zu Pointern, dass ich aber nicht ganz verstehe:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

punkt getGreater(punkt p1, punkt* p2). {   printf("getGreater: sizeof(p1)=%d : sizeof(p2)=%d\n",sizeof(p1),sizeof(p2));   if (p1.y >= p2->y)   {     return p1;       }   return *p2; }   punkt findMax(punkt* thePunkte, int len) {   int t=0;   punkt maxValue;     maxValue= *thePunkte;   for( t = 0 ; t < len; t++)   {     maxValue = getGreater(*thePunkte,&maxValue);//     thePunkte++;   }   return maxValue; }

Bei dem 1. Unterprogramm sind die Übergabeparametern eine struct p1 und ein Pointer p2 der auf die struct zeigt, aber beim Aufruf muss man da nicht den gleichen typ oder so nehmen? punkt p1 ist doch kein Pointer, sondern eine Struktur.

Aber beim Aufruf wird aber an der Stelle von Punkt p1, *thePunkte verwendet? * deutet ja auf Zeiger hin? Und das & hat auch was mit Zeiger zu tun oder?

& heißt ja da wird nur die Startadresse weitergegeben, aber was is da mit Startadresse gemeint?

mfg C_boy

Zu deinen Fragen:

Code :

1	maxValue = getGreater(*thePunkte,&maxValue);//

Die Funktion getGreater wird mit folgenden Parametern aufgerufen:

*thePunkte: thePunkte ist ein Zeiger und das * bedeutet, dass man den Zeiger dereferenziert. Das bedeutet, dass man mit dem arbeitet, auf das der Zeiger zeigt. Hier übergibst du also NICHT den Zeiger sondern das, auf das der Speicher zeigt.

&maxValue: maxValue ist eine Punkt-Struktur und das & bedeutet, dass du die Adresse der Struktur an die Funktion übergibst.

Wenn du noch Fragen hast, dann schreib

Lg

Dein findMax funktioniert so übrigens nur,
wenn das Array min. ein Element hat.

Sonst gibts hier

Code cpp:

1	maxValue= *thePunkte;

ein Problem.

Sollte man vllt. zuerst noch mit einem if abfragen,
ob len>0 ist.

Gruß

Ich danke euch beiden.

Die Adressen von maxValue sind ja float x und float y oder? Und man darum muss man "&maxvalue" schreiben, da maxValue eine Struktur ist und die Adressen x und y enthält(wenn oben das stimmt). Man übergibt das dann dem pointer p2 der auf die Struct zeigt und mittels "p2->y" auf float y.

Und bei *thePunkte übergibt man den Wert zu der struktur p1 und man schaut halt dann was größer ist mittels der if().

Aber was ist wenn man "int *pa = &a" schreibt, dann zeigt pa auf die Adresse von a?

Angenommen a ist ein Integer, was hat dies dann für Adressen? Integer hat ja 4 Bytes und die Zahl verteilt sich auf diese Bytes. 1 Byte = 8Bit.

Und wie muss man jetzt schreiben das man eine Variable b eine Wert der in einer Adresse steht zuweist?

mfg C_boy

Hi

da scheints einige grundlegene Verständnisprobleme zu geben.

Code cpp:

1 2 3

int a; int *b; b = &a;

Hier wird zuerst ein int gemacht.
(Auf 32bit-Rechnern) hat das int 4 Byte = 32 bit.

Der Abeitsspeicher hat durchnummerierte Speicherplätze zu je 1 Byte = 8bit
Einzelne Bit gibts nicht.
Ein int belegt jetzt 4 dieser Plätze, alle hintereinander natürlich
(also zB. Nummern 2400, 2401, 2402, 2403).
Die Adresse vom int (mit & abrufbar) gibt die erste Speicherstelle an (stark vereinfacht gesagt).
Also 2400.
Mit sizeof bekommt man heraus, wieviel Byte die Variable hat (4);
daraus ergibt sich, wieviel Stellen danach noch belegt sind.

Danach wird ein "int *b" gemacht.
Ein Pointer auf ein int.
Unabhängig ob int*, float*, xyz* sind Pointer selber immer int,
die dazu gedacht sind, so eine Arbeitsspeicheradresse zu speichern.
Die ist nun mal keine Kommazahl (float) und kein xyz, die ist immer int.
Ob es int*, float* oder sonstwas ist, gobt an,
ob es die Adresse von einem int, float etc. werden soll.

Mit "b=&a" weise ich jetzt dem int vom Pointer die Adresse von a zu.
2400.
Da es ein "int*" ist und ein int 4 Byte hat, ist dem Computer klar,
das 2401, 2402 und 2403 auch noch dazugehören.

Und was einen Pointer eben zum Pointer macht:
Wenn man jetzt "*b" als Variable verwendet,
wird nicht mit dem Pointer-int gearbeitet, sondern mit dem int,
dessen Adresse im Pointer gespeichert ist.

Ich danke dir, jetzt ist es mir verständlicher aber:

Wenn ich z.B. schreibe:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <stdio.h>   int main() {   int a=5;   int *b;     b=&a;     printf("%d\n",b);//hier wird eine 7-stellige zahl ausgegeben, also die Adresse von a und in dieser Adresse steht der Wert 5?   printf("%d\n",&b);//hier wird eine 7-stellige zahl ausgegeben, also die Adresse von b   printf("%d\n",*b);//hier wird der Wert 5, der in der Adresse(also die adresse die beim 1. printf ausgegeben wird) von a steht ausgegeben     return(0); }

Stimmt das was in den Comments steht?

Für was braucht man den z.B die Adressen von einem integer oder so? Was bringt das?

in deinem Code ist es nur eine Verständnisübung.

Anwendungsfälle in der Praxis gibts viele.

Ein häufiger und einfach zu erklärender:
Wenn du sowas hast:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

void funktion(int a, int b, int c) {     a = 1;     b = 2;     c = 3; }   int main() {     int a, b, c;     a = 0;     b = 0;     c = 0;       funktion(a, b, c);       printf("%d %d %d\n", a, b, c); }

Was wird da ausgegeben?
0 0 0

Grund: Der Funktion werden Kopien der Werte übergeben.
Grundsätzlich sind Parameter immer Kopien.
In der Funktion weist du den Kopien,
die am Funktionsende wieder verschwinden, Werte zu.
Die Variablen in main bleiben auf 0.

Wenn man die Variablenänderungen ins main übernehmen möchte,
kann man das so machen:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

void funktion(int *a, int *b, int *c) {     *a = 1;     *b = 2;     *c = 3; }   int main() {     int a, b, c;     a = 0;     b = 0;     c = 0;       funktion(&a, &b, &c);       printf("%d %d %d\n", a, b, c); }

Hier wird eine Kopie der Adresse übergeben.
Die zeigt aber noch immer auf die gleiche Speicherstelle...
Ausgegeben wird 1 2 3

Wenn du jetzt denkst "für so was gibts doch return":
Return hat das Problem, dass es nur einen einzelnen Wert nehmen kann.
Was macht man mit 3? Oder 10?

Was macht man mit 3? Oder 10?

Ne Struktur basteln, die füllen und zurückgeben

Möglich, aber noch umständlicher.
Und das mit der Funktion war ja auch nur ein Beispiel.

P braucht man allgemein immer, wenn man irgendetwas Anderem
Zugriff auf eigene Variablen geben will.
Weiters ist jedes Array ein Pointer usw. usw.

Das war ja auch nur ein Witz Deine Vorlage war so gut, ich konnt einfach nich anders Von daher gleich vergessen

Extra für die Rückgabe eine Struktur oder sogar ne Klasse zu schreiben, die sonst keinen Sinn hat, ist Quatsch und macht auch keiner.