Pointer, Referenzen
lima-city → Forum → Programmiersprachen → C/C++ und D
adresse
beitrag
byte
compiler
funktion
kiste
mache
multiplikation
null
objekt
pointer
referenz
speicherplatz
sprache
syntax
uebrigens
unlogisch zurck
verstehe
window
zeiger
-
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 -
Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!
lima-city: Gratis werbefreier Webspace für deine eigene Homepage
-
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 -
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 -
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.
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.
-
@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. -
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. -
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
!) 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
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. -
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 -
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!
-
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 -
Man(n) sollte den Code stets lesbar halten
Frau nicht?
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. -
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.
-
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 ? 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? -
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 -
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 -
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 -
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.
ich hab Big-Endian.
-
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?
-
Ist aber im letzten Byte. Prozessor: UltraSPARC III (Das ist mein "Router").
Auf meinem Laptop steht die 100 im ersten Byte (Athlon XP-M). -
Ist zwar bisschen Off-Topic... bekommst du auf der Kiste Solaris V zum laufen?
-
Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!
lima-city: Gratis werbefreier Webspace für deine eigene Homepage
