C++ Wozu dient & dings? z.b. &n &p usw

[konnichi]

Halli hallo

Folgendes, was in aller Welt ist & Dings?

Z.b. angegeben sind int a, b, c, &k

was bringt & Zeichen? Wann und wofür wird es benutzt? Das ist irgendetwas mit der Adresse des Variablen in der Computer Arbeitsspeicher (habe ich doch kein Unsinn gesagt oder??^^), aber wirklich, ich verstehe nicht was damit gemeint ist.
Ist es möglich diese Sache irgendwie vieleicht visuell zu erklären? Weil 2 Leute habens versucht..ich check es immer noch nicht. Aber ich bin heiß drauf! Ich will es unbedingt wissen.
Eigentlich gehe ich alle Themen in c++ nach, der Reihenfolge nach, und and dieser Stelle hänge ich fest. Sehr schlimm, weil will unbedingt Fortschritte machen, kann aber wegen & nicht.
Hilfe...

 

[MasterMito]

in C++ gibt es 3 Möglichkeiten Variablen anzusprechen.
Die erste ist ganz normal.
int a = 5;
Nix wildes. mit a hast du direkt die 5. Nun könnte man allerdings auch einen Zeiger (Pointer) darauf zeigen lassen. Das geht mit:
int *a = new int(5);
Der Unterschied hierfür ist, das der Zeiger auf einen Bereich im Speicher zeigt. Wenn du nun nur a aufrufst, rufst du nicht die Zahl a auf, sondern den Ort in dem a liegt. Willst du nun auf die gespeicherte fünf kommen, musst du den Pointer dereferenzieren mittel *a kommst du an die fünf.
Möchtest du nun einen weiteren Zeiger auf den Bereich im Speicher zeigen lassen, erstellst du einen neuen Pointer und zeigst auf die Adresse. Dazu das &:
int *b = &a;

Hoffe das wahr hilfreich bzw. richtig

 

[konnichi]

oha...danke für den versuch....aber ich habs nicht kapiert...bei mir war nichts von *p= irgendetwas...nur & und so,..hmmm

 

[bullsh1t]

da ist wohl nichts zu machen. vielleicht hilft dir ein kurzes C/C++ Tutorial weiter, wenn es dich denn interessiert ... im inet sind davon etliche zu finden.

ums kurz zu machen:
& = adressoperator
* = referenzierungsoperator

int a;
&a = adresse von a
*(&a)) = a

achso ... wenn du bei einer funktion im kopf (&a) stehen hast dann ist das eine referenz ...

 

[Bay-Breeze]

Hallo konnichi,

lies dir dochmal diese wirklich einfache Erklärung durch, ich denke danach wird dir ein Licht aufgehen: Pointer Erklärung

 

[Rossibaer]

Stell dir einen Container vor. Dieser Container hat einen Inhalt. Der Container steht im Hamburger Hafen. Der Hafen hat für jeden Platz eine Nummer, um den darauf befindlichen Container schnell wieder zu finden bzw. ihn zu identifizieren. Übertragen wir das mal auf das Programmieren in C/C++:

Du hast folgendes deklariert:

GummibaerchenContainer container1;

GummibaerchenContainer = Typ des Containers und somit die Größe des Containers = Speichermenge der Variable im Arbeitsspeicher
container1 = Name des Containers = Name der Variable
&container1 = Nummer des Standplatzes des Containers, z.B. 1234 = Adresse im Arbeitspeicher

Jetzt hast du folgende Möglichkeiten um mit diesem Container etwas zu machen, entweder du sagst im Programm das der Container mit dem Namen "container1" mit Gummibärchen befüllt werden soll oder du sagst, das der Container auf dem Standplatz 1234 mit Gummibärchen befüllt werden soll.

Vielleicht hilft das etwas weiter...

 

[Darii]

Zusätzlich dient das & in C++ dazu, Referenzen zu erstellen.

Und in deinem Beispiel

 int a, b, c, &k

ist k eine Referenz und & ist kein Adressoperator.

int x = 4;
int &y = x;
y = 5; // --> x = 5

Eine Referenz ist so etwas wie ein Pointer, bloß dass sie immer initialisiert werden muss und Pointerarithmetik nicht möglich ist. Eine Java-Referenz ist übrigens etwas anderes als eine C++ Referenz, da man bei einer Java-Referenz nicht den Wert der ursprünglichen Referenz verändern kann, das obige Beispiel würde da also nicht funktionieren.

 

[MasterMito]

Hmmm.

das mit der referenz vergess ich nur allzugerne.

 

[badday]

Und & kann als bitweise AND dienen. Aber das hat mit deinem Problem nichts zu tun.

Der ganze wichtige Unterschied zwischen Zeiger und Referenzen ist der oben beschriebene: Referenzen MÜSSEN initialisiert werden.

* = referenzierungsoperator
...
*(&a)) = a

Du meinst wohl Dereferenzierungsoperator!
Und den Wert auf den a zeigt bekommst du mit *a
also kannst du z. B. (wenn a nicht const ist) (du bekommst ein Lvalue)
*a=6;
machen und dann hat das Objekt, auf das a zeigt den Wert sechs, es steht sozusagen "im Arbeitsspeicher" an der stelle auf die a zeigt.

Vielleicht noch ein konkretes Beispiel:
int a = 7; //einfache int-Variable wird definiert
int *b = &a; //ein Zeiger namens b wird definiert;nun soll unser Zeiger auf a zeigen, dafür geben wir vor dem Variablennamen (a) den Adressoperator (&) an.
*b = 2; //nun ändern wir den Wert von a, nicht den von b (b zeigt nach wie vor auf den Speicherbereich von a). Das manipulieren gelingt uns nur, indem wir "dem Computer" mitteilen, dass er die Variable ändern soll, dafür benutzen wir den Derefernzierungsoperator (*), der sozusagen die Manipulation zur Variablen weiterreicht.
Wir können auch b "ändern", ihn also auf etwas anderes zeigen lassen. Dafür darf der Zeiger aber nicht const sein (was er bei uns nicht ist).

Im übrigen solltest du auch Zeiger nach Möglichkeit unverzüglich initialisieren.
Also nicht erst int *b; schreiben und erst später *b = &a; , da es immer mal (z. B. durch bedingte Ausführung (z. B. mit if-Anweisungen)) sein kann, dass der Zeiger dann nie initialisiert wird vor der ersten Verwendung, was fiese Fehler nach sich ziehen kann.


Hoffe ich habe mich hier nicht geirrt, bitte ggf. korrigieren.

Du kannst ja einfach mal den Code posten, den du nicht verstehst, dann können wir ihn auseinandernehmen.

Gruß,

badday

 

[konnichi]

Danke für die Unterstützung.
Vieles hab ich verstanden, aber dann mit Beispielprogrammen gabs wieder Probleme.
Hier der Code:

1 #include <stdio.h>
02 
03 int main(void)
04 {
05     int messwerte [3][4];
06     int i, j = 0;
07     
08     /* Initalisierung der Feldelemente mit 0 */
09     for (i=0; i<3; i++)
10         {
11          for (j=0; j<4; j++)
12              {
13                 messwerte [i][j] = 0;
14               }
15          }
16     /* Ausgabe der Feldelemente */                    
17     for (i=0; i<3; i++)
18         {
19          for (j=0; j<4; j++)
20              {
21               printf ("Tag -> %d Messwert -> %2d: %d \n", i+1, j+1, messwerte [i][j]);
22               }
23          }
24     fflush(stdin);
25     getchar();
26     return 0;
27 }

ich verstehe die 21-te zeile nicht, was macht %d? und %2d? Und /n ist wie endl oder? Ja warum i+1 und j+1, also die ganze 21 Zeile voll unklar.
Dann noch die zeile 24 und 25, was bringen die?


Dann noch ein zweiter code, es heißt, dieser hier ist die Alternative zu dem ersten Code.
Aber ich verstehe wiederum nicht alles.

01 #include <stdio.h>
02 
03 int main(void)
04 {
05     int messwerte [3][4];
06     int i, j = 0;
07     int *pt_messwerte = &messwerte [0][0];
08     
09     /* Initalisierung der Feldelemente mit 0 */
10     for (i=0; i< 3*4; i++)
11         {
12             *(pt_messwerte + i)=0;
13         }
14     /* Ausgabe der Feldelemente */ 
15     for (i=0; i< 3*4; i++)
16         {
17             printf ("Messwert -> %2d: %d \n", i+1, *(pt_messwerte + i));
18         }
19     fflush(stdin);
20     getchar();
21     return 0;
22 }

Die Zeile 10, wieso 3*4 genommen? Das ergibt 12, ja, das ist die Feldgröße, es gibt 12 Variablen in der Matrix, soweit ist mir klar...aber was macht die 12 hier?
Dann die zeile 12, voll unklar, was da passiert. Das gleiche wieder mit Zeilen 15 und 17.

Also, wenn ich das Mal verstehe, habe ich das Gefühl, komme ich sehr weit.

Echt, vielen dank im Voraus!

 

[Stefan_Sch]

Ich habe mir den Strang nicht durchgelesen, hat mich auch nicht sonderlich interessiert, antworte aber mal auf den letzten Beitrag.

ich verstehe die 21-te zeile nicht, was macht %d? und %2d? Und /n ist wie endl oder? Ja warum i+1 und j+1, also die ganze 21 Zeile voll unklar.
Dann noch die zeile 24 und 25, was bringen die?

%d und %2d dienen der Ausgabeformatierung in printf(). %d steht für eine dezimale Zahl und %2d für eine dezimale Zahl mit 2 Cursorlängen.

Und damit ich hier nicht noch mehr schreiben muss, siehe http://www.cppreference.com/wiki/c/io/printf

Die Zeile 24 darfst du schnell wieder vergessen, weil die falsch ist. fflush() ist in C nicht für den Eingabestream definiert und sollte auch nicht verwendet werden.

Siehe auch http://www.gidnetwork.com/b-57.html

Mit der Zeile 25 hat der Programmersteller offensichtlich versucht die vorzeitige Beendigung der Konsolenanwendung zu unterbinden. Viele verwenden hier auch system(pause).

Beides solltest du nicht benutzen und die Anwendung stattdessen aus der Konsole aufrufen. Dann schließt sich nämlich auch kein Fenster!

Die Zeile 10, wieso 3*4 genommen? Das ergibt 12, ja, das ist die Feldgröße, es gibt 12 Variablen in der Matrix, soweit ist mir klar...aber was macht die 12 hier?
Dann die zeile 12, voll unklar, was da passiert. Das gleiche wieder mit Zeilen 15 und 17.

Das zweite Beispiel nutzt die Tatsache das ein zweidimensionales Array in C natürlich im Speicher nur eine eindimensionale Liste ist. Das Array ist 12 Elemente lang, deshalb 3*4 was der Compiler ohnehin bei der Kompilierung in 12 verwandelt.

*(pt_messwerte + i) = 0;

ist die Dereferenzierung des Zeigers pt_messwerte, zu erkennen an dem Stern. Mit der Zeile wird jedem Feldelement die 0 als Wert zugewiesen. i ist die Laufvariable, die von 0 bis einschließlich 11 geht, also das gesamte Array abdeckt.

Die zweite Schleife ist natürlich völlig überflüssig, aber was solls.

Nichts spektakuläres, kauf dir ein gutes C Buch und arbeite Kapitel über Zeiger durch, dann weißt du auch was Sache ist.