Was ist der wirkliche Unterschied zwischen Zeigern und Referenzen?

https://stackoverflow.com/questions/92001

01-07-2019
|

Frage

AKA – Was ist das für eine Obsession mit Zeigern?

Da ich eigentlich nur moderne, objektorientierte Sprachen wie ActionScript, Java und C# verwendet habe, verstehe ich nicht wirklich, wie wichtig Zeiger sind und wofür man sie verwendet.Was verpasse ich hier?

Lösung

Es ist alles nur indirection: Die Fähigkeit, mit Daten nicht viel, aber sagen: „Ich Sie auf bestimmte Daten lenken würde, da drüben.“ Sie haben das gleiche Konzept in Java und C #, aber nur in Bezug Format.

Die wichtigsten Unterschiede sind, dass Referenzen effektiv unveränderlich Schilder sind - sie zeigen immer etwas. Dies ist nützlich und leicht zu verstehen, aber weniger flexibel als das C-Zeiger-Modell. C-Pointer sind Hinweisschilder, die Sie gerne umschreiben kann. Sie wissen, dass die Zeichenfolge, die Sie suchen müssen, wird neben dem String zu spitz zu werden? Nun, ändern nur leicht über das Schild.

Diese Paare gut mit C-Schema „dicht am Knochen, geringen Kenntnisse erforderlich“ -Ansatz. Wir wissen , dass ein char* foo eines Satzes von Zeichen besteht, beginnend an der Stelle durch die foo Wegweiser zeigte. Wenn wir wissen auch, dass die Zeichenfolge mindestens 10 Zeichen lang ist, können wir den Wegweiser ändern (foo + 5) auf dann denselben String-zu-Punkt, aber beginnen die Hälfte der Länge in.

Diese Flexibilität ist nützlich, wenn man weiß, was man tut, und dem Tod, falls Sie dies nicht tun (wo „wissen“ ist mehr als nur „einfach die Sprache“, zum Thema „einfach den exakten Status des Programms“). Machen wir es falsch, und Ihr Wegweiser leitet Sie über den Rand einer Klippe. Referenzen lassen Sie nicht Geige, so dass Sie viel mehr sicher sind, dass man sie ohne Gefahr folgen kann (vor allem, wenn sie mit Regeln verbunden wie „A referenzierte Objekt wird nie verschwinden“, wie in den meisten Müll gesammelt Sprachen).

Andere Tipps

Sie sind nicht auf eine Menge aus! Zu verstehen, wie der Computer, auf dem unteren Ebenen funktioniert, ist in verschiedenen Situationen sehr nützlich. C und Assembler, dass für Sie tun.

Im Grunde ein Zeiger kann Sie Zeug zu einem beliebigen Punkt in dem Speicher des Computers schreiben. Auf primitiver Hardware / OS oder in eingebetteten Systemen könnte dies tatsächlich etwas Sinnvolles tun. Sagen die blinkenlichts aus- und wieder einzuschalten.

Natürlich funktioniert das nicht auf modernen Systemen. Das Betriebssystem ist der Herr und Meister des Hauptspeichers. Wenn Sie versuchen, einen falschen Speicherort zugreifen, Verfahren zu seiner Hybris mit seinem Leben bezahlen.

In C-Zeiger sind die Art und Weise Verweise auf Daten zu übergeben. Wenn Sie eine Funktion aufrufen, die Sie nicht wollen eine Million Bits auf einen Stapel kopieren. Stattdessen sagen Sie nur, wo die Daten im Hauptspeicher befinden. Mit anderen Worten, geben Sie ein Zeiger auf die Daten.

Bis zu einem gewissen Grad, das ist es, was auch mit Java geschieht. Sie passieren Verweise auf Objekte, nicht die Objekte selbst. Denken Sie daran, schließlich jedes Objekt ist ein Satz von Bits in dem Computer-Hauptspeicher.

Zeiger sind für direkt den Inhalt des Speichers zu manipulieren.

Es ist an Ihnen, ob Sie denken, das ist eine gute Sache zu tun, aber es ist die Grundlage dafür, wie etwas in C oder Assembler erledigt wird.

High-Level-Sprachen verstecken Zeiger hinter den Kulissen: zum Beispiel eine Referenz in Java wird als Zeiger implementiert in fast jede JVM Sie stoßen werden, weshalb es Nullpointer genannt wird, statt Nullreferenceexception. Aber es lässt nicht der Programmierer direkt die Adressspeicher zugreifen verweist er auf, und es kann nicht um einen Wert zu nehmen andere als die Adresse eines Objekts des richtigen Typs geändert werden. So ist es nicht die gleiche Leistung bietet (und Verantwortung), die Zeiger in Low-Level-Sprachen zu tun.

[Edit: Dies ist eine Antwort auf die Frage ‚was mit Zeigern diese Besessenheit ist?‘. Alles, was ich habe, ist im Vergleich Assembler / C-Stil Zeiger mit Java Referenzen. Die Frage Titel seit geändert haben: gesetzt hatte ich die neue Frage zu beantworten I Referenzen in anderen Sprachen als Java erwähnt haben könnte]

Das ist wie zu fragen, „was ist diese Besessenheit mit CPU-Anweisungen? Muss ich verpassen etwas von nicht x86 MOV Anweisungen überall Beregnung?“

Sie haben soeben Notwendigkeit Zeiger, wenn sie auf einem niedrigen Niveau zu programmieren. In den meisten geordneten Programmiersprache Implementierungen werden Zeiger gerade so umfassend wie in C verwendet, aber von dem Benutzer durch den Compiler versteckt.

So ... Keine Sorge. Sie verwenden Zeiger bereits - und ohne die Gefahren des so falsch tun, auch. :)

Ich sehe Zeiger als ein manuelles Getriebe in einem Auto. Wenn Sie lernen, mit einem Auto zu fahren, die ein automatisches Getriebe hat, das wird nicht für einen schlechten Fahrer machen. Und Sie können immer noch die meisten alles tun, was die Fahrer, die auf einem manuellen Getriebe gelernt tun. Es wird nur ein Loch in Ihrem Wissen des Fahrens sein. Wenn Sie eine manuelle fahren musste würden Sie wahrscheinlich in Schwierigkeiten. Sicher ist es einfach, das Grundkonzept zu verstehen, aber wenn man einen Hügel Start zu tun haben, sind Sie geschraubt. Aber es ist noch ein Platz für Handschaltgetriebe. Zum Beispiel müssen Rennwagenfahrer das Auto in dem optimalste Weg zu den aktuellen Rennbedingungen zu reagieren erhalten verschieben zu können. ein manuelles Getriebe ist sehr wichtig für ihren Erfolg.

Dies ist sehr ähnlich jetzt in der Programmierung. Es besteht ein Bedarf für C / C ++ Entwicklung auf einige Software. Einige Beispiele hierfür sind High-End-3D-Spiele, niedriges Niveau Embedded-Software, die Dinge, wo die Geschwindigkeit ist ein wichtiger Bestandteil des Zwecks der Software und eine untere Ebene Sprache, die Sie näher Zugriff auf die aktuellen Daten ermöglicht, die verarbeitet werden muss, ist der Schlüssel zu dieser Leistung . Doch für die meisten Programmierer ist dies nicht der Fall ist und keine Zeiger zu wissen, ist nicht lähmend. Aber ich glaube, jeder von Lernen über C und Zeiger profitieren kann, und Schaltgetrieben zu.

Da Sie objektorientierten Programmiersprachen in haben, lassen Sie es mich so sagen.

Sie ein instantiate Objekt B Objekt, und Sie geben es als Methodenparameter C. Das Objekt C ändert im Objekt B. einige Werte Objekt Wenn Sie zurück auf Objekt A des Codes sind, können Sie den geänderten Wert sehen in Objekt B. Warum ist das so?

Weil Sie in einem Referenz übergeben von Objekt B C Objekt, machte nicht eine weitere Kopie von Objekt B. So ein Objekt und Objekt C beide halten Referenzen auf das gleiche Objekt B im Speicher. Änderungen von einem Ort und in einem anderen zu sehen. Dies wird durch Referenz genannt.

Nun, wenn Sie primitive Typen verwenden, anstatt wie int oder float, und geben sie als Methodenparameter, Änderungen in der Object C kann nicht von Objekt A zu sehen ist, weil Objekt A nur eine übergeben Kopie statt eine Referenz seiner eigenen Kopie der variablen. Dies wird durch Wert genannt.

Sie haben wahrscheinlich schon wusste.

auf die Sprache C Kommen wir zurück, übergibt Funktion A B einige Variablen zur Funktion. Diese Funktionsparameter sind native Kopien, von Wert. Damit Funktion B die Kopie zu manipulieren A gehören, funktionieren, müssen Funktion A ein Zeiger in die Variable übergeben, so dass es einen Pass Bezug genommen wird.

„Hey, hier ist die Speicheradresse in meinem Integer-Variable. Setzen Sie den neuen Wert an dieser Adresse Lage und ich werde später abholen.“

Beachten Sie das Konzept ist ähnlich, aber nicht zu 100% analog. Pointers kann viel mehr tun, als nur „by reference“ vorbei. Zeiger erlauben Funktionen zu beliebigen Stellen des Speichers zu manipulieren, was auch immer Wert erforderlich. Zeiger werden auch darauf hinweisen, um neue Adressen von Ausführungscode , um dynamisch und Ausführen beliebiger Logik, nicht nur Datenvariablen verwendet. Pointers kann sogar auf andere Zeiger (Doppelzeiger) zeigen. Das ist mächtig, aber auch recht einfach schwer zu erkennen Fehler und Sicherheitslücken einzuführen.

Wenn Sie nicht vor dem Zeiger gesehen, sind Sie sicher zu verpassen auf diesem Mini-Juwel:

void strcpy(char *dest, char *src)
{    
        while(*dest++ = *src++);
}

Historisch gesehen, was möglich gemacht Programmierung war die Erkenntnis, dass Speicherplatz Computeranweisungen halten konnten, nicht nur Daten.

Pointers ergab sich aus der Erkenntnis, dass Speicherplatz auch die Adresse anderer Speicherstellen halten können, so gibt uns indirection. Ohne Zeiger (auf niedrigem Niveau) komplizierteste Datenstrukturen wäre unmöglich. Keine verknüpften Listen, binär Bäume oder Hash-Tabellen. Kein Pass Bezug genommen wird, nur von Wert. Da Zeiger können, ohne sie zu codieren Punkte haben wir auch keine virtuellen Funktionen oder Funktions Tabellen nachschlagen.

Ich benutze Zeiger und Referenzen stark in meinem täglichen Arbeit ... in verwaltetem Code (C #, Java) und nicht verwaltete (C ++, C). Ich habe gelernt, wie man mit Zeigern zu tun und was sie sind vom Meister selbst ... [Binky !!] [1] Nichts anderes gesagt werden muss;)

Der Unterschied zwischen einem Zeiger und Referenz ist dies. Ein Zeiger ist eine Adresse zu einem gewissen Speicherblock. Es kann mit anderen Worten neu geschrieben oder wird, zu einem anderen Speicherblock zugewiesen. Ein Verweis ist einfach eine Umbenennung eines Objekts. Es kann nur einmal vergeben werden! Sobald es zu einem Objekt zugeordnet ist, kann es nicht zu einem anderen zugeordnet wird. Eine Referenz ist nicht eine Adresse, ein anderer Name für die Variable ist. Schauen Sie sich C ++ FAQ für mehr zu diesem Thema.

Link1

LINK2

Ich bin derzeit hüfthoch in eine hohen Enterprise-Software entwerfen, in dem Datenblock (in einer SQL-Datenbank gespeichert ist, in diesem Fall) von 1 oder mehr anderen Einrichtungen verwiesen. Wenn ein Teil der Daten bleibt, wenn keine weiteren Einheiten auf sie verweisen, verschwenden wir Lagerung. Wenn ein Referenzpunkt so Daten, die nicht vorhanden sind, ist das ein großes Problem zu.

Es gibt eine starke Analogie zwischen unseren Themen gemacht werden, und das der Speicherverwaltung in einer Sprache, die Zeiger verwendet. Es ist enorm nützlich, um der Lage sein, meine Kollegen in Bezug auf diese Analogie zu sprechen. Nicht unreferenced Löschen von Daten ist ein „Memory Leak“. Eine Referenz, die nirgendwo geht, ist ein „baumelnden Zeiger“. Wir können explizite „befreit“ wählen, oder wir können „Garbage Collection“ mit „Referenzzählung“ implementieren.

Also hier, Speicherverwaltung Low-Level-Verständnis ist Design helfen, High-Level-Anwendungen.

In Java Sie verwenden Zeiger die ganze Zeit. Die meisten Variablen sind Zeiger auf Objekte - deshalb:

StringBuffer x = new StringBuffer("Hello");
StringBuffer y = x;
x.append(" boys");
System.out.println(y);

... prints "Hallo Jungs" und nicht "Hallo".

Der einzige Unterschied in C ist, dass es häufig von Zeigern zu addieren und subtrahieren - und wenn Sie die Logik falsch Sie mit Daten kann am Ende bekommen verwirren Sie sollten sich nicht berühren sein

Strings ist von grundlegender Bedeutung für C (und andere verwandte Sprachen). Wenn in C programmieren, Sie muss der Speicher verwalten. Sie sagen nicht nur: „Okay, ich werde ein paar Strings müssen“; Sie müssen über die Datenstruktur denken. Wie viel Speicher brauchen Sie? Wann werden Sie es zuweisen? Wann werden Sie es kostenlos? Angenommen, Sie haben 10 Saiten wollen, die jeweils mit nicht mehr als 80 Zeichen.

Okay, jede Saite ist ein Array von Zeichen (81 Zeichen - Sie die Null nicht vergessen oder du wirst es bereuen!) Und dann jede Saite ist selbst in einem Array. Das Endergebnis wird ein mehrdimensionales Array so etwas wie

sein

char dict[10][81];

Beachten Sie, nebenbei bemerkt, ist, dass dict kein "string" oder "Array", oder ein "char". Es ist ein Zeiger. Wenn Sie versuchen, eine dieser Zeichenketten zu drucken, alles, was Sie tun, ist die Adresse eines einzelnen Zeichens verläuft; C geht davon aus, dass, wenn es nur Zeichen beginnt mit dem Drucken wird es schließlich ein Null-Hit. Und es wird davon ausgegangen, dass, wenn Sie am Anfang einer Zeichenfolge ist, und Sie springen nach vorn 81 Bytes, Sie zu Beginn der nächsten Zeichenfolge sein werden. Und in der Tat nehmen Sie den Mauszeiger und das Hinzufügen von 81 Bytes ist die nur erdenkliche Weise auf die nächste Saite zu springen.

Also, warum sind Zeiger so wichtig? Denn man kann nicht ohne sie tun nichts. Sie können nicht einmal tun etwas Einfaches wie Ausdruck eine Reihe von Zeichenketten; Sie sicher kann nichts interessant wie implementieren verkettete Listen tun, oder Hashes oder Warteschlangen oder Bäume oder ein Dateisystem, oder einen Speicher-Management-Code oder einen Kernel oder ... was auch immer. Sie müssen sie verstehen, weil C Sie nur einen Speicherblock Hände und lassen Sie uns den Rest, und mit einem Block von rohen Speicher etwas zu tun, erfordert Zeiger.

Auch viele Menschen deuten darauf hin, dass die Fähigkeit Zeiger korreliert stark mit Programmierkenntnisse zu verstehen. Joel hat dieses Argument gemacht, unter anderem. Zum Beispiel

Nun, ich gebe offen zu, dass die Programmierung mit Zeigern nicht in 90% des Codes geschrieben heute gebraucht wird, und in der Tat ist es geradezu gefährlich in Produktionscode. OKAY. Das ist gut. Und funktionale Programmierung ist einfach nicht viel in der Praxis eingesetzt. Einverstanden.

Aber es ist immer noch wichtig für einige der spannendsten Programmierung Arbeitsplätze. Ohne Zeiger, zum Beispiel, würden Sie nie in der Lage sein, auf dem Linux-Kernel zu arbeiten. Sie können nicht eine einzige Zeile Code in Linux verstehen, oder, in der Tat, jedes Betriebssystem, ohne wirklich Zeiger zu verstehen.

hier . Exzellente Artikel.

Um ehrlich zu sein, die meisten erfahrenen Entwickler ein Lachen (hoffentlich freundlich) haben, wenn Sie Zeiger nicht kennen. In meinem vorherigen Job hatten wir zwei neue Mitarbeiter im vergangenen Jahr (gerade abgeschlossen), die nicht über Zeiger wußte, und das allein war das Thema des Gesprächs mit ihnen für etwa eine Woche. Niemand konnte glauben, wie jemand ohne zu wissen, Zeiger Abschluss könnte ...

Referenzen in C++ unterscheiden sich grundlegend von Referenzen in Java- oder .NET-Sprachen;.NET-Sprachen verfügen über spezielle Typen namens „byrefs“, die sich ähnlich wie C++-„Referenzen“ verhalten.

Eine C++-Referenz oder .NET-byref (ich verwende den letzteren Begriff, um sie von .NET-Referenzen zu unterscheiden) ist ein spezieller Typ, der keine Variable enthält, sondern Informationen, die ausreichen, um eine Variable (oder etwas, das sich verhalten kann) zu identifizieren als Ganzes, z. B. ein Array-Steckplatz), der an anderer Stelle gehalten wird.Byrefs werden im Allgemeinen nur als Funktionsparameter/-argumente verwendet und sollen kurzlebig sein.Code, der eine Byref an eine Funktion übergibt, garantiert, dass die dadurch identifizierte Variable mindestens bis zur Rückkehr dieser Funktion existiert, und Funktionen garantieren im Allgemeinen, dass sie nach ihrer Rückkehr keine Kopie einer Byref behalten (beachten Sie, dass die letztere Einschränkung in C++ nicht gilt). durchgesetzt).Daher können Byrefs die dadurch identifizierten Variablen nicht überleben.

In den Sprachen Java und .NET ist eine Referenz ein Typ, der ein Heap-Objekt identifiziert.Jedem Heap-Objekt ist eine Klasse zugeordnet, und Code in der Klasse des Heap-Objekts kann auf die im Objekt gespeicherten Daten zugreifen.Heap-Objekte gewähren möglicherweise externem Code eingeschränkten oder vollständigen Zugriff auf die darin gespeicherten Daten und/oder ermöglichen externen Code, bestimmte Methoden innerhalb ihrer Klasse aufzurufen.Die Verwendung einer Referenz zum Aufrufen einer Methode ihrer Klasse führt dazu, dass diese Referenz dieser Methode zur Verfügung gestellt wird, die sie dann verwenden kann, um auf Daten (auch private Daten) innerhalb des Heap-Objekts zuzugreifen.

Das Besondere an Referenzen in Java- und .NET-Sprachen ist, dass sie als absolute Invariante aufrechterhalten, dass jede Nicht-Null-Referenz weiterhin dasselbe Heap-Objekt identifiziert, solange diese Referenz existiert.Sobald nirgendwo im Universum ein Verweis auf ein Heap-Objekt existiert, hört das Heap-Objekt einfach auf zu existieren, aber es gibt keine Möglichkeit, dass ein Heap-Objekt aufhört zu existieren, während ein Verweis darauf existiert, und es gibt auch keine Möglichkeit für ein „normales“ Objekt " Verweis auf ein Heap-Objekt, um spontan zu etwas anderem als einem Verweis auf dieses Objekt zu werden.Sowohl Java als auch .NET verfügen zwar über spezielle „schwache Referenz“-Typen, aber auch sie behalten die Invariante bei.Wenn es nirgendwo im Universum nicht-schwache Verweise auf ein Objekt gibt, werden alle vorhandenen schwachen Verweise ungültig.Sobald dies geschieht, gibt es keine Verweise auf das Objekt mehr und es kann daher ungültig werden.

Zeiger, wie sowohl C++-Referenzen als auch Java/.NET-Referenzen, identifizieren Objekte, aber im Gegensatz zu den oben genannten Referenztypen können sie die Objekte, die sie identifizieren, überleben.Wenn das durch einen Zeiger identifizierte Objekt nicht mehr existiert, der Zeiger selbst jedoch nicht, führt jeder Versuch, den Zeiger zu verwenden, zu undefiniertem Verhalten.Wenn ein Zeiger ebenfalls nicht bekannt ist null oder um ein Objekt zu identifizieren, das derzeit existiert, gibt es dafür keine standardisierte Methode irgendetwas mit diesem Zeiger, anstatt ihn mit etwas anderem zu überschreiben.Es ist völlig legitim, dass ein Zeiger weiterhin existiert, nachdem das dadurch identifizierte Objekt dies nicht mehr tut, vorausgesetzt, dass der Zeiger nie verwendet wird. Es ist jedoch erforderlich, dass etwas außerhalb des Zeigers anzeigt, ob die Verwendung sicher ist oder nicht, da dies nicht möglich ist Fragen Sie den Zeiger selbst.

Der Hauptunterschied zwischen Zeigern und Referenzen (beider Art) besteht darin, dass Referenzen immer gefragt werden können, ob sie gültig sind (sie sind entweder gültig oder als null identifizierbar), und wenn sie als gültig angesehen werden, bleiben sie dies, solange sie gültig sind existieren.Zeiger können nicht gefragt werden, ob sie gültig sind, und das System unternimmt nichts, um sicherzustellen, dass Zeiger nicht ungültig werden, und lässt auch nicht zu, dass Zeiger, die ungültig werden, als solche erkannt werden.

Für eine lange Zeit, die ich nicht verstand, Zeiger, aber es verstand Array Adressierung. Also würde ich in der Regel einige Speicherbereich zusammen für Objekte in einem Array, und dann einen Index als ‚Zeiger‘ Konzept für dieses Array verwenden.

SomeObject store[100];
int a_ptr = 20;
SomeObject A = store[a_ptr];

Ein Problem bei diesem Ansatz ist, dass, nachdem ich ‚A‘ geändert, würde ich es auf den ‚Store‘ Array, um neu zuweisen müssen, damit die Änderungen dauerhaft sein:

store[a_ptr] = A;

Hinter den Kulissen wurde die Programmiersprache mehrere Kopiervorgänge zu tun. Die meiste Zeit dies nicht die Leistung beeinträchtigen. Es machte vor allem den Code fehleranfällig und repetitiv.

Nachdem ich gelernt Zeiger zu verstehen, zog ich weg das Array von der Umsetzung Adressierung Ansatz. Die Analogie ist immer noch ziemlich gültig. Man denke nur an, dass der ‚Store‘ Array durch die Programmiersprache der Laufzeit verwaltet wird.

SomeObject A;
SomeObject* a_ptr = &A;
// Any changes to a_ptr's contents hereafter will affect
// the one-true-object that it addresses. No need to reassign.

Heute verwende ich nur Zeiger, wenn ich nicht berechtigterweise ein Objekt kopieren. Es gibt eine Reihe von Gründen, warum dies der Fall sein könnte:

eine teure Objekt-Kopie zu vermeiden Betrieb im Interesse der Leistung.
Einige andere Faktor ermöglicht nicht ein Objekt-Datei kopiert.
Sie wollen einen Funktionsaufruf haben Nebenwirkungen auf ein Objekt (nicht übergeben, das Objekt, vorbei an den pointer dazu).
In einigen Sprachen- wenn Sie wollen Rück mehr als ein Wert von a Funktion (obwohl allgemein vermieden).

Pointers sind die pragmatische Art und Weise indirection repräsentieren in niedrigerer Ebene Programmiersprachen.

Pointers sind wichtig! Sie „Punkt“ auf eine Speicheradresse, und viele interne Strukturen werden als Zeiger dargestellt, dh ein Array von Strings ist eigentlich eine Liste von Zeigern auf Zeiger! Zeiger können auch für die Aktualisierung von Variablen an Funktionen übergeben werden.

Sie benötigen sie, wenn Sie „Objekte“ zur Laufzeit ohne Speicher auf dem Stapel zuweisen pre generieren möchten

Parameter efficency - Hindurchleiten eines Zeigers (Int - 4 Bytes) dar. Wie zu Kopieren eines gesamten Gegensatz (willkürlich groß) Objekt

Java-Klassen sind über Referenz (im Grunde ein Zeiger) übergibt auch btw, es ist nur, dass in Java, die von dem Programmierer verborgen ist.

Programmierung in Sprachen wie C und C ++ Sie viel näher an das „Metall“ sind. Pointers halten einen Speicherplatz, wo Ihre Variablen, Daten, Funktionen usw. leben. Sie können einen Zeiger übergeben um statt vorbei Wert (das Kopieren von Variablen und Daten).

Es gibt zwei Dinge, die nur schwer mit Zeigern:

Zeiger auf Zeiger, Adressierung, etc. sehr kryptisch bekommen. Es führt zu Fehlern, und es ist schwer zu lesen.
Speicher dass Punkt Zeiger zu oft aus dem Heap zugeordnet wird, was bedeutet, dass Sie für die Freigabe, dass der Speicher verantwortlich sind. Bigger Ihre Anwendung wird, schwieriger ist es, diese Anforderung zu halten, und Sie mit Speicherlecks am Ende, die schwer aufzuspüren.

Sie können Zeiger Verhalten vergleichen, wie Java-Objekte um übergeben werden, mit der Ausnahme, dass in Java müssen Sie den Speicher keine Sorge zu befreien, da dies von der Garbage Collection gehandhabt wird. Auf diese Weise erhalten Sie die guten Dinge über Zeiger, aber müssen nicht mit den Negativen beschäftigen. Sie können nach wie vor Speicherlecks in Java natürlich, wenn man nicht de-Referenz Ihre Objekte, aber das ist eine andere Sache.

Auch etwas nur zu beachten, Sie Zeiger in C # verwenden können (im Gegensatz zu normalen Referenzen gegen) durch einen Code-Block als unsicher markiert. Dann können Sie direkt zu ändern Speicheradressen rumlaufen und Pointer-Arithmetik tun und alles, was Spaß Zeug. Es ist toll für sehr schnelle Bildmanipulation (der einzige Ort, ich habe es persönlich in Anspruch genommen).

Soweit ich weiß, Java und Actionscript nicht unsicheren Code und Zeiger unterstützen.

Ich bin immer wieder durch den Fokus auf solche Dinge wie Zeiger oder Verweise in Hochsprachen beunruhigt. Es ist wirklich nützlich bei einer höheren Abstraktionsebene in Bezug auf das Verhalten von Objekten (oder auch nur Funktionen) zu denken, wie in Bezug auf den „zu denken gegen lassen Sie mich sehen, wenn ich die Adresse dieses Dings dort sendet, dann das Ding kehrt mir einen Zeiger auf etwas anderes "

Betrachten wir sogar eine einfache Swap-Funktion. Wenn Sie

void swap (int & a, int & b)

oder

Verfahren Swap (var a, b: ganze Zahl)

dann diese interpretieren, dass die Werte geändert werden können. Die Tatsache, dass dies, indem die Adressen der Variablen implementiert wird, ist nur eine Ablenkung von dem Zweck.

Das Gleiche gilt für Objekte --- denkt nicht an Objekt-Identifikatoren als Zeiger oder Verweise auf „Material“. Stattdessen, man denke nur an sich als gut, Objekten, an denen Sie Nachrichten senden können. Auch in primitiven Sprachen wie C ++, können Sie viel weiter viel schneller durch das Denken (und Schreiben) bei einer so hohen Niveau wie möglich gehen.

Schreiben Sie mehr als 2 Zeilen von C oder C ++ und Sie werden es herausfinden.

Sie sind „Zeiger“ auf den Speicherplatz einer Variablen. Es ist wie ein bisschen eine Variable durch Verweis übergeben.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow