Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » Zeiger und Referenzen... Problem beim lernen

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
30.05.2009, 14:23 Uhr
Mentras




C++:
#include <iostream>
using namespace std;

int main() {
    int x=12,y=13;
    int *p=x;
    cout << "Speicheradresse von x: " << &x << "\n" << "Speicheradresse von y: " << &y << endl;
    cout << "Wert von x: " << x << "\n" << "Wert von y: " << y << endl;
    cout << "Speicheradresse in <p> gespeichert von <x> " << p << endl;
}



Ich versuche grad das (für mich schwere) Kapitel "Zeiger und Referenzen" zu lernen...
Beim kompilieren, kommt ständig ein Fehler
Ich hab mit dem Buch vor 1 1/2 Monat begonnen, eine 3 Wöchige Pause gemacht (Tests & Schularbeiten) und jetzt wieder begonnen...

Ich benutze die VS 2008 IDE (Professional Edition).
Könnte mir jemand den Fehler erklären (Finde den nämlich nicht. )

Wenn jemand das Kapitel versteht (Zeiger und Referenzen) wäre ich auch sehr glücklich darüber, wenn jemand es mir erklären könnte.

Was das einem bringt sowas in seine Projekte einzuführen. Ich versteh irgendwie den Sinn nicht (Ist nicht herabwertend gemeint!) Denn wenn ich den Wert einer Variable ändern will, dann mach ich das so x=3. Würde mich sehr über eine Erklärung freuen!


Lg Mentras

Dieser Post wurde am 30.05.2009 um 14:25 Uhr von Mentras editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
30.05.2009, 14:44 Uhr
Kest
saint


Musst dem Zeiger die Adresse zuweisen, nicht den Wert.

C++:
int* p = &x;

--
Wenn man einen Hufschlag hört, sollte man >Pferd< denken und nicht >Zebra<.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
30.05.2009, 14:48 Uhr
Mentras



Ärgerlich,...

Danke

Lg Mentras
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
17.06.2009, 11:43 Uhr
~arnold72
Gast


und was das für einen sinn hat..

wenn du jetzt zb einen neuen thread startest, da kannste du nur einen pointer als parameter übergeben. wenn du aber jetzt mehrere variablen übergeben willst, packst du die einfach alle in eine struktur, und übergibst dem neuen thread einfach einen pointer auf die neue struktur.

oder halt wenn du dynamisch programmierst.. wenn du zb ein array haben willst, du aber noch nicht weisst wieviele werte da rein sollen. ein statisches sieht ja so aus:

C++:
int werte[10];

da passen dann 10 werte rein. (von werte[0] bis werte[9]).
diese array kannst du nicht in der größe ändern. wenn du das array aber dynamisch machst

C++:
int anzahl = 20;
int *werte = new int[anzahl];


so kannst du die größe dynamisch zur laufzeit festsetzen, kannst das array aber immer noch ändern in der größe.

und referenzen haben mehrere daseins-berechtigungen..
zum einen kann man die ausführungsgeschwindigkeit optimieren, zum anderen kann man sich damit rückgabewerte sparen.

also zu punkt 1:
angenommen du hast diese funktion:

C++:
int addieren(int a, int b) {
   return a+b;
}



wenn du die dann aufrufst:

C++:
int x, y, ergebnis;
x = 12;
y = 3;
ergebnis = addieren(x, y);


dann erzeugt der compiler eine neue instanz von den variablen x und y. sprich er allokiert neuen speicher, und kopiert die werte aus x und y in den neuen speicher. wenn du die werte als referenz übergibst, werden die halt direkt übergeben, was natürlich schneller ist. allerdings können die variablen aber auch in der funktion verändert werden.


C++:
int aendern(int &a, int &b) {
   a *= 2;
   b *= 2;
   return a+b;
}

int x, y;
x = 10;
y = 5;
// also vorher x = 10, y = 5
aendern(x, y);
// nachher: x = 20, y = 10



manchmal ist dieser effekt gewünscht. in den meisten fällen sollen die variablen aber nicht verändert werden können. deshalb setzt man die referenzen konstant:

C++:
int addieren(const int &a, const int &b);



jetzt kann man die variablen nicht mehr ändern, hat aber immer noch den geschwindigkeitsvorteil..

soo, ich hoffe ich konnte dir ein wenig helfen..
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
17.06.2009, 12:01 Uhr
ao

(Operator)



Zitat von ~arnold72:
und referenzen haben mehrere daseins-berechtigungen..
zum einen kann man die ausführungsgeschwindigkeit optimieren ...


Das möchte ich bezweifeln, zumindest in deinem Beispiel mit int und int&.


Zitat:
dann erzeugt der compiler eine neue instanz von den variablen x und y. sprich er allokiert neuen speicher, und kopiert die werte aus x und y in den neuen speicher. wenn du die werte als referenz übergibst, ...


... sind die Referenzen lokale Objekte innerhalb der Funktion, und für diese wird genauso neuer Speicher angelegt und gefüllt.

Technisch gesehen sind Referenzen dasselbe wie Zeiger (nämlich Speicheradressen, über die ein Objekt erreicht werden kann), sie sehen nur syntaktisch anders aus. Und da auf den meisten Systemen ein int genauso groß ist wie eine Speicheradresse, bedeutet die Übergabe einer Referenz exakt denselben Aufwand wie die Übergabe eines Wertes.

Was anderes ist es mit größeren Typen (Strukturen, Klassen), die by-value zu übergeben kostet tatsächlich mehr Zeit.

Außerdem ist es (speziell bei Objekten) oft nicht möglich oder semantisch unerwünscht, eine Kopie herzustellen, so dass mit Referenzen gearbeitet werden muss.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (WinAPI, Konsole) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: