Zeiger in C

1. 1 Einführung: Hallo und willkommen diesen neuen Kurs, in dem wir Zeiger in C kauen werden In diesem Kurs erfahren Sie, was Zeiger sind und wie sie es uns ermöglichen, den Programmcode zu optimieren. Und Sie lernen, komplexe Datentypen in eine Folge von Bytes umzuwandeln . Sie können Programme ohne Zeiger entwickeln, aber sie beschleunigen die Ausführung des Programmcodes erheblich , was besonders bei der Arbeit mit Mikrocontrollern wichtig ist . Und in diesem Kurs werden wir alles darüber behandeln. Die meisten von Ihnen wissen, dass Zeiger eines der sehr wichtigen Themen sind. Für alle eingebetteten Systemingenieure. Jeder, der in C programmiert, muss Zeiger verwenden , sonst scheitert er zurück. Viele Interviews oder Embedded-Systementwickler, Interviews stellen viele Fragen zu Zeigern. Und das Ziel dieses Kurses ist es, Ihnen beim Einstieg zu helfen und zu lernen, wie man Zeiger und die verschiedenen Arten von Zeigern nutzt , viele wichtige Themen abdecken. Wir werden alles erklären und Ihnen praktische Beispiele, Aufgaben und viele andere Ressourcen geben , die Ihnen dabei helfen, Zeiger in C zu meistern. Nun nehmen wir an, wir verfolgen was Sie wollen lerne in diesem Kurs. Sie lernen indirektes Adressieren mit Zeigern. Dann werden wir verschiedene Arten von Zeigern behandeln. Danach werden wir über Zeiger, zwei Haupttypen und Zeiger auf Arrays sprechen. Wir werden auch über Hinweise auf Funktionen sprechen. Zeiger, die ungültige, dynamische Variablen und Zeigeroperationen. Und dann sprechen wir über Datentypen, Konvertierung mit Zeigern. Und all diese Themen werden detailliert behandelt. Auch hier nehmen Sie Aufgaben entgegen, damit wir sicher sind , dass Sie das haben, was wir erklärt haben. Wir werden auch Praxisbeispiele erläutern. Wir werden sie gemeinsam lösen , um Ihnen ein praktisches Erlebnis zu bieten. Danke, dass du dir diese Einführung angesehen hast. Wir sehen uns drinnen. 2. 2 Einführung in Zeiger in C: Hallo und willkommen zu dieser neuen Lektion, in wir über Zeiger sprechen werden. Der Zeiger ist eine Variable, die die Speicheradresse als h-Wert speichert . Die Dinge sind an dieser Stelle möglicherweise nicht klar. Sprechen wir zuerst über die Syntax zum Erstellen eines Zeigers. Dann werden wir über diese Definition sprechen. Wie Sie hier sehen können, haben wir andere Syntax, um einen Zeiger zu definieren. Die erste ist, in den Zeigertyp einzugeben, das Sternzeichen hinzuzufügen, dann den Zeigernamen einzugeben und ein Semikolon hinzuzufügen. Das Gleiche passiert hier, aber anstatt das Sternchen in die Nähe des Zeigernamens zu schreiben, schreiben wir es in die Nähe des Zeigertyps. Die dritte Syntax ist die gleiche wie die ersten beiden, aber wir lassen Leerzeichen nach und vor dem Sternzeichen. In der Praxis können Sie hier sehen, dass wir einen Zeiger namens PTR haben. Der Typ dieses Zeigers ist Integer. Und um diesen Zeiger zu erstellen, müssen wir das Sternzeichen hinzufügen. Jetzt fügen wir es hier direkt vor dem Zeigernamen hinzu. Hier fügen wir es direkt nach dem Zeigertyp hinzu. Und hier fügen wir es in der Mitte zwischen dem Zeigernamen und dem Typ hinzu. Wie Sie hier sehen können, gibt es keinen Unterschied in diesen drei Syntax. Alle definieren einen Zeiger, der auf den ganzzahligen Typ zeigt, der das Hauptziel eines Zeigers ist. Jetzt zeigt wieder ein Zeiger. Dies ist ein Zeiger, der auf einen Speicherort im Speicher zeigt. Auch hier ist der Zeiger eine Variable, die die Speicheradresse als Wert speichert. Um die Dinge klarer zu machen, ist dies ein Beispiel. Die Adresse des Operators ist ein unärer Operator, der durch das Symbol dargestellt wird. Und wenn Sie sich dieses Symbol angeschaut haben, nennt man das Adresse des und zeichens. Es gibt die Adresse einer beliebigen Variablen an, wenn sie dem Variablennamen vorangestellt ist. Um dies klarer zu machen, wenn wir dies und x schreiben, bedeutet dieses x jetzt, gib mir die Adresse von x. Die Adresse von x wird in PTR gespeichert. Und in diesem Fall haben wir diese Erinnerung. Und das ist die Variable x. Jetzt ist die Adresse der Variablen x 1 Tausend. Jetzt ist der Wert von x innerhalb des Speichers zehn, aber das Anzeigenrisiko von x im Speicher beträgt 1 Tausend. Um diese Zahl zu erreichen, die 1 Tausend ist, müssen wir dies und x. Also entspricht PTR hier 1 Tausend, weil wir das Unsignierte verwenden, was die Adresse bedeutet. Die Adresse des Operators ist also ein Operator, der nur ein Argument benötigt. Es ist im Grunde das und -Symbol. Es gibt die Adresse einer beliebigen Variablen wenn sie dem Variablennamen vorangestellt ist. Jetzt. Und x ist gleich zehn, was das ist. Jetzt ist x gleich zehn. Es ist ein richtiger Satz. Wir erstellen eine neue Variable namens x. Wir geben ihr einen Wert von zehn. Also wird es in den Speicher gehen, hier eine neue Variable namens x erstellen, und es gibt ihr den Wert zehn. Jetzt int asterisk sign PTR, wir erstellen einen Zeiger vom Integer-Typ namens BT off. Und hier ist dieser Punkt oder dass wir einen Videorekorder erstellt haben. Und der Datentyp ist Integer. Der letzte Schritt besteht nun darin, eine Adresse innerhalb des Zeigers hinzuzufügen. Um das zu tun, verwenden wir diese Zeile, PTR entspricht der Adresse von x. Jetzt ist es wieder ein Zeichen, es wird andere abgesagt. Wir werden die Adresse von x finden, und wir werden die Adresse von x in BPR speichern. Die Adresse von x hier ist also 1 Tausend. Also speichern wir 1 Tausend in BT verwenden diese Zeile. Jetzt. Addieren Sie das aus PTR gleich was? Kannst du darüber nachdenken? Wir haben das bereits erwähnt und Sinus ist die Adresse von VTR, ist jetzt eine Variable im Speicher. Es ist ein Zeiger, aber er hat einen Speicherort im Speicher. Das ist also alles PTR und das andere, also ist der Videorecorder 2000s, also entspricht t 2 Tausend. Dieses Zeichen wird also die Adresse von Sinus genannt. Sie nun daran, dass dieser Zeiger selbst eine Variable ist eine Adresse im Datenspeicher hat. Wie jede Variable. Der einzige Unterschied besteht darin, dass der Zeiger eine Adresse einer anderen Variablen enthält. Es enthält keine regulären Daten, es enthält eine Adresse einer anderen Variablen. Lassen Sie uns nun den Bildschirm löschen , damit wir dies abschließen können. Jetzt haben wir hier eine ganze Zahl mit dem Namen x definiert und sie oft mit Wert initialisiert. Dann haben wir einen Zeiger auf int mit dem Namen VTR definiert. Danach haben wir PTR mit der Adresse von x initialisiert. Auf diese Weise haben wir alles bereit. Jetzt können wir einige Operationen durchführen. Zuerst haben wir bereits unsere Variable mit dem Namen x definiert, welcher Typ ganzzahlig ist, und gaben ihr den Wert zehn an. Wir haben den Zeiger auf n benannten Videorekorder definiert und initialisiert. Schau dir in diesem Fall diesen Satz an. Wir haben das Sternzeichen und wir haben den Zeigernamen. Und wir haben hier gleich. Jetzt ist der Dereferenzoperator ein unärer Operator, der durch das Symbolsternchen dargestellt wird. Dies wird als Dereferenzoperator bezeichnet. Und Sie müssen sich diese Namen merken, die wir bereits erwähnt haben und welche ist die Adresse davon. Jetzt haben wir das Sternzeichen, welches der Dereferenzoperator ist. Es heißt NOT Operator, was bedeutet, dass es nur eine Variable benötigt. Es arbeitet mit einer Zeigervariablen und bietet die Möglichkeit auf die Variable zuzugreifen, auf die der Zeiger zeigt. Jetzt ist es an dieser Stelle vielleicht nicht klar, aber wir nennen es d Elektronen, weil es die Notwendigkeit für die Adresse nimmt. Und es ermöglicht Ihnen , direkt mit der Variablen umzugehen , auf die der Zeiger zeigt. Lassen Sie uns dies anhand eines Beispiels erklären. Wie Sie hier sehen können, haben wir x, wir haben Videorekorder. Jetzt hat PTR die Adresse von x, die 1 Tausend ist, und x hat einen Wert von 50. Jetzt wissen wir bereits, dass x einen Wert von zehn hat. Und um es auf 50 zu ändern, machen wir folgendes. Das erste, was wir hier tun ist, dass wir diesen Dereferenzoperator schreiben. Und du kannst es hier sehen. Dann der Zeigername. Jetzt bedeutet das, gehe zur PTR und überprüfe die Adresse darin, die 1 Tausend ist. Und gehe zu der Variablen , die diese Adresse hat. In diesem Fall bedeutet der Referenz-PTR also x, denn 1 Tausend zeigt hier auf x, was diese Variable ist. Und wir sagen ihm, dass wir 50 darin aufbewahren wollen. Wir lagern es nicht in PTR. Ptr tut das. Wir speichern es in dieser Div-Referenz von PTR, die im Grunde die Variable x. also x entspricht 50. Deshalb entfernen wir zehn. Und jetzt ist ein neuer Wert 50. Lassen Sie uns nun den ANC löschen und es noch einmal erklären. Jetzt ist der x-Wert zehn. Wenn wir den Dereferenzoperator verwenden, der das Sternzeichen ist, wir ihm auf, PTR zu dereferenzieren, was ein Zeiger ist. Dereferenzieren eines Zeigers bedeutet, zu der Variablen zu gehen , auf die ein Zeiger zeigt. Und in diesem Fall zeigt der Zeiger mit dieser Adresse auf Variable x. Indem wir also ein Sternchen oder Dereferenz-PTR schreiben, sagen wir ihm auch, dass er zu x gehen und es gleich 50 machen soll. Lasst es uns jetzt erklären. Wenn wir eine andere Variable haben, sagen wir, wir haben y hier und wir haben 3 Tausend hier, was die Adresse ist. Und wir haben hier einen weiteren PTR zwischen R1. Und fügen wir die Adresse von y hinzu, 3 Tausend. Wenn du es jetzt so geschrieben hast. Jetzt machen wir den Wert von 55. Fügen wir das Sternzeichen hinzu PT R1 ist gleich, sagen wir 15. Jetzt bedeutet das Dereferenzierung. Pt R1 bedeutet, zur Variablen zu gehen oder zum Zeiger namens BT R1 zu wechseln. Rufen Sie die Adresse ab und überprüfen Sie die Variable, auf die diese Adresse verweist , und ändern Sie ihren Wert auf 15. Der erste Schritt geht also zum PT-R1-Zeiger und überprüft die Adresse. Nachdem Sie die Adresse überprüft haben, gehen Sie zu der Variablen, auf die diese Adresse zeigt, die in diesem Fall y ist, und ändern Sie den Wert von y auf 15. Also jetzt ist y gleich 15. Um die Dinge zusammenzufassen, bedeutet das Unsignierte die Adresse von PTR. Wenn wir vor dem Zeiger ein Sternzeichen hinzufügen, dereferenzieren wir den Zeiger. Daher geben wir ihm im Grunde die Möglichkeit, auf die Variable zuzugreifen , auf die der Zeiger zeigt. Und dies ist das Hauptziel dieses Dereferenzzeichens. Jetzt, in der nächsten Lektion, werden wir ein praktisches Beispiel lösen , dass Sie versuchen müssen, es selbst zu lösen. Ich musste ein Programm erstellen , das eine Ganzzahl definiert , sie mit ihnen initialisieren und dann ausdrucken. Definieren Sie anschließend einen Zeiger, der auf diese Ganzzahl zeigt , und ändern Sie den Wert der Ganzzahl durch den Zeiger auf B20. Dann drucke es nochmal aus. Jetzt ist die erwartete Ausgabe x, bevor die Änderung zehn ist. X nach Änderung ist 20. Stellen Sie sicher, dass Sie es lösen, bevor Sie mit der nächsten Lektion fortfahren. Danke, dass du diese Lektion gesehen hast. 3. 3 Erste praktische Beispiele lösen: Hallo und willkommen zu dieser neuen Lektion, in der wir die erste Frage lösen werden . Sie müssen ein Programm erstellen , das eine Ganzzahl definiert , sie mit zehn initialisieren und dann drucken. Danach. Definieren Sie einen Zeiger, der auf dieses Innere zeigt und ändern Sie den Wert des n durch die Zeiger auf B20. Dann drucke es nochmal aus. Die Ausgabe sollte dies sein. X ist zehn, dann x, nachdem es mit dem Zeiger geändert wurde, ist es 20. Um diese Frage zu lösen, verwenden alle Visual Studio-Code. Gehe zum Startmenü und rechts Visual Studio-Code. Hier ist es. Jetzt. Sie müssen eine neue Datei oder ein neues Projekt erstellen. Jetzt Datei, neue Datei. Und hier müssen Sie auf eine Sprache auswählen klicken und C wählen Jetzt können wir loslegen. Der erste Schritt besteht darin, die Std-Eingabeausgabe-String.h-Bibliothek einzuschließen , die die wichtigste Standard-Eingabe-Ausgabebibliothek für unser Programm ist . Also sollte ich Geschlechtskraft einbeziehen. Befehl zum Ätzen. Danach müssen Sie zu n gehen. Ich meine, dies wird unsere Hauptfunktion sein, die ausgeführt wird, nichts nehmen wird, was ungültig ist. Und der erste Schritt besteht darin, eine neue Ganzzahl zu definieren. Also ist x gleich 0. Dann drucke f. Lassen Sie uns den Benutzer bitten, den Wert einzugeben. Geben Sie also bitte eine Zahl ein. Jetzt müssen wir diese Nummer mit Scan f scannen . Die Nummer, die wir scannen werden, ist eine Dezimalzahl. Also hier, richtig. All dies wurde in unserem C-Programmierkurs erklärt. Und es ist nicht nötig , es noch einmal zu erklären weil wir hier Hinweise lehren. Jetzt. Wir müssen den vorherigen Wert und den neuen Wert erneut drucken . Also x vor dem Wechsel. X vor Änderung ist der Prozentsatz d. Jetzt müssen wir x mit Zeigern ändern. Lassen Sie uns also einen neuen Zeiger erstellen. Lassen Sie uns auf die Adresse von x verweisen. Um den Wert von x zu ändern, verwenden wir den Dereferenzoperator, den Asterix-PTR, und machen ihn gleich 20, was der neue Wert ist. Und wir werden dieselbe Zeile drucken, was das ist. Aber wir werden nach dem Wechsel sagen. Jetzt haben wir alles bereit und bereit. Wir können dieses x mit dem Referenz-PTR ändern und wir planen dasselbe. Wir können hier diese UTR und die andere Disziplin hinzufügen, dass dies auch x bedeutet, weil wir die Adresse innerhalb der PTR dereferenzieren, die die Adresse von x ist, also wird es der Wert von x sein. weil wir die Adresse innerhalb der PTR dereferenzieren, die die Adresse von x ist, also wird es der Wert von x sein. , beachte den Code. Sie können es einfach auf den Notepad Plus, Plus einfügen , wie wir bereits erklärt haben, und speichern. Nennen wir es Zeigerbeispiel. Jetzt müssen wir es als Punkt c speichern und lassen Sie es uns ausführen. Was nun IGCSE-Zeiger zeigt, zum Beispiel Nazi. Schreiben Sie danach einen Punkt EXE. Und wie du siehst, fragt es Gott, bitte gib eine Zahl ein. Sagen wir fünf. Nun, x vor Änderung ist fünf, x nach Änderung ist 20, was genau das ist, was wir hier gemacht haben. Wir ändern den Wert von x mit Zeigern. Das war's für diese Lektion. Danke fürs Zuschauen. 4. 4 Durchlauf für Wert und Durchlauf für Adresse in C: Hallo und willkommen zu dieser neuen Lektion , in der wir Wert und Übergabe von Adresse erklären werden. In dieser Lektion werden wir diese beiden Registerkarten zur Übergabe von Wert und Adresse besprechen . Der erste Typ wird nach Wert übergeben. Dies bedeutet, dass Sie eine Kopie im Speicher des tatsächlichen Parameterwerts erstellen, der übergeben wird. Eine Kopie des Inhalts des tatsächlichen Parameters. Während in der Vergangenheit nach Adresse oder als Referenz übergeben. Sie erstellen im Grunde eine Kopie im Speicher der Adresse des tatsächlichen Parameters. Zwei erstellen keine Kopie des Parameterwerts. Wir erstellen eine Kopie im Speicher der Adresse des tatsächlichen Parameters. Werfen wir einen Blick auf diese Beispiele. Auch hier wird der Wert übergeben eine Kopie im Speicher des tatsächlichen Parameters erstellt, während die Übergabe an Adresse oder Refinanzierung eine Kopie im Speicher der Adresse des tatsächlichen Parameters erstellt. Also hier machen wir eine Kopie der Adresse. Hier machen wir eine Kopie des eigentlichen Parameters. Wie Sie in diesem Beispiel sehen können, haben wir hier eine Funktion und diese Funktion wird von der Wertefunktion aufgerufen. Es dauert Integer x. Jetzt nimmt diese Funktion ein Argument nach Wert an , da sie einen tatsächlichen Wert annimmt , der im Grunde eine Variable x vom Typ Integer ist. Wenn wir die Funktion aufrufen, übergeben wir die Variable, übergeben wir die Variable, indem wir eine Kopie des eigentlichen Parameters erstellen. Wir beschäftigen uns hier nur mit tatsächlichen Werten, tatsächlichen Parametern, wir haben es nicht mit Adressen zu tun. Wenn es nun darum geht, an Adresse oder Referenz zu übergeben , wie Sie sehen können, haben wir in dieser Funktion eine Funktion, die von anderen aufgerufen wird , und sie nimmt einen Zeiger als Eingabe. Also ganzzahliges Sternchen PTR, das ist ein Zeiger. Nun nimmt diese Funktion eine Adresse als ungerade an. Die Eingabe für diese Funktion muss also eine Adresse sein. Und wir übergeben die Variable z an anderen hier. Wir können nicht hinzufügen, weil es sich im Grunde um einen Wert handelt. Und diese Funktion will eine Adresse. Also hier haben wir das und -Zeichen hinzugefügt, was die Adresse davon bedeutet. Wie Sie hier sehen können. Jetzt wird die Adresse von z an die Byteadressfunktion übergeben. Während hier der Wert von z durch die Wertefunktion übergeben wird. Also machen wir im Grunde eine Kopie des eigentlichen Parameters. Während wir hier drin sind, machen wir eine Kopie im Speicher der Adresse, deren die Adresse des tatsächlichen Parameters ist. Und dies ist der Hauptunterschied zwischen Wert übergeben und Adresse übergeben. Es gibt verschiedene Anwendungsfälle und Sie werden einige praktische Beispiele annehmen. Aber das ist alles, was Sie vorerst wissen müssen, um Wert zu übergeben und an Adresse zu übergeben. 5. 6 Hinweise erhöhen und Dekret: Hallo und willkommen zu dieser neuen Lektion. Wir sprechen über Operationen an Zeigern. Jetzt. Die erste Operation, über die wir sprechen werden, sind die Inkrement- und Dekrementierungsoperationen. Der Inkrementvorgang erhöht den Zeigerwert um einen Schritt. Nun haben wir nicht mit einem Byte gesagt, da dieser Schritt 148 sein könnte oder eine beliebige Anzahl von Bytes die Größe des Punktes t hat. Wenn wir nun PTR plus plus schreiben, wenn wir davon ausgehen, dass PTR ein Zeiger auf Integer ist, dann wenn wir es sind wenn wir plus sagen, gehen wir einen ganzzahligen Schritt, der im Grunde vier Bytes ist. Abhängig von Ihrem Compiler. Der Compiler hat eine ganze Zahl als vier Bytes. Dies bedeutet, dass jedes Inkrement der Adresse von PTR vier Bytes hinzufügt. Unter der Annahme, dass eine PTR-Adresse 1 Tausend beträgt, bedeutet dies, dass wir aufgrund dieser vier Bytes jetzt bei 1004 sind . Jedes Inkrement oder jedes Zeigerinkrement erhöht also den Zeigerwert um einen Schritt. Auch hier ist der Stub die Größe des Points ohne Ganzzahl, Zeichenfolge oder Zeichen oder welche Art von Daten auch immer. Wenn es um das Dekrement geht, ist es das gleiche Szenario. Verringert den Zeigerwert um einen Schritt. Es ist so geschrieben , PTR minus minus. Und wenn wir davon ausgehen, dass die ganze Zahl vier Bytes hat, bedeutet dies, dass sie vier Schritte zurückgehen wird, sie wird 996 werden. Und so funktionieren Inkremente und Dekremente im Grunde . Jetzt sehen wir uns das in der Praxis an. Beginnen wir nun mit einem einfachen Beispiel. Hash enthält stdio.h. Jetzt int main, void. Wählen wir die Sprache aus, die c sein soll. Jetzt erstellen wir eine neue Variable und x entspricht zehn und erstellen einen Zeiger. Jetzt wird PTR die Adresse von x. Und das sind drei einfache Sätze. Was wir jetzt tun müssen, ist die PTR zu erhöhen oder zu dekrementieren. Aber zuerst müssen wir drucken. Schreiben wir also print f PTR-Adresse, und wir müssen die Adresse des Zeigers drucken. Fügen Sie nun P als Formatbezeichner hinzu. Und p N steht hier für Zeigerschrägstrich n. Und danach können Sie die Adresse einer ECS-Instanz hinzufügen. Sie können PTR hinzufügen, beide Arbeiten. Jetzt fügen wir die Adresse von x. Um zu verhindern, dass die Anzeige korrekt ist, müssen wir sie als ungültig umwandeln. Lassen Sie uns das nun ausführen, um zu sehen, wie die Dinge laufen werden. Öffnen Sie also den enthaltenden Ordner, speichern wir zuerst diese Datei. Nennen wir es Zeigerelement. Mal sehen. Lassen Sie uns danach diesen Zeiger kombinieren. Verwenden wir zuerst ls, GCC-Zeigerpunkt c. Jetzt suchen wir eine EXE. Und hier haben wir PTR-Adresse ist 01, F, 1 Viertel. Jetzt können wir dieses Inkrement und dieses Dekrement ausführen , um zu sehen, wie die Dinge laufen werden. Hier drin können Sie PTR plus plus und PTR minus minus sagen. Jetzt werden Sie feststellen, dass, wenn wir dies durch PTR ersetzen, versuchen wir, die Codes auszuführen. Wie Sie sehen können, erzielen wir die gleichen Ergebnisse. Jetzt. Drucken wir dasselbe nach den Inkrementen und drucken dann dasselbe nach dem Doppelpunkt aus. Jetzt erhöht das Inkrement die Adresse um vier, was die Anzahl der Bytes und eine Ganzzahl ist. Dann wird es mit dem Dekrement um vier zurückbekommen. Mal sehen, wie die Dinge laufen werden. Geht zurück. Lassen Sie uns mit GCC kombinieren. Lasst uns rennen. Hier ist es. Wie Sie hier sehen können, 61 E14. Nachdem wir um vier Bytes erhöht haben, sind es 18. Jetzt habe ich den Wert erneut verringert, PDR minus minus. Jetzt ist es wieder auf eins, um vier Byte erhöht und dann um vier Balken reduziert. Also geh zum ursprünglichen Ort. Auch hier, PTR, erhöhen und verringern je nach Art des Punktes. Jetzt können wir es in Charakter ändern. Wenn wir jetzt wieder hierher gehen, versuchen wir es zu kombinieren. Führen Sie nun aus, wie Sie sehen können, dass dieser Schauspieler nur ein Byte ist. Jetzt ist es bei 17, indem es bei 18 erhöht wird. Und indem er erneut dekrementiert hat, spuckte sie am 17. Wie Sie sehen können, erfolgt das Inkrement und das Dekrement je nach Datentyp auf Byteebene. Und es erhöht und dekrementiert die Adresse. Nicht der Wert. Danke, dass du diese Lektion gesehen hast. Wenn Sie Fragen haben, bin ich hier, um Ihnen zu helfen. 6. 7 Hinweise hinzufügen und Subtraktion: Hallo und willkommen zu dieser neuen Lektion , in der wir über Addition und Subtraktion von Zeigern sprechen werden. Um nun den Wert vom Zeiger zu subtrahieren, definieren wir zuerst einen neuen Zeiger. Fügen wir also x gleich zehn hinzu. Und das erzeugt einen Zeiger. Lassen Sie uns diesen Zeiger auf die Adresse von x. Nun definieren wir diese, wie in unserem vorherigen Beispiel, und wir werden damit Operationen durchführen. Der erste Schritt ist Subtraktion vom Zeiger zum Subtrahieren des Wertes vom Zeiger. Ptr entspricht PTR minus, sagen wir vier. Weil wir es mit einer Ganzzahl zu tun haben. Hier geht davon aus, dass die Ganzzahl vier Bytes beträgt. Aber Sie können jeden Wert subtrahieren. Sobald Sie diesen Befehl ausführen, gehen wir davon aus, dass die PTR-Adresse 1 Tausend beträgt, wird es jetzt 960 oder 84 , weil wir vier Bytes haben und vier mal vier 16 Bit sind. Also sind wir 16 Bit zurückgegangen. Jetzt geht es um die Bit-Level. Um die Dinge klarer zu machen, drucken wir. Danke. Drucken Sie also f, Adresse, Wert, der Prozentsatz ist Nähen und Schrägstrich. Jetzt möchten wir hier den PTR-Wert drucken. Wir müssen es auswerfen. Und dann können wir B2 hinzufügen. Jetzt um den Wert zu drucken, nachdem wir vier davon abgezogen haben. Gehen wir zurück und führen das aus. Also sparen Sie. Dies ist der Name unserer Datei. Also lasst uns den Namen kopieren. Jetzt. Lassen Sie uns diesen Code ausführen. Jetzt, Compiler GCC E. Und hier haben wir es. Wie Sie hier sehen können. Der Wert vor der Subtraktion ist wenn B14. Jetzt ist der Wert nach der ersten Subtraktion, Subtraktion, 04. Und hier drinnen sind wir zurückgegangen. Wie Sie sehen können, haben wir vier davon abgezogen. Jetzt wissen Sie genau, wie viele Schritte wir zurückgegangen sind. Subtrahieren wir einen. Speichern Sie diesen Code jetzt erneut, gehen Sie zurück, kombinieren Sie den Code und führen Sie den Code aus. Wie Sie sehen können, sind wir von 14 auf zehn gestiegen, als wir einen subtrahierten . Wir sind vier Schritte zurückgegangen. Wenn wir nun vier subtrahieren, werden wir 16 Schritt zurückgehen. Eine andere Sache, die Sie mit Zeigern machen können , ist, den Zeiger vom Zeiger zu subtrahieren. Lassen Sie uns also eine andere Variable erstellen. Nennen wir es y. Und lasst uns einen weiteren Zeiger erstellen. Nennen wir das und dieses Tool. Und lassen Sie uns die Werte x und y ändern. Beta1, beta2. Hier haben wir PTR eins, und hier haben wir PTR C2. Was wir tun müssen, ist folgendes. Wir werden int x gleich R1 minus PTR erstellen. Hier gehen wir davon aus, dass wir zwei Zeiger haben. Und beide sind Zeiger auf Integer, die vier Bytes sind. Jetzt gibt PTR eins minus Beta zwei die Anzahl der Schritte zwischen ihnen zurück. Also lasst uns das machen. Und der letzte Schritt ist das Drucken. Das Ergebnis ist Prozentsatz d Slash n. Und n. Hier müssen wir x über x hinzufügen. Nun gehen wir zurück zur Befehlszeile. Jetzt. Wir haben hier ein Problem. X ist wieder definiert, also müssen wir es schaffen. Wie Sie hier sehen können, haben wir einen Punkt oder einen anderen. Wir haben Hinweise, die wir ansprechen müssen. Und wir haben Zeiger ein Frame-Zeiger-Werkzeug subtrahiert. Und wir haben herausgefunden, dass der Abstand zwischen ihnen diese Zahl ist. Wenn es nun um die Hinzufügung von Zeigern geht, können wir einem Zeiger einen Wert hinzufügen. Um das zu tun, können wir einfach folgendes tun. Wir können sagen, dass PTR V1 V1 gleich V2 R1 plus sagen wir vier. Und wir können es mit dem Befehl print drucken , den wir alle verwendet haben. R1, ungültig B bis R1. Okay? Jetzt wissen wir bereits , dass wir auf andere hier gedruckt werden. Mal sehen, wie sich dies auf das Ergebnis auswirken wird. Jetzt bearbeite EXP. Und hier sind wir. Dies ist die Adresse von PT R1. Und dies ist die Adresse nach dem Hinzufügen vier zum PT R1-Wert. Wie Sie sehen können, bewegt es sich von 08 auf 18. Und darüber sprechen wir. können Sie Werte einfach hinzufügen oder subtrahieren Je nach Art der Operation können Sie Werte einfach hinzufügen oder subtrahieren. Nun, was nicht erlaubt ist, ist, dass es einen Zeiger auf einen Zeiger wie den zu subtrahieren hier drin hinzuzufügen verboten ist, einen Zeiger auf einen Zeiger wie den zu subtrahieren hier drin hinzuzufügen. Es ist nicht zulässig und führt zu einem Compilerfehler. Wenn Sie versuchen, einen Punkt bei 1 oder zwei mit einem Pluszeichen hinzuzufügen, erhalten Sie einen Kompilierungsfehler. Es ist also nur erlaubt, dem Zeiger einen Wert hinzuzufügen. Es ist nicht erlaubt, zwei Zeiger zusammen hinzuzufügen. Sie können den Wert jedoch von einem Zeiger subtrahieren oder zwei Zeiger voneinander subtrahieren. Das war's für diese Lektion. Wenn Sie Fragen haben, wenden Sie sich bitte an und ob Sie im Vorstand sind. 7. 8 Hinweise und Arrays: Hallo und willkommen zu dieser neuen Lektion, in der wir über Arrays und Funktionen sprechen werden. Das erste, was Sie wissen müssen , ist, dass der Name des Arrays die Adresse des ersten Elements darin ist. Wenn wir also speichern und ARR , ein Array mit zehn Elementen, dann ist dies die Adresse des SE, des ersten Elements und des Arrays, das Element 0 ist. Es ist genau so, als würde man sagen , dass ein Risiko für ein alle 0 ist. Diese beiden sind identisch. Definieren eines Arrays mit dieser Methode bedeutet also , dass wir auf die Adresse des ersten Elements im Array zeigen . Jetzt werden alle Elemente des Arrays nacheinander im Speicher gespeichert. Das heißt, wenn Sie einen Zeiger auf das erste Element im Array haben , durch Inkrementieren des Zeigers der Punkt oder zeigt auf das zweite Element und erhöht es weiter, um das dritte zu erreichen, vierter, fünfter und so weiter. Nun ist eine weitere gute Sache, die zu wissen ist , dass der Umgang mit dem Array und der Tatsache , dass Tierdaten die Adresse ihres ersten Elements sind, es uns ermöglichen, viele Dinge mit Arrays zu tun , indem wir sie als Zeiger. Auch hier ist ARR identisch mit der Adresse von 0. Das heißt, wenn Sie den Array-Namen ARR an die aufgerufene Funktion übergeben , sagen wir Funktion. Also funktioniere. Und wir geben es. Dann geben wir in diesem Fall die Adresse weiter. Wir geben keinen Wert weiter. Dieser Funktionsprototyp sollte also als Follow-void-Funktion deklariert werden . Und hier müssen wir sicherstellen , dass wir einen Zeiger hinzufügen. Wir gehen nicht nach Wert. Wir geben Kuchen Alice vorbei, obwohl wir schreiben, schreiben wir nichts, wir nichts darauf hinweist , dass dies ein Zeiger ist. Aber wie wir bereits erwähnt haben, ist dies der Name unseres Arrays. Und der Name des Arrays ist im Grunde die Adresse des ersten Elements im Array. Und das kommt viel, ein MCQ Fragen und Interviews und in vielen verschiedenen Szenarien. Jetzt innerhalb der Funktion, wenn wir PTR dereferenzieren wollen, was der Zeiger ist. Dies bedeutet, dass wir auf das erste Element des Arrays zugreifen. Und wenn wir es geschafft haben, haben wir die PTR um eins erhöht. Dann greifen wir auf das zweite Element dieses Arrays zu. B bis R. Zwei ist das dritte Element und so weiter. Sie müssen sicherstellen, dass diese Notizen berücksichtigt werden, wenn Sie mit Arrays innerhalb von C arbeiten . Da Arrays Zeigern sehr ähnlich sind und das Verständnis von Zeigern den Umgang mit Arrays ermöglicht sind eine viel einfachere Arbeit. Ein weiterer wichtiger Hinweis ist tiefgestellte TR- und Dereferenzoperator im Umgang mit Zeigern und Arrays. Nun, der Index Operator , der diese beiden Zeichen sind, wurde mit Arrays verwendet, wenn wir ein neues Array definieren. Es kann auch mit Zeigern verwendet werden. Sagen wir also, wir haben einen Zeiger. Also lasst uns einen Kommentar abgeben. Okay. Sagen wir, wir haben einen Zeiger, PTR. Wenn wir nun PTR 0 sagen und diesen tiefgestellten Operator verwenden, diesen tiefgestellten Operator verwenden, bedeutet dies dasselbe wie schöne Tanzdetails zu sagen. Diese beiden sind identisch. Wir rufen das erste Element oder die erste Adresse des Zeigers auf. Wenn wir nun nach der Zeigeradresse auf die zweite Adresse zugreifen möchten , können wir einfach eine PTR schreiben. Und dann greifen wir in diesem Fall die Adresse neben dieser ersten PTR-Adresse zu. Und es ist dasselbe wie jetzt PTR hier ist das gleiche wie die Dereferenzierung von PTR blas eins. Und PTR zehn zum Beispiel ist das Gleiche wie die Dereferenzierung der PTR, die zehn verloren hatte. Und das ist der Hauptpunkt hier. Wir können die tiefgestellten zwei benutzen. Operator mit Zeigern, genau wie Arrays, um ein genaues Element zu erreichen oder zu finden. Um die Dinge noch klarer zu machen, warum nicht? Wir versuchen dies an einem praktischen Beispiel. Lasst uns das alles entfernen. Jetzt. Zuerst definiere ich eine Funktion. Und wie die meisten von Ihnen wissen, müssen wir zuerst den Prototyp aufrufen oder einen Prototyp initiieren, um eine Funktion zu definieren . Und dann müssen wir die Funktion, die Funktionsimplementierung, implementieren . Dann müssen wir es anrufen. Fangen wir zuerst mit dem Prototyp an. Nennen wir es lustig. Und hier drin und Sternchen PTR. Diese Funktion nimmt also PTR oder Zeiger als Eingabe an und gibt nichts zurück. Lasst uns nun die Funktionsimplementierung finden. Entfernen Sie dies, fügen Sie zwei geschweifte Klammern hinzu. Hier drin. Wir müssen eine for-Schleife hinzufügen. Innerhalb dieser for-Schleife wird von 0 auf, sagen wir mal, zehn I plus plus plus. Und hier müssen wir print f hinzufügen und hier müssen wir die Werte drucken. Und wir wären zu schwer. Aber anstatt die PTR allein zu bekämpfen, werden wir den tiefgestellten TR verwenden und genau wie bei Arrays hinzufügen. Danach können wir die Funktion aufrufen. Jetzt kommt der Trick. Wenn wir die Funktion aufrufen, übergeben wir nicht, sagen wir einen Wert, wir übergeben eine Adresse, weil wir , wie Sie in der Funktionsimplementierung sehen können, einen Zeiger erhalten. Jetzt erstellen wir ein Array und ARR dann gleich, und geben wir ihm zehn Werte an. Also 12345678910. Um nun eine Adresse an diese Funktion zu übergeben, können wir dies mit dem Array tun. Wie wir bereits erwähnt haben. Wir haben bereits erwähnt, dass das Array oder Array von zehn im Grunde die gleiche Weise ist wie das Aufrufen des ersten Elements in diesem Array. Um also die Adresse des ersten Elements aufzurufen, müssen wir sie mit ARR übergeben , ohne etwas anderes zu schreiben. Dadurch wird sichergestellt, dass der Funk die Adresse des ersten Elements erhält. Und es wird diese Adresse um eins erhöhen, indem sie den PTR Tiefpunkt hier verwendet. Es wird also vom ersten Element zum letzten Element schleifen und dies in Aktion sehen. Lasst uns das speichern und zurückgehen. Jetzt GCC-Arrays, Zeiger. Mal sehen. Wie Sie sehen können, haben wir hier ein Problem, nämlich die Tatsache, dass ich nicht definiert bin. Definieren wir es also. Schon wieder. Jetzt. Wie Sie sehen können, haben wir das Array einfach gedruckt, ohne den Wert dieses Arrays übergeben zu müssen. 12345678910. Und wir übergeben nur die Adresse des ersten Elements dieses Arrays. Wir verwenden den Zeiger-Index , um dieses Array zu durchlaufen , indem wir einfach von einer Adresse zur nächsten zur nächsten wechseln, indem wir einen erhöhen, den PTR mit diesem Diesel oder dem tiefgestellten Operator. Ich weiß, dass die Dinge zu diesem Zeitpunkt etwas verwirrend sein könnten , aber in diesem Beispiel müssen Sie sich dieses Beispiel noch einmal ansehen. Versuchen Sie, diese Lektion mehr als einmal anzusehen , um die darin enthaltenen Informationen zu verdauen. Lassen Sie uns jetzt eine kurze Zusammenfassung machen. Der Name des Arrays ist die Adresse seines ersten Elements. Wenn wir dieses Array haben, dann ist ARR hier die Adresse von Array 0. Wenn Sie nun den Array-Namen oder ähnliches in diesem Fall an diese Funktion übergeben, geben Sie Adresse an Ende weiter. Die Funktion. Der Prototyp sollte mit einem Zeiger als Eingaben deklariert werden. innerhalb der Funktion func Wenn wir jetzt PTR dereferenzieren, greifen wir auf das erste Element des Arrays zu. Und wir können auf das erste Element zugreifen indem wir entweder PDR schreiben, letzte Element, um auf das zweite Element zuzugreifen. Oder wir können einfach PTR benutzen. Und hier verwenden wir Tiefpunkt oder für I. Und wir beginnen mit dem ersten angesprochenen Element. Dann das zweite Element, fügt das dritte Element hinzu. Und ich sage hier, ich würde es nur tun, weil wir es mit Adressen zu tun haben, haben wir es nicht mit Werten zu tun, weil wir gerade die Adresse des ersten Elements erhalten haben und wir schleifen durch die Adressen. Und wir drucken den Wert, diese Adressen verweisen. Das war's. Das ist kein einfaches Beispiel, ich weiß. Aber auch hier sind Operatoren oder sagen wir Zeiger nicht einfach zu erlernen. Deshalb müssen Sie sich diese Lektion mehrmals ansehen , um die darin enthaltenen Informationen zu verdauen. Wenn Sie Fragen haben oder wenn in dieser Lektion etwas nicht klar ist, fragen Sie bitte nach dem Unterkiefer, ich helfe Ihnen gerne weiter. Danke fürs Zuschauen. 8. 9 hängende wilde und Null-Zeiger: Hallo und willkommen zu dieser neuen Lektion , in der wir über baumelnde Zeiger und wilde Zeiger sprechen werden. Ein baumelnder Zeiger zeigt auf eine Speicheradresse, die früher ein Wertvolles enthielt. Da die Adresse, auf die sie zeigt, nicht mehr erhalten bleibt, führt die Verwendung zu einem erwarteten Ergebnis. Also um dies in Aktion zu sehen. Hier drin besteht der erste Schritt darin, einen Zeiger zu erstellen. Also n Asterix PTR. Was wir jetzt tun müssen, ist die malloc-Funktion zu verwenden. Diese malloc-Funktion gibt ungültig zurück. Wir müssen also in ein ganzzahliges Sternchen umwandeln, das der Zeiger auf Integer ist, um den ungültigen Zeiger in einen ganzzahligen Zeiger umzuwandeln. Also geh zurück und schreibe Integer, was im Grunde ein ganzzahliger Zeiger ist. Fahren Sie nun mit dem Modell fort und wir müssen die Größe der Funktion aufrufen. Und wir werden die Größe der Ganzzahl hier lösen. Danach erstellen wir eine Variable, nennen sie a und machen sie gleich 560. Dann müssen wir auf die Adresse von a hinweisen oder auf die Adresse verweisen. Dann verwenden wir diese freie Funktion. Die Funktion wird den Speicher einfach freigeben. Also richtig, sei PTR. Das war's. Jetzt haben wir diesen Zeiger befreit. Wir haben bereits erwähnt, dass der baumelnde Zeiger auf eine Speicheradresse zeigt , die verwendet wird, um die Variable zu halten. Da die Adresse, auf die sie zeigt, nicht mehr reserviert ist, führt die Verwendung zu unerwarteten Ergebnissen. Um Ihnen das unerwartete Ergebnis zu zeigen, können wir Folgendes tun. Wir haben die PTR zugeteilt. So können wir PTR gleich fünf schreiben , um fünf in diesem Dereferenz-Videorekorder zu speichern . Und der letzte Schritt ist das Drucken. Also drucken Sie f. Und hier werden wir den Prozentsatz d verwenden , um die Referenz von PTR zu planen. Jetzt speichern wir den Code. Und hier testen wir den baumelnden Zeiger. Also geh zurück, CLS, GCC. Okay, jetzt das siehst du baumelnde Zeiger c, k. Jetzt haben wir ein Problem. Wir haben vergessen, eine CD live einzubauen. Also lasst es uns einbeziehen. Habe den Code gespeichert und geh zurück. Schon wieder. Hier sind wir. Wie Sie hier sehen können, haben wir diesen Code kompiliert. Lassen Sie uns jetzt eine EXE ausführen. Und wie Sie sehen können, blinkt es. Jetzt haben wir nichts erhalten. Es hätte diese verschiedenen Fronten von PTR drucken sollen. Aber wie bereits erwähnt, haben wir PTR freigegeben. Dies ist also ein baumelnder Zeiger und die Verwendung nach der Zuweisung führt zu unerwarteten Ergebnissen. Das ist es, was ein baumelnder Zeiger ist. Auch hier ist ein baumelnder Zeiger ein Zeiger hinweist , ihn oder die zugewiesenen Objekte zu löschen. Und Sie müssen sicherstellen, dass Sie solche Szenarien nicht verfolgen. Und versuche sie zu vermeiden. Versuche nicht mit Zeigern zu spielen. Sie weisen sie zu oder löschen sie, ohne zu wissen , was Sie tun. Jetzt sind die zweite Art von Zeigern die wilden Zeiger. Lassen Sie uns diesen Teil kommentieren. Während Zeiger ein Zeiger ist, der vor der Initialisierung verwendet wird. Ein Beispiel dafür ist dieses Ende PTR. Wenn wir die Anweisung print f verwenden und versuchen , PTR mit der Dereferenz-PTR zu drucken. Wir haben die PTR noch nicht mit einer Adresse initialisiert. Das nennt man also eine Weile Zeiger. Speichern Sie jetzt Ihre Codes, gehen Sie zurück und kombinieren Sie es und führen Sie dann aus. Wie Sie sehen können, wieder ein unerwartetes Ergebnis, da dies unser Zeiger ist. Wir haben diesen Zeiger nicht initialisiert. Und deswegen stehen wir vor dem. Jetzt. Keine Pfeile gezeichnet, aber wir haben deshalb keine Ergebnisse erhalten. Dieser Zeiger wurde zunächst nicht initialisiert. Wie verwandelt man nun einen gültigen Zeiger in einen anderen? Also während Zeiger, Es ist einfach. Wie Sie sehen können, haben wir den Zeiger bereits erstellt, also müssen wir darauf hinweisen, dass er auf etwas hinweist. Wir können es initialisieren, indem wir einfach eine andere Ganzzahl erstellen, sie aufrufen und ihm einen Wert von zehn geben. Dann werden wir sagen, dass PTR der Adresse von x entspricht . Und jetzt können wir diesen Code erneut ausführen. Wie Sie sehen können, haben wir fünf, was dem Wert von x entspricht. Und das ist jetzt kein wilder Zeiger. Also mussten wir den Zeiger initialisieren , um ihn nicht zu einem wilden Zeiger zu machen. Und so wird es im Grunde genommen gemacht. Lassen Sie uns diesen Teil kommentieren und sprechen wir über eine andere Art von Zeigern, denen es sich um einen Nullzeiger handelt. Um sicherzustellen , dass wir unseren Endpunkt nicht haben , oder wir können einen Zeiger analog initialisieren, was ihn zu einem Nullzeiger macht. Der einfachste Weg , dies zu tun, besteht darin, einfach diesen enden asischen PTR zu kopieren , der die Zeigerinitialisierung ist. Und dann zählst du das richtige Wissen. Das war's. Dies wird als Nullzeiger bezeichnet. Jetzt können wir diesen Zeiger auch drucken. Hände. Sie können sehen, dass wir jetzt spielen und drucken, aber es druckt nichts, weil es ein Nullzeiger und ein leerer Zeiger ist. Nullzeiger zeigt auf nichts oder auf Speicheradresse , auf die Benutzer nicht zugreifen können. In diesem Fall wird dies also als alter Zeiger bezeichnet. Nennen wir das also Wein. Nennen wir das „Dangling und nennen wir diesen Nullzeiger. Nun ist eine andere Art von Zeigern der ungültige Zeiger. Ein ungültiger Zeiger kann verwendet werden, um auf eine Variable eines beliebigen Datentyps zu zeigen. Es kann wiederverwendet werden, um auf jeden Datentyp zu verweisen, den wir wollen. Und es wird leicht deklariert, indem man einen ungültigen Asterixpunkt schreibt oder PTR gleich null ist. Dies wird als ungültiger Zeiger bezeichnet, da sie sehr allgemeiner Natur sind und auch als generische Zeiger bezeichnet werden. Mit ihrer Flexibilität bringen Void-Zeiger auch einige Einschränkungen mit sich. Void-Zeiger können nicht wie jeder andere Zeiger dereferenziert werden. Wenn Sie nun versuchen, einen ungültigen Zeiger zu dereferenzieren, werden Sie am Ende auf einen Fehler stoßen. Wenn Sie arithmetische Operationen für ungültige Zeiger ausführen möchten, müssen Sie diese Zeiger umwandeln. Typecasting ist im Grunde ein anderes Thema, und wir werden es hier nicht behandeln. Aber Sie müssen es typecast, wenn Sie es verwenden und arithmetische Operationen verwenden, Zeiger aus großen Hughes- und C-Bibliotheksfunktionen wie malloc und Calloc, die dramatisch zuweisen Speicher gab ungültige Zeiger zurück. Es gibt auch die Farbtonquelle und die integrierte Sortierfunktion in C, die eine Funktion als Argument hat, die selbst ungültige Zeiger als Argument annimmt. Nun kommen diese hauptsächlich der ungültige Zeiger, Nullzeiger, der wilde Zeiger und der baumelnde Zeiger normalerweise und Interviewfragen und die MCQ-Fragen. Sie müssen also sicherstellen , dass alle diese Entzündungen in einem Notizbuch aufgeschrieben sind, damit Sie sie bei Bedarf überprüfen können. Und Sie müssen sich nicht alle auswendig lernen, aber Sie müssen genau wissen, was jeder von ihnen tut. Lassen Sie uns jetzt eine kurze Überarbeitung machen. Ein baumelnder Zeiger. Der erste ist ein Zeiger hinweist , ihn oder das zugewiesene Objekt zu löschen. Der wilde Zeiger, der der zweite ist, ist ein beliebiger Punkt oder der vor der Initialisierung verwendet wird. Um es nicht zu einem wilden Zeiger zu machen, können wir das einfach mit dem Nullzeiger tun. Und der letzte in unserer Liste wird der void-Zeiger genannt, der ein Zeiger ist , der verwendet werden kann, um auf eine Variable eines beliebigen Datentyps zu zeigen. Es kann auch verwendet werden, um auf jeden Datentyp zu verweisen , den wir verwenden möchten. Es wird deklariert, indem Sie einfach void vor dem Zeigernamen und dem Asterixzeichen eingeben und ihm den Wert null geben. Das war's für diese Lektion. Danke fürs Zuschauen.