Hallo und willkommen zurück. In dieser Vorlesung möchte ich eine Demonstration
für unsere vorherige Herausforderung liefern, bei der
es darum ging, Referenzübergabe zu
verstehen, wobei ein Parameter innerhalb einer Funktion einen Zeiger nimmt.
Erstellen wir also ein neues Projekt. Wir nennen diesen einen
Zeiger als Referenz, weil er das demonstriert,
grundlegende Dinge hier, neues Projekt,
Konsolenanwendung c. Ziemlich einfach hier.
Nennen wir diesen Zeiger einfach als
Referenz unterstrichen.
Wiederum wird gezeigt, wie wir Parameter innerhalb einer Funktion verwenden können, um
Daten zu übergeben, und wie diese Daten dann außerhalb
der Funktion geändert werden.
Als erstes erstellen wir unsere Funktionsdeklaration, unseren
Funktionsprototyp. Dies ist immer schön,
damit Sie überall in Ihrem Programm aufrufen können. Wir werden es nur quadratisch nennen.
Die Hauptsache in dieser Funktionsdeklaration ist, dass ein Zeiger benötigt wird.
Es wird also nur ein Endzeiger benötigt, also werden wir nur int star
sagen, und dann können Sie ihm einen beliebigen Namen geben und ihn mit dem Semikolon beenden.
Und unsere Hauptfunktion, zuerst
werden wir nur eine reguläre Ganzzahlvariable erstellen und wir
werden nur int num sagen und wir werden nur Hardcode auf 9 sagen.
Und wir werden unsere quadratische Funktion aufrufen.
Unsere quadratische Funktion gibt keine Daten zurück, sie ist ungültig.
Wir müssen ihm jetzt allerdings eine Adresse übergeben, da unsere quadratische Funktion in Zeile 4 einen Zeiger nimmt.
Wir können also keine Zahl übergeben, wir müssten tatsächlich die Adresse von num übergeben, und dann
würden wir sie mit einem Semikolon beenden. Also rufen wir die Funktion
mit dem Funktionsnamen auf und übergeben dann die Adresse der Variablen.
Weil die Variable hier in einer Zeile acht kein Zeiger ist.
Dann können wir einfach den Wert von num ausdrucken.
Und wieder werden Sie hier feststellen, dass wir die Adresse übergeben.
Wenn wir die Daten in der Funktion selbst für diese Variable ändern, werden
sie sich außerhalb der Adresse ändern. Hier sagen wir also, das
Quadrat der angegebenen Zahl ist und es heißt nur Prozent d,
wir fügen einen Zeilenvorschub hinzu und
wir drucken nur num aus, und num wird nicht
9 sein. Ich werde dir so viel sagen.
Und dann geben wir einfach 0 für unsere reguläre Funktion zurück.
Jetzt müssen wir die Funktion tatsächlich implementieren, definieren.
Um es zu definieren, werde ich nur void square sagen.
Wir wissen, dass es einen ganzzahligen Zeiger braucht, also werde ich int star x sagen.
Und jetzt wollen wir es einfach mit sich selbst multiplizieren.
Wir möchten aber sicherstellen, dass wir die Adresse nicht ändern.
Wir könnten hier also eine Konstante festlegen, aber Sie möchten
die Konstante nach dem Datentyp
setzen, da wir den Wert von x oder
die Adresse dessen, worauf es zeigt, nicht ändern möchten wir könnten int konstant sagen.
Wenn wir den Wert von x nicht
ändern wollten, würden wir konstant sagen. Aber wir wollen den Wert von x ändern, wir werden ihn von selbst quadrieren.
Um es zunächst selbst zu quadrieren, wollen wir zunächst
den endgültigen Wert von x ändern. Wir müssen also den
Indirektionsoperator verwenden. Wir müssen es mit dem Sternchen de-referenzieren.
Und dann sagen wir einfach gleich, wir wollen nicht
x mal x machen, weil das nur die Adressen multipliziert. X ist ein Zeiger, wir wollen nicht nur den
Wert von x erhalten, wir wollen den Wert dessen erhalten, auf was x zeigt.
Also müssen wir es wieder de-referenzieren und dann
werden wir es mit sich selbst multiplizieren. Wir werden es zweimal de-referenzieren.
Könnte eine gute Idee sein, dies
in Klammern zu setzen, damit es sehr leicht zu verstehen ist, was hier vor sich geht.
Sie referenzieren den Zeiger, erhalten den Wert des Zeigers und multiplizieren ihn
mit seinem Wert. Dann fügen Sie einfach das Semikolon hinzu, und das
ist alles, was Sie tun müssen. Wenn wir dieses Programm ausführen, wird es
81 ausdrucken.
Es wird den Wert von num ausdrucken. Num wird sich innerhalb des Quadrats ändern,
weil wir dort die Adresse weitergeben.
Wir können den Wert des Zeigers nicht wirklich ändern, daher
haben wir die Konstante nach dem Typ.
Hier sagen wir also build und es sieht so aus,
als hätten wir die Deklaration nicht geändert.
Und jetzt wollen wir nur noch sicherstellen, dass
alles andere korrekt ist.
Wenn der Zeiger konstant sein soll, müssen Sie
ihn nach dem Sternchen setzen.
Int start Konstante bedeutet also,
dass Sie den Wert von x, der
Adresse von num, nicht ändern können.
Wenn wir const vor dem int
oder nach der Eingabe vor dem Sternchen setzen, bedeutet
dies, dass Sie den Wert dessen, auf den der Zeiger zeigt, nicht ändern können.
Wenn wir dies jetzt ausführen, sollten wir als Ausgabe 81 sehen.
Dies sagt uns
wiederum, dass wir die Daten geändert
haben. Diese Variable,
diese lokale Variable num wurde innerhalb der Funktion geändert und ihr Wert geändert.
Das ist nicht normal Dieses Konzept haben wir bisher noch nicht gelernt. Das wird als Referenz übergeben.
In c übergeben Sie jedoch eine Kopie der Adresse.
Deshalb ist es wirklich redundant, wir brauchen nicht einmal die Konstante, denn selbst wenn
wir den Wert des Zeigers ändern würden, wäre es
eine Kopie des Wertes des Zeigers, also müssen Sie das nicht wirklich tun.
Wenn wir nun keine vorhandene Nummer verwenden möchten, können wir einen Zeiger erstellen,
für den wir nur Speicher zuweisen müssen.
Was wir hier also tun müssten, ist, dass wir eine int star num erstellen könnten.
Aber wir müssten zuerst das Malloc umwandeln, da Malloc
mit einem leeren Zeiger zurückkommt,
aber wir können Speicher dynamisch zuweisen.
Und hier müssten wir wirklich sagen, nur
weil wir eine ganze Zahl erstellen, wir könnten einfach die Größe von
int sagen und das würde uns Speicher zuweisen.
Und dann müssten wir nur noch in die Quadratzahl übergehen.
Und wenn wir
dies dann erstellen, würde es dasselbe tun, aber
jetzt haben wir auch keinen Wert für
num, also würden wir nicht
wirklich wissen, was zu berechnen ist, also müssten Sie
dem Wert von num tatsächlich zuweisen Wir werden
hier vier sagen, Sie verweisen darauf. Und jetzt, wenn Sie es erstellen und
ausführen, sollten Sie 16 erhalten.
Jetzt wollen wir nur noch den Wert ausdrucken, also wollen wir num sagen.
Und wenn wir es dann ausführen, sollten wir 16 sehen.
Und es ist wirklich genau die gleiche Art
von Verhalten, und wir sehen 16.
Der einzige Unterschied bestand darin, dass wir Speicher für
das zuweisen, auf das der Punkt zeigt, anstatt nur auf einen vorhandenen Speicherort
mit kaufmännischem Und zu zeigen.
Auch hier ist zu beachten, dass sich diese Zahl außerhalb
der Funktion ändert. Dies
wird durch Verweis verstanden. Wenn wir den De-Referenz-Operator verwenden, den Indirektionsoperator,
um den Wert dessen zu ermitteln, auf den der Punkt zeigt.
Verstehen Sie, dass wir, wenn die Funktion einen Zeiger nimmt und wir
einen Zeiger haben, einfach den Namen einsenden können.
Wenn es keinen Zeiger nimmt
und es tatsächlich ein Wert ist,
müssen wir ihn de-referenzieren. Und das ist genau wie beim Scanf.
Hier müssten wir also das kaufmännische Und sagen.
Und dann, auch wenn wir es ausdrucken,
müssten wir nichts de-referenzieren, weil es kein Zeiger ist, und
dann wäre das hier dasselbe.
Und dann verstehe Konstante zwei. Const vor dem int-Stern sagt, dass sich
der Wert, auf den der Punkt zeigt, nicht ändern kann.
Die Konstante nach dem int-Start sagt, dass die Adresse des Zeigers den Wert des Zeigers nicht ändern kann.
Ich hoffe das war hilfreich.
Spielen Sie noch einmal damit herum, ändern Sie die Syntax und spielen Sie herum, wie ich es getan habe.
Es wird Ihnen helfen, viel zu lernen. Vielen Dank.