Hallo und willkommen zurück.
Ich möchte eine Lösung für anbieten vorherige Herausforderung in dieser Vorlesung.
Eine Demonstration, wie Sie kann Zeiger als Elemente innerhalb der Struktur
haben und auch Übergeben Sie Zeiger zwei Funktionen,
die Strukturen sind.
Lassen Sie uns also den Code aufrufen Blöcke, erstellen Sie ein neues Projekt.
Dies wird eine Konsole sein Anwendung, und wir werden
dieses Beispiel für Strukturzeiger benennen.
Und wenn Sie sich für die erinnern Voraussetzungen
hierfür war dies im Grunde nur ein Produkttyp Struktur, in der ein Artikelname, eine Menge, ein Preis
und eine Menge gespeichert sind.
Und der Artikelname ging ein Zeichenzeiger sein.
Du würdest eine haben Menge, die im Grunde nur die
Menge im Preis multipliziert.
Und dann hatten wir zwei Funktionen das wird als Parameter Zeiger
auf eine Struktur nehmen.
Also das erste, was wir sind Wir
werden unsere Struktur schaffen.
Und ich habe das schon früher erwähnt, aber Es ist
gut, die Struktur global zu erstellen, denn wenn Sie möchten Verwenden Sie es in mehreren Funktionen.
Struktur erstellen definiert es wirklich.
Sie weisen keinen Speicher zu.
Es gibt also keinen Schaden global ausgedrückt.
Und sie gehen normalerweise hinein die Header-Datei sowieso.
Um eine Struktur zu schaffen, wir sagen nur struct.
Wir werden diesen Artikel nennen, und Wir werden vier Elemente haben.
Wir werden einen Charakter haben Zeiger, den wir nur als
Elementnamen bezeichnen werden.
Wir werden eine Menge haben.
Wir werden einen Wagen haben für den Preis, und wir werden einen
Float für den Betrag haben.
Und so können wir definieren unsere Struktur, ziemlich einfach.
Jetzt innerhalb unserer Hauptfunktion, wir Ich möchte eine Variable für den Strukturtyp und auch
einen Zeiger erstellen.
Also das erste, was wir tun wollen ist, wir wollen nur struct item mit dem
Namen der Struktur und sagen dann nennen wir diesen Artikel einfach.
Und das ist gerecht Erstellen eines ungeraden Zeigers.
Dadurch wird Speicher zugewiesen für die vier Variablen und Elemente
innerhalb der Struktur.
Und so wollen wir unseren Zeiger erstellen jetzt, und wir können einfach struct item sagen.
Wir werden p Punkt sagen weil wir unsere Zeiger normalerweise
mit dem Präfix p benennen.
Also sagen wir das Sternchen, und wir sagen p item.
Und dann in der nächsten
Zeile, Wir möchten nur unserem Zeigerelement, unserem Element, zuweisen.
Also müssen wir die verwenden Adresse von und wir sagen Artikel.
Und so haben wir hier Erinnerung zugewiesen für Elemente in unserer Struktur für
unseren Zeiger.
Wir haben kein Gedächtnis zugewiesen für unseren Zeichenzeiger,
der unser Artikelname ist, Das wäre also der nächste Schritt.
Jetzt fragen Sie sich vielleicht, warum wir brauchen um die Item-Struktur zu erstellen.
Wir nicht wirklich.
Wir könnten einfach den Zeiger erstellen und Der Zeiger erstellt nur
Speicher für diesen Strukturelementzeiger.
Es wird Speicher für die zuweisen int und
float, aber wir müssen noch die Zuweisung des Artikelnamens vornehmen.
Ich mache das einfach gerne, weil Dies ist normalerweise die gute Praxis.
Normalerweise, was Sie damit machen würden Die erste Elementstruktur ist, dass Sie sie
initialisieren würden, und Sie auch hätte eine Initialisierung.
Aber das müssen wir nicht tun.
Das erste, was wir tun wollen, ist Ordnen Sie Speicher für unseren Artikelnamen zu.
Wir können also grundsätzlich a verwenden spezieller Operator für den Zugriff auf Elemente, wenn es sich
um einen Zeiger handelt.
Denken Sie daran, für Strukturen, die Sind Zeiger, haben Sie den Bindestrich dann größer als
das Symbol, das Sie kann verwenden, um auf die Elemente zuzugreifen.
Andernfalls müssten Sie die Referenz aufheben der Zeiger für den Zugriff auf die Elemente.
Wir könnten so etwas tun dies in Klammern.
Wir könnten den Zeiger de-referenzieren, Also müssten
wir so etwas wie star p item machen und dann verwenden der Punkt für den Zugriff auf Elemente.
Dies ist vollkommen gültig so etwas zu tun.
Aber es ist eine Art zusätzliche Syntax das brauchst du nicht wirklich.
C hat also eine spezielle Syntax Sie können verwenden, wann immer Ihre Struktur ein Zeiger
ist, wenn Sie möchte auf die Elemente zugreifen.
Sie können im Grunde nur den Namen sagen des Zeigers, der p Element ist und dann den
Bindestrich verwenden, dann größer als.
Und in diesem Fall wollen wir Ordnen Sie Speicher für den Elementnamen zu.
Also werden wir ihm zuweisen, was ist von der Malloc-Funktion zurückgegeben.
Denken Sie daran, die Malloc-Funktion Gibt einen ungültigen Zeiger zurück.
Also müssen wir es besetzen zu einem Charakterstern.
Aber wir können einfach Malloc nennen Sagen Sie Malloc und dann die Größe der
Bytes, die wir erstellen möchten.
In diesem Fall sagen wir einfach 30, und wir multiplizieren es mit der Größe von char, nur
für den Fall, dass char a ist unterschiedliche Größe auf unterschiedlichen Computern.
Und das wird zuteilen Speicher für unseren Artikelnamen.
Wir müssen dies tun, weil der Artikelname ist ein Zeiger innerhalb der Struktur.
Es hat kein Gedächtnis zugewiesen, wenn Sie
es einer anderen Struktur zuweisen.
Also müssen wir das tun.
Jetzt das erste was du willst Nachdem
Sie den Speicher zugewiesen haben, überprüfen Sie das Malloc.
Deshalb möchten wir hier nach Null suchen.
Wir werden nur sagen, ob p Artikel, wenn Es ist null, was bedeuten würde, dass es null ist.
Andernfalls würden Sie sagen, wenn nicht, könnten Sie Sagen Sie einfach, dass Return oder Exit wahrscheinlich besser wäre. Beenden Sie
das Programm, wenn wir konnten keinen Speicher zuordnen und Sie konnten ihn
in einen negativen übergeben.
Ansonsten wollen wir in einlesen Artikel, also wollen wir eine Funktion erstellen.
Die Funktion, die wir gehen zu erstellen heißt read item.
Lassen Sie uns eine Funktionsdeklaration erstellen hier oben über der Struktur.
Es wird nur Daten einlesen in die Struktur, die wir an sie übergeben haben.
Es werden keine Daten zurückgegeben.
Wir können also einfach "Artikel lesen" sagen und es braucht eine Struktur, und das wird ein Zeiger
sein.
Es ist also ein Strukturelement, Sternchen I.
Jetzt könnten wir dies zu einer Konstante machen Die Werte ändern sich
also, aber wir ändern die Werte.
Aber wir könnten konstante Struktur sagen, die Die Werte für den Zeiger, auf den
er zeigt, können sich nicht ändern.
Wenn wir die Konstante danach machen würden das Sternchen, das heißt, die Adresse kann sich nicht
ändern oder richtig vor dem Sternchen so etwas nach
dem Namen.
Das würde sagen, die Adresse kann nicht ändern,
aber das ist überflüssig, weil wir den Kopierwert übergeben.
Wir haben unseren Artikel gelesen.
Und während ich hier oben bin, könnte ich ebenso mein Druckartikel.
Das wird nur die Funktion sein Deklaration, Funktionsprototyp.
Hier wird es sehr ähnlich, nimm auch einen Zeiger.
Kann ein Leerzeichen haben, wenn Sie wollen nach dem Sternchen oder nicht?
Jetzt können wir unser Lesen definieren Artikel unter unserer Hauptmethode.
Und das wird lesen in Werten des Artikels und berechnen
Sie dann den Gesamtbetrag.
Wir können also sagen, nichtig lesen Artikel, haben unseren Zeiger.
Und hier drinnen wollen wir einfach nur um einige scanfs wirklich zu benutzen.
Wir werden einige Nachrichten ausdrucken um den Benutzer anzuweisen, Informationen einzugeben.
Also werden wir eintreten sagen Produktname, und dann werden wir es
einlesen.
Also werden wir scanf sagen, und wir haben einen Zeiger auf eine Struktur, damit wir darauf
zugreifen können mit dem Bindestrich dann größer als.
Wir wollen für scanf, das einlesen Der Produktname ist ein Zeichenpuffer.
Also wollen wir Prozent s und sagen dann werden wir sagen, ich werde es
im Artikelnamen speichern.
Und wir könnten zurückgehen und das benutzen Intellisense gehen Sie einfach zum Elementnamen.
Wir müssen das nicht benutzen Adresse des Operators, da es sich
um einen Zeichenzeiger handelt.
Wir wollen dann ausdrucken und bekommen Der Preis,
wahrscheinlich möchten Sie hier einige Zeilenvorschübe hinzufügen, geben Sie den Preis ein.
Wir werden speichern das in der Struktur.
Der Preis ist also wieder ein Float.
Also werde ich Prozent f sagen, aber Wir werden auch darauf zugreifen, weil es ein Zeiger ist, den wir immer noch
wollen Verwenden Sie den Bindestrich dann größer als.
Außer diesmal werden wir Sagen Sie Preis, und wir müssen die Adresse davon bekommen, also werden wir Stellen
Sie ein kaufmännisches Und davor, da der Preis
kein Zeiger ist.
Und dann machen wir das Gleiches gilt für die Menge.
Quantität ist also eine ganze Zahl.
Wir können also sagen, Prozent d brauchen wir noch um die Adresse zu
erhalten, aber wir möchten es in einem anderen Element speichern, wir wollen es in der Menge lagern.
Jetzt, wo wir gespeichert oder gefragt haben Wenn der Benutzer drei
Informationen eingibt, können wir dies jetzt tun tatsächlich den Betrag berechnen, etwas in
dem Betrag gespeichert.
Die Menge ist nur die Menge mal Preis.
Wir wollen also immer noch auf die zugreifen Struktur mit unserer Syntax, wir
wollen es umwandeln, wir wollen signieren die Menge mal der Preis.
Und das ist die Funktion zum Lesen von Elementen.
Nimmt einen Strukturzeiger.
Und wenn wir diesen Zeiger ändern Innerhalb des gelesenen Elements wird
es außerhalb der Funktion geändert.
Also welche Struktur wir auch haben Übergeben Sie diese Funktion, sie
wird geändert.
Es wird alles speichern Artikel, der Artikelname, Preis und
Menge und Menge.
Das liest also die Daten ein.
An diesem Punkt möchten Sie test und du willst wahrscheinlich
vorher kompilieren und testen.
Aber wir können jetzt das gelesene Element aufrufen Methode in unserem Haupt und übergeben Sie es
in unserer Struktur, die wir erstellt haben.
So können wir lesen Artikel lesen, und wir können einfach p item sagen.
Wir müssen nicht in der übergeben Adresse, weil es ein Zeiger ist,
also übergeben wir einfach unsere Struktur.
Und dann das nächste was wir Wir können es ausdrucken.
Und was dies Ihnen zeigen wird, ist Damit die Daten gespeichert werden, wird
das Element p innerhalb der Funktion geändert und es wird außerhalb der Funktion, der
Hauptfunktion, gespeichert hat diese Werte tatsächlich gespeichert.
Wir können also sagen, dass Artikel gedruckt werden wieder im Zeiger, und dann können wir die
Druckelementfunktion definieren.
Druckartikel ist ziemlich einfach.
Es gibt nichts zurück, Also sagen wir nichtig und wir
sagen, dass das Druckelement einen Zeiger benötigt.
Also sagen wir einfach struct item star Ich, wie auch immer du es nennen willst.
Und dann drucken wir einfach die Daten aus für die Struktur, die übergeben wurde.
Also würden wir so etwas machen printf name prozent s, ich artikelname, ich preis, ich
menge und ich Menge und dann formatieren wir die Daten.
Was ist das Letzte, was wir haben?
Nachdem wir die Daten ausgedruckt haben, tun wir dies in der Hauptsache wirklich wichtige freie Funktion.
Wir müssen frei anrufen, weil wir Sie möchten den Speicher freigeben, den wir für
den Elementnamen zugewiesen haben.
Also können wir einfach kostenlos p Artikel sagen und greifen Sie dann auf den Artikelnamen zu.
Wir wollen nicht das Ganze befreien Struktur,
da die gesamte Struktur auf der gelöscht wird Stapel, wenn die Funktion zurückkehrt.
Wir wollen nur befreien, was wir malloced haben.
Wir haben nur für Artikel malloced Name, damit wir das befreien, und dann kehren
wir von der Hauptleitung zurück.
Also lass uns weitermachen und versuche das zu bauen.
Und wir haben einen Fehler.
Mal sehen, es heißt struct item star.
Also hatten wir einen Fehler wo Die Funktionen wurden über der
Struktur definiert.
Aber die Funktion, a Parameter als Strukturtyp.
Wir müssen also die Struktur haben oben definiert, wo wir es verwenden.
Also verschiebe ich die Funktionen bis zu den Zeilen 12 und 13.
Jetzt können wir kompilieren.
Lassen Sie uns fortfahren und dies ausführen.
Und mal sehen, was wir hier bekommen.
Wir haben noch einen Fehler.
Sie müssen sicherstellen, dass Sie Überprüfen Sie das p-Element auf null.
Wenn Sie nur sagen, ob p Artikel für wahr, es wird immer wahr sein.
Sie können also entweder überprüfen, um zu sagen Es ist nicht wahr, wenn das
Symbol nicht bedeutet, dass es nicht null ist oder Sie kann überprüfen, ob es null ist.
Also habe ich dort einfach die Null hinzugefügt.
Also jetzt führen wir es, wir sollte gut zu gehen sein.
Wir können den Produktnamen eingeben.
Wir werden seriell sagen und wir werden Sagen wir, der Preis ist 1. 99.
Und wir werden sagen, wir haben fünf davon.
Und jetzt drucken wir es aus, und wir sagen Seriendollar 99.
5 ist der Gesamtbetrag 9. 95.
Den Preis mag ich allerdings nicht wie der Preis ausgedruckt wird.
Also lasst uns das beheben.
In unserem Druckartikel können wir nur für sagen Preis für 2 f schwimmt, jetzt sehen
wir ein bisschen besser aus und lassen es laufen.
Wir werden ein wenig bekommen etwas besseres Format.
Vier von ihnen und jetzt ist es soweit sieht ein bisschen besser aus
und alles ist gut zu gehen.
Also nochmal Basisprogramm mit Strukturen und Zeiger.
Wir haben die Struktur oben erstellt.
Wir haben ein Mitglied, das enthält Ein Zeiger, das ist
sehr effizient, weil wir es können Kopieren Sie einfach und adressieren Sie
im Gegensatz zu Zeichenarrays.
Wir haben unsere zwei func Erklärungen, Element lesen Druckelement,
das Zeiger zerstört.
Und dann erstellen wir den Zeiger und ordne es einer regulären Struktur
innerhalb unserer Hauptleitung zu.
Wir ordnen Speicher in Zeile 22 zu.
Wir stellen sicher, dass die Erinnerung ist erfolgreich zugewiesen, wenn es nicht war,
beenden wir das Programm.
Und dann rufen wir unsere beiden an Funktionen, die Zeiger
auf Strukturen nehmen, übergeben diese.
Und zu guter Letzt: Wir geben den Speicher frei und beenden
das Programm.
Und die Funktionen sind ziemlich einfach.
Sie nehmen diesen Zeiger.
Sie greifen mit auf den Zeiger zu der Bindestrich dann größer als.
Und Sie erhalten die Adresse von es für scanfs, die keine
Zeiger als Elemente haben.
Und das war's auch schon.
Ich werde dieses Programm speichern, Sie sehen es sich an.
Lassen Sie mich wissen, wenn Sie Fragen haben. Vielen Dank.