kostenloser Webspace werbefrei: lima-city


Pointer, Referenzen

lima-cityForumProgrammiersprachenC/C++ und D

  1. Autor dieses Themas

    c*a

    Hallo,

    ich bin nun grade dabei von Java auf C++ umzusteigen.

    Also in Java werden an Funktionen die Referenzen von Objekten übergeben und zwar immer.
    In C++ werden standardmäßig Kopien an die Funktionen übergegen. Richtig?

    Aber wenn ich jetzt will, dass eine Funktion ein Objekt direkt bearbeitet, soll ich dann Pointer (*) oder Referenzen (&) nehmen?

    Wofür sind diese Referenzen überhaupt gut?

    Und was ist der Witz dabei, dass man Pointer mit diesem * deklariert, also so

    int* i;

    und dann wieder mit dem * and den Inhalt kommt? Warum wurde das so gewählt, ich verstehe da die Logik nicht, die da dahintersteckt?

    Z. B. geht so was:
    int h = 2;
    int *i = &h;


    aber so was nicht:

    int h = 2;
    int *i;
    *i = &h;


    und das ist doch nun wirklich total unlogisch!!! Mir ist schon klar warum das technisch nicht geht, aber nicht warum das Design der Syntax so verwirrend ist.

    Vielleicht erklärt es mir jemand.
    DANKE
  2. Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!

    lima-city: Gratis werbefreier Webspace für deine eigene Homepage

  3. Für dein Vorhaben wäre meiner Meinung nach ein Pointer geeignet.
    Auf die Funktion kannst du dann mit dem Operator "->" zugreifen.
    Soviel ich weiß, gibt's bei Java nur den guten alten Punkt, und
    nicht wie bei C++ die drei verschiedenen Operatoren ('.' , '::' , '->')
    Jedoch finde ich das nicht verwirrend, im Gegenteil.
    Das mag für _dich_ unlogisch erscheinen, aber für Menschen,
    die mit C++ coden ist das sehr logisch :)
    Zu dem zweiten Code-Block, 3. Zeile:
    Mach den Stern einfach weg und es sollte gehen :)
    int  a     = 5;
    int *ptr; // Wie gesagt, mach lieber |int *ptr = NULL;| draus
    ptr        = &a;
    std::cout << "Der Wert von ptr ist: " << *ptr << std::endl;

    Wenn du Pointer deklarierst, solltest du sie gleich mit NULL definieren,
    da es sonst zu Problemen kommen könnte *hust*
    Wenn du den Wert ausgeben willst, auf den der Pointer zeigt,
    musst du dereferenzieren, indem du den Stern bei der Ausgabe
    stehen lässt. Wenn du das nicht tust, wird lediglich die Adresse
    ausgegeben.

    Ansonsten würde ich dir folgende Links empfehlen:
    http://www.mathematik.uni-marburg.de/~cpp/pointer/index.html
    http://publib.boulder.ibm.com/infocenter/macxhelp/v6v81/index.jsp?topic=/com.ibm.vacpp6m.doc/language/ref/clrc05cplr205.htm
    http://de.wikibooks.org/wiki/C++-Programmierung:_Zeiger

    Beitrag geaendert: 22.2.2007 9:45:17 von z3r0c00l
  4. Referenzen wurden doch gerade erfunden um Pointer abzuschaffen.. -.-"

    Referenzen sind sowas wie statsiche Pointer, sie können,, einmal an ein Objekt, eine Variable oder ähnliches gebunden, nciht mehr gelöst werden. Deshalb auch nicht auf leeren Speicher zeigen. Demnach: Weniger fehleranfällig.

    Vielleicht finde ich den Artikel über pointer und Referenzen nochmal wieder..nimm auf jedenfall...AUF JEDENFALL... Referenzen..^^(Meine meinung..)

    Nicht der Artikel, den ich meinte.. aber doch ein kleiner Quote:


    Zeiger

    Früher gab es keine Referenzen, sondern nur Zeiger. Da Zeiger aber recht kompliziert zu handhaben sind und auch viele Tücken haben, wurden Referenzen eingeführt. Referenzen sind vereinfachte Zeiger. Ein Zeiger an sich verhält sich ähnlich wie eine Referenz, allerdings mit 2 wesentlichen Unterschieden

    1. ein Zeiger kann ungültig sein. Eine Referenz ist immer an einen Wert gebunden. Zeiger sind das nicht. Zeiger können undefiniert sein, zB int* p; - hier zeigt p irgendwo hin. Wenn wir ihn jetzt ansprechen *p=3; erzeugen wir undefiniertes Verhalten (also meistens einen Absturz. Es gibt auch NULL Zeiger, diese zeigen auf 0 und somit als ungültig gekennzeichnet. int* p=0;.

    2. ein Zeiger kann 'wandern'. Mann kann einen Zeiger ganz oft auf verschiedene Sachen zeigen lassen. zB wenn man 10 int Variablen hintereinander hat (Array), kann man ganz einfach in einer Schleife mit einem Zeiger alle 10 int Variablen ansprechen.

    Quelle: http://tutorial.schornboeck.net/zeiger.htm


    Dieser Artikel dürfte der gesuchte sein:
    http://www.techfak.uni-bielefeld.de/~clange/Notizen_zu_C++.htm#_Toc48197516

    (Wer sucht, der findet..(mesitens..^^))

    Beitrag geaendert: 22.2.2007 13:37:54 von adrians
  5. Autor dieses Themas

    c*a

    Jedoch finde ich das nicht verwirrend, im Gegenteil.
    Das mag für _dich_ unlogisch erscheinen, aber für Menschen,
    die mit C++ coden ist das sehr logisch :)


    Ja, in diesem Stadium bin ich noch nicht angelangt.

    Wenn du Pointer deklarierst, solltest du sie gleich mit NULL definieren,
    da es sonst zu Problemen kommen könnte *hust*

    Warum eigentlich? Solange dem Pointer nur ein Wert zugewiesen wird, bevor er benutzt wird, sollte es doch egal sein, oder?

    AUF JEDENFALL... Referenzen..^^(Meine meinung..)

    Mmmh in den meisten Sourcecodes sehe ich selten Referenzen, dafür Pointer ohne Ende. Also die Profis scheinen Pointer zu nehmen, vielleicht weil sie schneller sind? Oder weil C-Erfahrung den Stil verdirbt?

    Für mich ist C++ die komischste Sprache der Welt, gerade weil man wegen dem ganzen C-Ballast alles doppelt hat. :mad: :mad: C finde ich schon ein bisschen unkomfortabel aber zumindest in sich logisch.

    Da sich gestern abend noch ergeben hat, dass man auch unter C++/C nicht gescheit arithmetische Überläufe erkennen (darf man in Assembler schreiben) kann, ohne Riesenprobleme mit der Portabilität zu bekommen, seh ich auch nicht so wirklich den Grund warum ich mir das antue...

    Fast jeder Prozessor setzt Carry-Flag und Sign-Flag, das hätten die doch mal in die Standardbibliothek aufnehmen können. :mad: :mad: :mad:
  6. Hi

    Also du hast oben etwas falsch verstanden:


    Z. B. geht so was:
    int h = 2;
    int *i = &h;


    aber so was nicht:

    int h = 2;
    int *i;
    *i = &h;


    Besser du schreibst:

    int h = 2;
    int* i = &h;


    (beachte die stellung des *)

    int bedeutet ja wie bekannt: der Datentyp Integer.
    int* bedeutet der Typ "Zeiger auf Interger Wert".

    Somit macht es keinen Sinn das hier zu machen: *i.

    Ich habe gerade keinen C++ Compiler zur Hand (nur das C++ Buch von Bjarne Stroustrup - Erfinder von C++ :wink:).

    Aber teste mal das hier:

    int h = 2;
    int* i;
    i = &h;


    Weil das würde Sinn machen :wink:

    Gruß Tobi

    EDIT: VERGESST BITTE ALLES WAS ICH GESCHRIEBEN HABE ICH HABE NENN GAAAAAAAAAAAAANZ WICHTIOGEN SATZ IM ERSTEN POSTING ÜBERLESEN *schäm*

    Edit2:

    Ok schau dir mal dieses Beispiel an:

    int h=2;
    
      int g = 3;
    
      int* i;
    
      i = &h;
    
      cout << *i;
    
      g = *i;
    
      cout << g;


    Damit müsste es jetzt wirklich klar sein! Du kannst *i nichts zuweisen. Um diesen Wert zu verändern brauchst du ja nur h einen anderen Wert geben da ja i auf h zeigt! i ist nunmal vom Datentyp her ein Zeiger und daher kann ihm auch nur eine Adresse zugeordnet werden und kein Integer Wert.

    Gruß Tobi


    Beitrag geaendert: 22.2.2007 21:45:27 von ttobsen

    Beitrag geaendert: 22.2.2007 21:49:36 von ttobsen
  7. Autor dieses Themas

    c*a

    @ttobsen:

    OK,

    soweit ist das klar.

    Den Stern bei der Deklaration hinter den Typ zu stellen, macht sehr viel mehr Sinn, als ihn vor die Variable zu stellen (auch wenn die meisten Bücher schreiben, dass es egal ist, solange man nur konsistent bleibt.)

    Wenn man den Stern nämlich vor den Variablennamen stellt, könnte man sich auf den Standpunkt stellen: "Bei int *i; deklarieren wir keinen Pointer, sondern einen Integer *i und durch Weglassen des Sterns gelangt man an seine Adresse."
    Z. B. ist es ja erlaubt sowas wie *i = 4; zu schreiben, wenn i auf eine anständige Adresse zeigt, in die man schreiben darf.

    ABER wie gesagt hört das dabei auf, dass sowas wie
    int h = 4;
    int *i = &h; //nanu einem Integer wird eine Adresse zugewiesen???

    richtig ist.

    Und natürlich, dass *i nur ein Integer "ist", wenn es auf einen Integer zeigt.

    Ich hab halt gedacht, dass es einen vernünftigen Grund gibt, warum die Bezeichnungen so gewählt wurden und ich sehe jetzt, dass es keinen gibt.
    Deklarationen wie "int *i" oder gar "int h, i, *j, k;" sollte es nicht geben, wenn man das Design der Syntax durchdacht hätte. Und ich glaube auch, dass es zum Verstehen einfacher wäre, Pointer am besten überhaupt nicht mit dem selben Zeichen zu deklarieren, das man auch zur Dereferenzierung von Pointern benutzt.
  8. Also bitte :>
    Ob du nun |int* a| oder |int *a| schreibst, macht imo keinen Unterschied =)
    Nur weil du noch nicht sehr viel Ahnung von C++ hast (ist nicht böse gemeint),
    musst du sie nich schlechtmachen ala "Total unlogisch/Immer dieser C-Ballast/usw."
    und |int *i| ist kein normaler Integer sondern ein Zeiger auf einen Integer-Wert.
    Deswegen kann ihm auch eine Adresse zugewiesen werden, was ist da so schwer?
    Ganz ehrlich: Wenn es dir zu kompliziert ist, dann sag das einfach und zweifel nicht an der Logik und dem Sinn der Syntax oder bleib bei Java :)
    Ich für meinen Teil finde die Sprache sehr gut und an die Syntax habe ich mich gewöhnt, das kommt mit der Zeit.
  9. Autor dieses Themas

    c*a

    und |int *i| ist kein normaler Integer sondern ein Zeiger auf einen Integer-Wert.
    Deswegen kann ihm auch eine Adresse zugewiesen werden, was ist da so schwer?

    Mein Gott!!!!!
    Das ist gar nicht schwer. Das versteht jeder (selbst du :lol: !) und ich verstehe es auch.

    Man kann es schlucken, akzeptieren. Man kann sich dran gewöhnen, aber man kann es nicht verstehen. Ist ungefähr so als ob du verstehen wolltest warum man im Englischen Wörter anders ausspricht als man sie schreibt.
    => Unlogisch und das lass ich mir nicht nehmen :biggrin:

    Ein Code sagt mehr als tausend Worte:
    int main (int argc, char *argv[]){
                int a, *b = &a, d, *c = &d, &e = *c, f;
                b = &a;
                *c = e;
                d = 2;
                *b = 3;
                a = 5;
                f = a**b**c*d*e;
                cout << f << endl;
                cin.get();
                return 0;
         }


    Na, was kommt raus?

    Ich für meinen Teil finde die Sprache sehr gut und an die Syntax habe ich mich gewöhnt, das kommt mit der Zeit.

    "gewöhnt" ist das richtige Wort.
  10. Mein Gott!!!!!

    Jetzt zieh den lieben Gott doch bitte nicht rein :>

    ---
    Das ist gar nicht schwer. Das versteht jeder (selbst du !) und ich verstehe es auch.


    aber man kann es nicht verstehen

    N/C
    ---
    Ist ungefähr so als ob du verstehen wolltest warum man im Englischen Wörter anders ausspricht als man sie schreibt.

    Das ist im Französischen so und über die Sprache brauchen wir uns gar nicht zu unterhalten :)

    Hättest du deinen Code richtig eingerückt und dieses schreckliche K&R nicht verwendet, ist das ganze sehr simpel :)
    Wenn du glaubst, du könntest mich mit einem Zeiger auf einen Zeiger, bzw. der Multiplikation mit dem dereferenzierten Wert überfordern, irrst du dich :P
    Und wenn ich mich nicht ganz irre, kommt da 200 raus ;)

    Zuerst wird a (5) mit dem dereferenzierten Wert von b (5) multipliziert.
    Das gibt also schonmal 25.
    Nun wird dieses Produkt mit dem dereferenzierten Wert von c (2) multipliziert.
    Das wären dann schon 50.
    Jetzt wird das ganze mit d (2) multiplizert.
    Das wäre wiederum 100.
    Nun wird diese Zahl mit e (2) multipliziert.
    Dann kommen wir auf 200.
    :-)





    Beitrag geaendert: 24.2.2007 9:54:47 von z3r0c00l
  11. Autor dieses Themas

    c*a

    Hättest du deinen Code richtig eingerückt

    Ach es gibt da für dich ein richtig und falsch wie man seinen C++ Code schreibt? Ich hätte jetzt wirklich gedacht, dass du die Einstellung "compilierbar = richtig" hast.

    Dann musst du auch akzeptieren, dass ich es als komisch ansehe int *i zu schreiben, anstatt int* i.

    Das ist gar nicht schwer. Das versteht jeder (selbst du !) und ich verstehe es auch.



    aber man kann es nicht verstehen


    Das eine verstehen war kursiv! Das macht einen Unterschied!

    Warum wird denn nun für Deklaration von Pointern das selbe Zeichen wie für die Multiplikation und die Dereferenzierung von Pointern benutzt? Wenn du mir einen Grund dafür nennen kannst, nehme ich das mit unlogisch zurück.

    Und wenn ich mich nicht ganz irre, kommt da 200 raus

    Wir wissen jetzt eigentlich nur: Du kannst einen Editor benutzen, beherschst Kopieren&Einfügen und hast ein C-Compiler...
    Nein, nein, ich glaubs dir ja, dass du darauf selbst gekommen bist.;)

    P. S.: Die Leute, die BRAINF*CK schlecht machen, haben doch auch nur zu wenig Programmiererfahrung damit! :biggrin:
  12. Ach es gibt da für dich ein richtig und falsch wie man seinen C++ Code schreibt? Ich hätte jetzt wirklich gedacht, dass du die Einstellung 'compilierbar = richtig' hast.


    Ob es compilierbar ist, ist eine Sache. Ob es lesbar ist, ist eine ganz andere, durchaus wichtige Sache. Man(n) sollte den Code stets lesbar halten, das schadet niemandem, ganz im Gegenteil, jeder hat einen Vorteil davon :)

    Dann musst du auch akzeptieren, dass ich es als komisch ansehe int *i zu schreiben, anstatt int* i.


    imo sind das zwei verschiedene Paar Schuhe (Coding-Stil und "Logik") ^^

    Warum wird denn nun für Deklaration von Pointern das selbe Zeichen wie für die Multiplikation und die Dereferenzierung von Pointern benutzt? Wenn du mir einen Grund dafür nennen kannst, nehme ich das mit unlogisch zurück.


    Du fragst gerade den falschen^^
    Ich bin selbst nicht der größte Experte, wenn's um C++ geht, aber mir ist die Sprache einfach ans Herz gewachsen :)
    Deswegen gilt es für mich auch, sie zu 'verteidigen'...
    Du fragst wieso? Ein Grund wäre folgender:
    * (Deklaration) Kann man als Punkt (point) sehen und er zeigt auf etwas (pointer) - Nicht umsonst
    * (Multiplikation) Wird in der Mathematik verwendet
    * (Dereferenzierung) Ist eng mit den oben genannten Grund verbunden. Es zeigt auf den Wert, nicht auf die Adresse, die man erhält, wenn man das '*' weglässt

    P. S.: Die Leute, die BRAINF*CK schlecht machen, haben doch auch nur zu wenig Programmiererfahrung damit!

    :D

    Beitrag geaendert: 26.2.2007 20:50:30 von z3r0c00l
  13. Autor dieses Themas

    c*a

    Man(n) sollte den Code stets lesbar halten

    Frau nicht?:biggrin:

    Ich bin selbst nicht der größte Experte, wenn's um C++ geht, aber mir ist die Sprache einfach ans Herz gewachsen :)
    Deswegen gilt es für mich auch, sie zu 'verteidigen'...


    Irgendwie ist mir auch Java ans Herz gewachsen, trotzdem würde ich immer zugeben, dass sie viele Macken (z. B. keine unsigned-Arithmetic. *toc, toc*) hat, jawohl.

    Ich hatte vielleicht während meines ganzen Java-Programmieren, 2-3 mal einen richtigen Runtime-Fehler. Ansonsten nur Syntax oder logische Fehler. Da sieht der Alltag eines C++ Programmierers sicher anders aus.

    Ich hab kein Problem damit, dass C++ hardwarenah ist, oder dass es kompliziertere Features wie das Überladen von Operatoren oder Vererbung von mehreren Klassen gibt... usw.

    Ich denke halt, dass gewisse Dinge unnötig kompliziert sind, was bestimmt damit zusammenhängt, dass C++ unbedingt 100%-ige Abwärtskompatibilität mit C haben musste (was Stroustrup [richtig?] garnicht wollte, aber die C-Leute haben sich durchgesetzt).

    Und so langsam sehen die Leute auch ein, dass C++ für gewisse Anwendung (z. B. Web) einfach Overkill ist und nehmen dann Spezialsprachen. Vll wird sich dieser Trend ja noch fortsetzten...

    Also von mir aus sind wir hier fertig.
  14. hannover-liga

    hannover-liga hat kostenlosen Webspace.

    cga schrieb:
    Aber wenn ich jetzt will, dass eine Funktion ein Objekt direkt bearbeitet, soll ich dann Pointer (*) oder Referenzen (&) nehmen?

    Kommt darauf an, was du machen willst. Bei solchen Beispielen, wie sie hier aufgeführt sind, ist das eigentlich völlig egal, Referenzen wären aber trotzdem die "richtigere" Entscheidung.


    z3r0c00l schrieb:
    Wenn du Pointer deklarierst, solltest du sie gleich mit NULL definieren,
    da es sonst zu Problemen kommen könnte *hust*

    Nach einem delete sollte man den Pointern auch wieder auf NULL zuweisen.


    adrians schrieb:
    Referenzen wurden doch gerade erfunden um Pointer abzuschaffen.. -.-'

    Ich hoffe, dass sollte wirklich ein Witz sein ;-)


    adrians schrieb:
    Referenzen sind sowas wie statsiche Pointer, sie können,, einmal an ein Objekt, eine Variable oder ähnliches gebunden, nciht mehr gelöst werden. Deshalb auch nicht auf leeren Speicher zeigen. Demnach: Weniger fehleranfällig.

    Referenzen weisen den Compiler an, den gleichen Speicherplatz wie die ursprüngliche Variable zu benutzen. Mit Zeigern hat das überhaupt nichts zu tun, das ganze Konzept hinter Zeigern und Referenzen ist ein grundlegend anderes.
    Der von dir kopierte Artikel ist übrigens das blödsinnigste, was ich zu dem Thema Zeiger und Referenzen jemals gelesen habe.


    cga schrieb:
    Wenn du Pointer deklarierst, solltest du sie gleich mit NULL definieren,
    da es sonst zu Problemen kommen könnte *hust*

    Warum eigentlich? Solange dem Pointer nur ein Wert zugewiesen wird, bevor er benutzt wird, sollte es doch egal sein, oder?

    Operationen auf ungültige Zeiger haben meist eine Exception zufolge. Von daher ist z3r0c00ls Ratschlag berechtigt.


    cga schrieb:
    Mmmh in den meisten Sourcecodes sehe ich selten Referenzen, dafür Pointer ohne Ende. Also die Profis scheinen Pointer zu nehmen, vielleicht weil sie schneller sind? Oder weil C-Erfahrung den Stil verdirbt?

    Pointer sind einfach flexibler. Und da meist komplexe Dinge damit angestellt werden, für die Referenzen weder brauchbar noch geschaffen sind, sieht man öfter Pointer als Referenzen. Allerdings ist es auch so, dass oft Zeiger benutzt werden, wo Referenzen geeigneter wären. Musst dir halt mal bessere Code-Beispiele anschauen.


    cga schrieb:
    Warum wird denn nun für Deklaration von Pointern das selbe Zeichen wie für die Multiplikation und die Dereferenzierung von Pointern benutzt? Wenn du mir einen Grund dafür nennen kannst, nehme ich das mit unlogisch zurück.

    Es gibt nun mal nicht ewig viele Sonderzeichen. C ist damals aus B hervor gegangen, welches wiederum auch für irgendeine alte PDP-Kiste von DEC konzipiert war. Möglicherweise gab es auf genau dieser Maschine gar keine weiteren Sonderzeichen, so dass man einige doppelt verwenden musste. * ist ja nicht das einzige Beispiel dafür: & | ( ) ! = / sind ja auch Zeichen, die mehrere Bedeutungen haben.


    cga schrieb:
    Und so langsam sehen die Leute auch ein, dass C++ für gewisse Anwendung (z. B. Web) einfach Overkill ist und nehmen dann Spezialsprachen.

    Genau, das mache ich auch. Ich nehm dann die Spezialsprache C ;-)


    Wegen der Diskussion, wo der Stern hingehört noch was...
    Ich schreibe das so:
    int * i;
    Finde ich übersichtlicher.
  15. Autor dieses Themas

    c*a

    Referenzen weisen den Compiler an, den gleichen Speicherplatz wie die ursprüngliche Variable zu benutzen.

    Es wird doch kein neuer Speicherplatz zugewiesen, wenn ich eine Referenz deklariere!!!

    Und Pointer sind doch auch typensicher (d. h. er speichert auch, wie gross das Objekt ist, auf das der Pointer zeigt)!!

    Also von daher stimmt das für mich, was adrians sagt.

    Musst dir halt mal bessere Code-Beispiele anschauen.

    Also nicht der Windows NT Sourcecode :biggrin: ? Nee im Ernst, das war Code von bekannten Opensource-Programmmen!!

    C ist damals aus B hervor gegangen, welches wiederum auch für irgendeine alte PDP-Kiste von DEC konzipiert war.

    Immer dieser Ballast.;) O nein ich hab das B-Wort gesagt!!

    Genau, das mache ich auch. Ich nehm dann die Spezialsprache C

    Das möcht ich sehen, wo kann ich deine Werke betrachten?
  16. c*********c


    cga schrieb:
    [..]
    Und Pointer sind doch auch typensicher (d. h. er speichert auch, wie gross das Objekt ist, auf das der Pointer zeigt)!!


    Wenn das so wäre, würden keine wilden Zeiger mehr die armen C-Programmierer in ihren Al(b|t)träumen heimsuchen ^^

    Ein Pointer bezeichnet einen Speicherbereich variabler Grösse (da hardwareabhängig). Die besonderheit liegt lediglich darin, dass der Wert auf einen anderen Speicherbereich im Ram zeigt.
    //edit: Theoretisch *zeigt* jede andere Variable (sofern ihr Wert ungleich NULL ist) ebenfalls auf einen Speicherbereich. Dieser kann aber meist nicht ausgelesen werden, da der Speicherbereich ausserhalb des eigenen liegt. Das Betriebssystem würde das evtl. mit einem "undefinierten Verhalten" quittieren. //ende-edit
    Zu der Typensicherheit: Pointer können ebenfalls gecastet werden. Häufiges Beispiel: der void-Zeiger.

    Beitrag geaendert: 28.2.2007 21:21:55 von compactdisc
  17. Nach einem delete sollte man den Pointern auch wieder auf NULL zuweisen.


    Stimmt, sonst würde es ja wieder zu einem "wilden" Zeiger kommen.
    Kleine Korrektur am Rande:
    Entweder "auch wieder NULL zuweisen" oder "auch wieder auf NULL bringen\setzen\stellen"
    ^^

    Beitrag geaendert: 28.2.2007 22:32:15 von z3r0c00l
  18. hannover-liga

    hannover-liga hat kostenlosen Webspace.

    cga schrieb:
    Referenzen weisen den Compiler an, den gleichen Speicherplatz wie die ursprüngliche Variable zu benutzen.

    Es wird doch kein neuer Speicherplatz zugewiesen, wenn ich eine Referenz deklariere!!!

    Hat ja auch niemand gesagt. Lies den von dir zitierten Satz nochmal genau.


    cga schrieb:
    Und Pointer sind doch auch typensicher (d. h. er speichert auch, wie gross das Objekt ist, auf das der Pointer zeigt)!!

    compactdisc hat schon richtig drauf geantwortet. Zeiger sind nicht typensicher, insofern dass ein Zeiger eigentlich auf alles zeigen kann. Beispiel:

    int i = 100;
    char * pc;
    pc = (char *) &i;

    printf("Bytes von i: ");
    printf("0x%02X ", *(pc++));
    printf("0x%02X ", *(pc++));
    printf("0x%02X ", *(pc++));
    printf("0x%02X ", *pc);

    Beim Ausführen dieses Codes kann man übrigens auch sofort sehen, ob man auf einem Little-Endian- oder Big-Endian-System arbeitet.


    cga schrieb:
    Also von daher stimmt das für mich, was adrians sagt.

    Einfachere Aussagen werden nun mal schneller akzeptieren, selbst wenn sie nicht stimmen oder einfach nur pauschalisiert sind.


    cga schrieb:
    Genau, das mache ich auch. Ich nehm dann die Spezialsprache C

    Das möcht ich sehen, wo kann ich deine Werke betrachten?

    Erst zahlen, dann gucken :-p


    Edit:
    Um nochmal zum ursprünglichen Thema zurück zu kommen, wann man Referenzen und wann man Pointer benutzen sollte...
    Zeiger werden oft anhand von Beispielen erklärt, für die in der Praxis eigentlich Referenzen die geeignetere Wahl wären. Daher ist es dann später oft so, dass die Leute mit dem Unterschied zwischen Referenzen und Zeigern nicht klar kommen. Wie ich schon bereits geschrieben hatte, werden an Stellen, wo Referenzen "richtiger" wären oft stattdessen Zeiger benutzt.
    Ich habe in google einfach mal nach "zeiger pointer c" gesucht und bin direkt beim ersten Ergebnis fündig geworden. http://www.pronix.de/pronix-743.html
    Dort wird zur Erklärung von Zeigern folgende Funktion aufgeführt:

    void kreisflaeche(float *wert) {
    *wert = ( (*wert) * (*wert) * PI );
    }

    Das funktioniert zwar, das Benutzen einer Referenz an dieser Stelle wäre aber sinnvoller, etwas performanter und weniger Schreibarbeit gewesen:
    void kreisflaeche(float & wert) {
    wert = wert * wert * PI;
    }

    Solche Funktionen sind in der Praxis aber kaum üblich. Meist wird solch ein Ergebnis einfach über return zurückgegeben, damit man damit direkt weiterrechnen kann.

    Die meist in der Praxis üblichen Funktionen stellen mit Zeigern relativ komplexe Dinge an, die mit Referenzen nicht mehr zu bewältigen sind.
    Ausserdem sollte man noch beachten, dass viele Codebeispiele (insbesondere der Windows NT Code) in C geschrieben sind. Unter (ANSI-)C gibt es aber keine Referenzen, daher wird man dort immer nur auf Zeiger stossen.

    Beitrag geaendert: 1.3.2007 12:34:26 von hannover-liga
  19. Autor dieses Themas

    c*a

    danke an euch für eure Ausführungen.

    Letztlich sind Referenzen in C++ fast identisch mit Referenzen in Java.

    Einfachere Aussagen werden nun mal schneller akzeptieren, selbst wenn sie nicht stimmen oder einfach nur pauschalisiert sind.

    Achje, ich wusste eben einfach nicht, dass man Pointer casten kann.

    Das macht natürlich einen großen Unterschied...

    Ausserdem sollte man noch beachten, dass viele Codebeispiele (insbesondere der Windows NT Code) in C geschrieben sind.

    Das war schon C++.

    Und dass NT in C geschrieben ist, hab ich in dem Moment vergessen... naja dafür war die Pointe gut.

    Beim Ausführen dieses Codes kann man übrigens auch sofort sehen, ob man auf einem Little-Endian- oder Big-Endian-System arbeitet.

    :scared: ich hab Big-Endian.
  20. tischfussball

    tischfussball hat kostenlosen Webspace.

    Wenn du in dem zuerst angezeigten Byte die 100 gespeichert hast, dann hast du ein Little-Endian-System, kein Big-Endian-System. Ich glaube nicht, dass du an einem Big-Endian-System sitzt. Oder welchen Prozessor hast du?
  21. Autor dieses Themas

    c*a

    Ist aber im letzten Byte. Prozessor: UltraSPARC III (Das ist mein "Router").

    Auf meinem Laptop steht die 100 im ersten Byte (Athlon XP-M).
  22. Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!

    lima-city: Gratis werbefreier Webspace für deine eigene Homepage

Dir gefällt dieses Thema?

Über lima-city

Login zum Webhosting ohne Werbung!