Ich verstehe die Syntax und die allgemeine Semantik von Zeigern gegenüber Referenzen, aber wie soll ich entscheiden, wann es mehr oder weniger angemessen ist, Referenzen oder Zeiger in einer API zu verwenden?

Natürlich benötigen einige Situationen die eine oder andere ( operator++benötigt ein Referenzargument), aber im Allgemeinen bevorzuge ich Zeiger (und konstante Zeiger), da die Syntax klar ist, dass die Variablen destruktiv übergeben werden.

ZB im folgenden Code:

void add_one(int& n) { n += 1; }
void add_one(int* const n) { *n += 1; }
int main() {
  int a = 0;
  add_one(a); // Not clear that a may be modified
  add_one(&a); // 'a' is clearly being passed destructively
}

Mit dem Zeiger ist es immer (offensichtlicher), was los ist. Sind APIs und APIs, bei denen Klarheit ein großes Problem darstellt, Zeiger nicht geeigneter als Referenzen? Bedeutet das, dass Referenzen nur bei Bedarf verwendet werden sollten (z. B. operator++)? Gibt es Leistungsprobleme mit dem einen oder anderen?

BEARBEITEN (veraltet):

Neben dem Zulassen von NULL-Werten und dem Umgang mit Raw-Arrays scheint die Wahl von den persönlichen Vorlieben abhängig zu sein. Ich habe die folgende Antwort akzeptiert, die auf den C ++ - Style Guide von Google verweist , da sie die Ansicht enthält, dass "Verweise verwirrend sein können, da sie eine Wertsyntax, aber eine Zeigersemantik haben".

Aufgrund der zusätzlichen Arbeit, die erforderlich ist, um Zeigerargumente zu bereinigen, die nicht NULL sein sollten (z. B. add_one(0)wird die Zeigerversion aufgerufen und zur Laufzeit unterbrochen), ist es aus Sicht der Wartbarkeit sinnvoll, Referenzen zu verwenden, bei denen ein Objekt vorhanden sein muss, obwohl dies eine Schande ist die syntaktische Klarheit zu verlieren.

Verwenden Sie Referenz, wo immer Sie können, Zeiger, wo immer Sie müssen.

Vermeiden Sie Zeiger, bis Sie nicht mehr können.

Der Grund dafür ist, dass Zeiger das Verfolgen / Lesen erschweren, weniger sicher und weitaus gefährlicher sind als alle anderen Konstrukte.

Als Faustregel gilt also, Zeiger nur dann zu verwenden, wenn es keine andere Wahl gibt.

Das Zurückgeben eines Zeigers auf ein Objekt ist beispielsweise eine gültige Option, wenn die Funktion in einigen Fällen nullptr zurückgeben kann und davon ausgegangen wird, dass dies der Fall ist. Eine bessere Option wäre jedoch, etwas Ähnliches zu verwenden boost::optional.

Ein weiteres Beispiel ist die Verwendung von Zeigern auf den Rohspeicher für bestimmte Speichermanipulationen. Dies sollte in sehr engen Teilen des Codes versteckt und lokalisiert werden, um die gefährlichen Teile der gesamten Codebasis zu begrenzen.

In Ihrem Beispiel macht es keinen Sinn, einen Zeiger als Argument zu verwenden, weil:

1. Wenn Sie nullptrals Argument angeben, gehen Sie in ein Land mit undefiniertem Verhalten.
2. Die Referenzattributversion erlaubt das Problem mit 1 nicht (ohne leicht zu erkennende Tricks).
3. Die Version des Referenzattributs ist für den Benutzer einfacher zu verstehen: Sie müssen ein gültiges Objekt angeben, nicht etwas, das null sein könnte.

Wenn das Verhalten der Funktion mit oder ohne ein bestimmtes Objekt funktionieren müsste, deutet die Verwendung eines Zeigers als Attribut darauf hin, dass Sie nullptrals Argument übergeben können, und dies ist für die Funktion in Ordnung. Das ist eine Art Vertrag zwischen dem Benutzer und der Implementierung.

Die Leistungen sind genau gleich, da Referenzen intern als Zeiger implementiert werden. Sie brauchen sich also keine Sorgen zu machen.

Es gibt keine allgemein anerkannte Konvention bezüglich der Verwendung von Referenzen und Zeigern. In einigen Fällen müssen Sie Referenzen zurückgeben oder akzeptieren (z. B. Kopierkonstruktor), aber ansonsten können Sie tun, was Sie möchten. Eine häufig vorkommende Konvention ist die Verwendung von Referenzen, wenn der Parameter auf ein vorhandenes Objekt verweisen muss, und von Zeigern, wenn ein NULL-Wert in Ordnung ist.

Einige Codierungskonventionen (wie die von Google ) schreiben vor, dass immer Zeiger oder konstante Referenzen verwendet werden sollten, da Referenzen eine etwas unklare Syntax haben: Sie haben Referenzverhalten, aber Wertesyntax.

Aus C ++ FAQ Lite -

Verwenden Sie Referenzen, wenn Sie können, und Zeiger, wenn Sie müssen.

Referenzen werden normalerweise Zeigern vorgezogen, wenn Sie kein "erneutes Setzen" benötigen. Dies bedeutet normalerweise, dass Referenzen in der öffentlichen Schnittstelle einer Klasse am nützlichsten sind. Referenzen erscheinen normalerweise auf der Skin eines Objekts und Zeiger auf der Innenseite.

Die Ausnahme besteht darin, dass der Parameter oder Rückgabewert einer Funktion eine "Sentinel" -Referenz benötigt - eine Referenz, die sich nicht auf ein Objekt bezieht. Dies geschieht normalerweise am besten, indem Sie einen Zeiger zurückgeben / nehmen und dem NULL-Zeiger diese besondere Bedeutung geben (Referenzen müssen immer Alias-Objekte sein, kein dereferenzierter NULL-Zeiger).

Hinweis: Alte Programmierer der Zeile C mögen manchmal keine Referenzen, da sie eine Referenzsemantik bereitstellen, die im Code des Aufrufers nicht explizit ist. Nach einigen C ++ - Erfahrungen wird jedoch schnell klar, dass dies eine Form des Versteckens von Informationen ist, die eher ein Aktivposten als eine Verbindlichkeit ist. Beispielsweise sollten Programmierer Code in der Sprache des Problems und nicht in der Sprache der Maschine schreiben.

Meine Faustregel lautet:

• Verwenden Sie Zeiger für ausgehende oder eingehende Parameter. Es ist also ersichtlich, dass der Wert geändert wird. (Sie müssen verwenden &)
• Verwenden Sie Zeiger, wenn der Parameter NULL ein akzeptabler Wert ist. (Stellen Sie sicher, constdass es sich um einen eingehenden Parameter handelt.)
• Verwenden Sie Referenzen für eingehende Parameter, wenn diese nicht NULL sein dürfen und kein primitiver Typ sind ( const T&).
• Verwenden Sie Zeiger oder intelligente Zeiger, wenn Sie ein neu erstelltes Objekt zurückgeben.
• Verwenden Sie Zeiger oder intelligente Zeiger als Struktur- oder Klassenelemente anstelle von Referenzen.
• Verwenden Sie Referenzen für das Aliasing (z. B. int &current = someArray[i])

Unabhängig davon, welche Sie verwenden, vergessen Sie nicht, Ihre Funktionen und die Bedeutung ihrer Parameter zu dokumentieren, wenn sie nicht offensichtlich sind.

Haftungsausschluss: Abgesehen von der Tatsache, dass Referenzen weder NULL noch "Rebound" sein können (was bedeutet, dass sie das Objekt, dessen Alias ​​sie sind, nicht ändern können), kommt es wirklich auf den Geschmack an, also werde ich nicht sagen "das ist besser".

Trotzdem stimme ich Ihrer letzten Aussage im Beitrag nicht zu, da ich nicht glaube, dass der Code durch Verweise an Klarheit verliert. In Ihrem Beispiel

add_one(&a);

könnte klarer sein als

add_one(a);

da Sie wissen, dass sich der Wert von a höchstwahrscheinlich ändern wird. Auf der anderen Seite jedoch die Signatur der Funktion

void add_one(int* const n);

ist auch etwas unklar: wird n eine einzelne ganze Zahl oder ein Array sein? Manchmal haben Sie nur Zugriff auf (schlecht dokumentierte) Header und Signaturen wie

foo(int* const a, int b);

sind auf den ersten Blick nicht leicht zu interpretieren.

Imho, Referenzen sind so gut wie Zeiger, wenn keine (Neu-) Zuordnung oder Neubindung (im zuvor erläuterten Sinne) erforderlich ist. Wenn ein Entwickler nur Zeiger für Arrays verwendet, sind Funktionssignaturen etwas weniger mehrdeutig. Ganz zu schweigen von der Tatsache, dass die Operatorsyntax mit Referenzen viel besser lesbar ist.

Wie andere bereits geantwortet: Verwenden Sie immer Referenzen, es sei denn, die Variable ist NULL/ nullptrist wirklich ein gültiger Zustand.

John Carmacks Standpunkt zu diesem Thema ist ähnlich:

NULL-Zeiger sind das größte Problem in C / C ++, zumindest in unserem Code. Die doppelte Verwendung eines einzelnen Werts als Flag und Adresse verursacht eine unglaubliche Anzahl schwerwiegender Probleme. C ++ - Referenzen sollten nach Möglichkeit Zeigern vorgezogen werden. Während eine Referenz „wirklich“ nur ein Zeiger ist, hat sie den impliziten Vertrag, nicht NULL zu sein. Führen Sie NULL-Prüfungen durch, wenn Zeiger in Referenzen umgewandelt werden. Anschließend können Sie das Problem ignorieren.

http://www.altdevblogaday.com/2011/12/24/static-code-analysis/

Bearbeiten 2012-03-13

User Bret Kuhns bemerkt zu Recht:

Der C ++ 11-Standard wurde fertiggestellt. Ich denke, es ist Zeit in diesem Thread zu erwähnen, dass der meiste Code mit einer Kombination aus Referenzen, shared_ptr und unique_ptr perfekt funktionieren sollte.

Richtig, aber die Frage bleibt auch dann bestehen, wenn Rohzeiger durch intelligente Zeiger ersetzt werden.

Zum Beispiel können beide std::unique_ptrund std::shared_ptrals "leere" Zeiger über ihren Standardkonstruktor konstruiert werden:

• http://en.cppreference.com/w/cpp/memory/unique_ptr/unique_ptr
• http://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr

... was bedeutet, dass ihre Verwendung ohne Überprüfung, dass sie nicht leer sind, einen Absturz riskiert, und genau darum geht es in der Diskussion von J. Carmack.

Und dann haben wir das amüsante Problem: "Wie übergeben wir einen intelligenten Zeiger als Funktionsparameter?"

Jon ‚s Antwort auf die Frage C ++ - Verweise auf boost :: shared_ptr vorbei , und die folgenden Kommentare , die zeigen , selbst dann, vorbei an ein Smart - Pointer durch Kopie oder durch Verweis ist nicht so eindeutig, wie man möchte (Ich bevorzuge ich das" by-reference "standardmäßig, aber ich könnte mich irren).

Es ist keine Geschmackssache. Hier sind einige endgültige Regeln.

Wenn Sie auf eine statisch deklarierte Variable innerhalb des Bereichs verweisen möchten, in dem sie deklariert wurde, verwenden Sie eine C ++ - Referenz, und sie ist absolut sicher. Gleiches gilt für einen statisch deklarierten Smart Pointer. Das Übergeben von Parametern als Referenz ist ein Beispiel für diese Verwendung.

Wenn Sie auf etwas aus einem Bereich verweisen möchten, der breiter ist als der Bereich, in dem es deklariert ist, sollten Sie einen intelligenten Zeiger mit Referenzzählung verwenden, damit er absolut sicher ist.

Sie können aus syntaktischen Gründen auf ein Element einer Sammlung mit einer Referenz verweisen, dies ist jedoch nicht sicher. Das Element kann jederzeit gelöscht werden.

Um eine Referenz auf ein Element einer Sammlung sicher zu halten, müssen Sie einen intelligenten Zeiger mit Referenzzählung verwenden.

Jeder Leistungsunterschied wäre so gering, dass es nicht gerechtfertigt wäre, den weniger klaren Ansatz zu verwenden.

Erstens ist ein Fall, der nicht erwähnt wurde, wo Referenzen im Allgemeinen überlegen sind, constReferenzen. Bei nicht einfachen Typen wird a übergebenconst reference vermeidet das das Erstellen eines temporären und verursacht keine Verwirrung, über die Sie sich Sorgen machen (da der Wert nicht geändert wird). Wenn Sie eine Person zwingen, einen Zeiger zu übergeben, ist dies sehr verwirrend, da Sie möglicherweise glauben, dass sich der Wert geändert hat, wenn Sie die Adresse sehen, die an eine Funktion übergeben wurde.

Auf jeden Fall stimme ich Ihnen grundsätzlich zu. Ich mag es nicht, wenn Funktionen Referenzen verwenden, um ihren Wert zu ändern, wenn es nicht sehr offensichtlich ist, dass die Funktion dies tut. Auch ich bevorzuge in diesem Fall Zeiger.

Wenn Sie einen Wert in einem komplexen Typ zurückgeben müssen, bevorzuge ich Referenzen. Zum Beispiel:

bool GetFooArray(array &foo); // my preference
bool GetFooArray(array *foo); // alternative

Hier macht der Funktionsname deutlich, dass Sie Informationen in einem Array zurückerhalten. Es gibt also keine Verwirrung.

Die Hauptvorteile von Referenzen sind, dass sie immer einen gültigen Wert enthalten, sauberer als Zeiger sind und Polymorphismus unterstützen, ohne dass eine zusätzliche Syntax erforderlich ist. Wenn keiner dieser Vorteile zutrifft, gibt es keinen Grund, eine Referenz einem Zeiger vorzuziehen.

Aus dem Wiki kopiert -

Dies hat zur Folge, dass in vielen Implementierungen das Bearbeiten einer Variablen mit automatischer oder statischer Lebensdauer über eine Referenz, obwohl syntaktisch dem direkten Zugriff ähnlich, versteckte Dereferenzierungsoperationen beinhalten kann, die kostspielig sind. Referenzen sind eine syntaktisch kontroverse Funktion von C ++, da sie die Indirektionsebene eines Bezeichners verdecken. Das heißt, im Gegensatz zu C-Code, bei dem Zeiger normalerweise syntaktisch hervorstechen, ist es in einem großen Block von C ++ - Code möglicherweise nicht sofort offensichtlich, ob das Objekt, auf das zugegriffen wird, als lokale oder globale Variable definiert ist oder ob es sich um eine Referenz (impliziter Zeiger) handelt ein anderer Ort, insbesondere wenn der Code Referenzen und Zeiger mischt. Dieser Aspekt kann das Lesen und Debuggen von schlecht geschriebenem C ++ - Code erschweren (siehe Aliasing).

Ich stimme dem zu 100% zu, und deshalb glaube ich, dass Sie eine Referenz nur verwenden sollten, wenn Sie einen sehr guten Grund dafür haben.

Zu beachtende Punkte:

1. Zeiger können sein NULL, Referenzen können nicht sein NULL.

2. Referenzen sind einfacher zu verwenden, constkönnen als Referenz verwendet werden, wenn wir den Wert nicht ändern möchten und nur eine Referenz in einer Funktion benötigen.

3. Zeiger verwendet mit einer *Weile Referenzen verwendet mit a &.

4. Verwenden Sie Zeiger, wenn eine arithmetische Zeigeroperation erforderlich ist.

5. Sie können Zeiger auf einen Leertyp haben, int a=5; void *p = &a;aber keinen Verweis auf einen Leertyp.

Zeiger gegen Referenz

void fun(int *a)
{
    cout<<a<<'\n'; // address of a = 0x7fff79f83eac
    cout<<*a<<'\n'; // value at a = 5
    cout<<a+1<<'\n'; // address of a increment by 4 bytes(int) = 0x7fff79f83eb0
    cout<<*(a+1)<<'\n'; // value here is by default = 0
}
void fun(int &a)
{
    cout<<a<<'\n'; // reference of original a passed a = 5
}
int a=5;
fun(&a);
fun(a);

Urteil, wann was zu verwenden ist

Zeiger : Für Array-, Linklisten-, Baumimplementierungen und Zeigerarithmetik.

Referenz : In Funktionsparametern und Rückgabetypen.

Es gibt ein Problem mit der Regel " Verweise verwenden, wo immer möglich ", und es tritt auf, wenn Sie die Referenz für die weitere Verwendung aufbewahren möchten. Stellen Sie sich vor, Sie haben folgende Klassen, um dies anhand eines Beispiels zu veranschaulichen.

class SimCard
{
    public:
        explicit SimCard(int id):
            m_id(id)
        {
        }

        int getId() const
        {
            return m_id;
        }

    private:
        int m_id;
};

class RefPhone
{
    public:
        explicit RefPhone(const SimCard & card):
            m_card(card)
        {
        }

        int getSimId()
        {
            return m_card.getId();
        }

    private:
        const SimCard & m_card;
};

Auf den ersten Blick scheint es eine gute Idee zu sein, Parameter im RefPhone(const SimCard & card)Konstruktor von einer Referenz übergeben zu lassen, da dadurch verhindert wird, dass falsche / Null-Zeiger an den Konstruktor übergeben werden. Es fördert irgendwie die Zuweisung von Variablen auf dem Stapel und die Nutzung von RAII.

PtrPhone nullPhone(0);  //this will not happen that easily
SimCard * cardPtr = new SimCard(666);  //evil pointer
delete cardPtr;  //muahaha
PtrPhone uninitPhone(cardPtr);  //this will not happen that easily

Aber dann kommen Provisorien, um deine glückliche Welt zu zerstören.

RefPhone tempPhone(SimCard(666));   //evil temporary
//function referring to destroyed object
tempPhone.getSimId();    //this can happen

Wenn Sie sich also blind an Referenzen halten, tauschen Sie die Möglichkeit, ungültige Zeiger zu übergeben, gegen die Möglichkeit aus, Referenzen auf zerstörte Objekte zu speichern, was im Grunde den gleichen Effekt hat.

Bearbeiten: Beachten Sie, dass ich mich an die Regel "Verwenden Sie Referenz, wo immer Sie können, Zeiger, wo immer Sie müssen. Vermeiden Sie Zeiger, bis Sie nicht können." von der am besten bewerteten und akzeptierten Antwort (andere Antworten schlagen dies ebenfalls vor). Obwohl es offensichtlich sein sollte, soll ein Beispiel nicht zeigen, dass Referenzen als solche schlecht sind. Sie können jedoch wie Zeiger missbraucht werden und ihre eigenen Bedrohungen in den Code einbringen.

Es gibt folgende Unterschiede zwischen Zeigern und Referenzen.

1. Wenn es um die Übergabe von Variablen geht, sieht die Übergabe als Referenz wie die Übergabe als Wert aus, hat jedoch eine Zeigersemantik (verhält sich wie ein Zeiger).
2. Die Referenz kann nicht direkt auf 0 (null) initialisiert werden.
3. Referenz (Referenz, nicht referenziertes Objekt) kann nicht geändert werden (entspricht dem Zeiger "* const").
4. Die const-Referenz kann temporäre Parameter akzeptieren.
5. Lokale const-Referenzen verlängern die Lebensdauer temporärer Objekte

Unter Berücksichtigung dieser sind meine aktuellen Regeln wie folgt.

• Verwenden Sie Referenzen für Parameter, die lokal innerhalb eines Funktionsbereichs verwendet werden.
• Verwenden Sie Zeiger, wenn 0 (null) ein akzeptabler Parameterwert ist oder Sie Parameter zur weiteren Verwendung speichern müssen. Wenn 0 (null) akzeptabel ist, füge ich dem Parameter das Suffix "_n" hinzu, verwende einen geschützten Zeiger (wie QPointer in Qt) oder dokumentiere ihn einfach. Sie können auch intelligente Zeiger verwenden. Sie müssen mit gemeinsam genutzten Zeigern noch vorsichtiger sein als mit normalen Zeigern (andernfalls kann es zu Designleckagen und Verantwortungsproblemen kommen).

Im Folgenden finden Sie einige Richtlinien.

Eine Funktion verwendet übergebene Daten, ohne sie zu ändern:

1. Wenn das Datenobjekt klein ist, z. B. ein integrierter Datentyp oder eine kleine Struktur, übergeben Sie es als Wert.

2. Wenn das Datenobjekt ein Array ist, verwenden Sie einen Zeiger, da dies Ihre einzige Wahl ist. Machen Sie den Zeiger zu einem Zeiger auf const.

3. Wenn das Datenobjekt eine Struktur mit guter Größe ist, verwenden Sie einen const-Zeiger oder eine const-Referenz, um die Programmeffizienz zu erhöhen. Sie sparen Zeit und Platz, die zum Kopieren einer Struktur oder eines Klassendesigns erforderlich sind. Machen Sie den Zeiger oder die Referenz const.

4. Wenn das Datenobjekt ein Klassenobjekt ist, verwenden Sie eine konstante Referenz. Die Semantik des Klassenentwurfs erfordert häufig die Verwendung einer Referenz. Dies ist der Hauptgrund, warum C ++ diese Funktion hinzugefügt hat. Daher ist die Standardmethode zum Übergeben von Klassenobjektargumenten die Referenz.

Eine Funktion ändert Daten in der aufrufenden Funktion:

1.Wenn das Datenobjekt ein integrierter Datentyp ist, verwenden Sie einen Zeiger. Wenn Sie Code wie fixit (& x) erkennen, wobei x ein int ist, ist es ziemlich klar, dass diese Funktion beabsichtigt, x zu ändern.

2.Wenn das Datenobjekt ein Array ist, verwenden Sie Ihre einzige Auswahl: einen Zeiger.

3.Wenn das Datenobjekt eine Struktur ist, verwenden Sie eine Referenz oder einen Zeiger.

4.Wenn das Datenobjekt ein Klassenobjekt ist, verwenden Sie eine Referenz.

Dies sind natürlich nur Richtlinien, und es kann Gründe geben, unterschiedliche Entscheidungen zu treffen. Beispielsweise verwendet cin Referenzen für Basistypen, sodass Sie cin >> n anstelle von cin >> & n verwenden können.

Referenzen sind sauberer und einfacher zu verwenden und können Informationen besser verbergen. Referenzen können jedoch nicht neu zugewiesen werden. Wenn Sie zuerst auf ein Objekt und dann auf ein anderes zeigen müssen, müssen Sie einen Zeiger verwenden. Referenzen können nicht null sein. Wenn also die Möglichkeit besteht, dass das betreffende Objekt null ist, dürfen Sie keine Referenz verwenden. Sie müssen einen Zeiger verwenden. Wenn Sie die Objektmanipulation selbst durchführen möchten, dh wenn Sie Speicherplatz für ein Objekt auf dem Heap und nicht auf dem Stapel zuweisen möchten, müssen Sie den Zeiger verwenden

int *pInt = new int; // allocates *pInt on the Heap

Ihr richtig geschriebenes Beispiel sollte so aussehen

void add_one(int& n) { n += 1; }
void add_one(int* const n)
{
  if (n)
    *n += 1;
}

Deshalb sind Referenzen möglichst vorzuziehen ...

Ich habe gerade einen Cent reingelegt. Ich habe gerade einen Test durchgeführt. Ein höhnischer dazu. Ich habe g ++ einfach die Assembly-Dateien desselben Mini-Programms mit Zeigern erstellen lassen, verglichen mit Referenzen. Bei der Betrachtung der Ausgabe sind sie genau gleich. Anders als die Symbolbenennung. Wenn man sich also die Leistung ansieht (in einem einfachen Beispiel), gibt es kein Problem.

Nun zum Thema Zeiger gegen Referenzen. IMHO denke ich, dass Klarheit über allem steht. Sobald ich implizites Verhalten lese, beginnen sich meine Zehen zu kräuseln. Ich bin damit einverstanden, dass es ein schönes implizites Verhalten ist, dass eine Referenz nicht NULL sein kann.

Das Dereferenzieren eines NULL-Zeigers ist nicht das Problem. Es wird Ihre Anwendung zum Absturz bringen und ist einfach zu debuggen. Ein größeres Problem sind nicht initialisierte Zeiger mit ungültigen Werten. Dies führt höchstwahrscheinlich zu einer Speicherbeschädigung, die ein undefiniertes Verhalten ohne eindeutigen Ursprung verursacht.

Hier sind Referenzen meiner Meinung nach viel sicherer als Zeiger. Und ich stimme einer früheren Aussage zu, dass die Schnittstelle (die klar dokumentiert werden sollte, siehe Design by Contract, Bertrand Meyer) das Ergebnis der Parameter für eine Funktion definiert. Wenn ich dies alles berücksichtige, gehe ich vor, wo immer / wann immer möglich, Referenzen zu verwenden.

Für Zeiger müssen sie auf etwas zeigen, sodass Zeiger Speicherplatz kosten.

Beispielsweise nimmt eine Funktion, die einen Ganzzahlzeiger verwendet, die Ganzzahlvariable nicht an. Sie müssen also zuerst einen Zeiger erstellen, um ihn an die Funktion weiterzugeben.

Als Referenz kostet es keinen Speicher. Sie haben eine Ganzzahlvariable und können diese als Referenzvariable übergeben. Das ist es. Sie müssen keine Referenzvariable speziell dafür erstellen.