Hallo und willkommen zurück.
In dieser Vorlesung möchte ich über den Anwendungsfall für
Zeiger sprechen, wenn wir sie verwenden, wie wir sie verwenden werden. Wir wissen, wie man sie erstellt.
deklarieren Sie sie und definieren Sie sie.
Wir wissen, wie man ihnen die Adresse einer vorhandenen Variablen anhand der Adresse des Operators zuweist.
Und wir wissen, wie man sie de-referenziert,
wie man den Wert erhält, auf den der Zeiger zeigt.
Wie fangen wir nun tatsächlich an, sie zu verwenden?
Daher bietet c einige grundlegende Operationen, die Sie für Zeiger ausführen können.
Sie können einem Zeiger, den wir bereits
kennengelernt haben, eine Adresse zuweisen.
Dies ist eine vorhandene Variable, bei der die Variable eine Adresse hat.
Und Sie sehen sich nur die Adresse dieser Variablen an, indem Sie die Adresse des Operators verwenden,
und wir haben einen Punkt dazu. Wir könnten auch einen vorhandenen Zeiger einem anderen Zeiger zuweisen.
Das sind zwei Möglichkeiten, wie Sie einem Zeiger eine Adresse zuweisen können.
Es kann also ein Array-Name für sich sein.
Wir haben noch nicht über Arrays gesprochen, aber wenn Sie einem Zeiger eine
Erhöhung zuweisen, müssen Sie nur den Namen angeben. Sie müssen nicht einmal die Adresse des Betreibers verwenden.
Bisher haben wir uns nur darauf konzentriert, eine vorhandene Variable zu verwenden
und die Adresse der Variablen selbst zu übergeben.
Aber die 3 Möglichkeiten, wie Sie es tun können, werden dort erwähnt.
Sie können auch einen Zeiger dereferenzieren. Wir haben gerade erfahren, dass Sie dort das
Sternchen des Indirektionsoperators verwenden.
Dadurch erhalten Sie den Wert, der im Zeiger auf gespeichert ist. Der Zeiger Der Wert des Zeigers,
der eine Adresse ist, auf die der Punkt zeigt,
verwenden Sie einfach diese. Sie können auch eine Zeigeradresse verwenden.
Dies ist die tatsächliche Adresse des Zeigers, wenn Sie den Zeiger
erstellen, in dem der Zeiger selbst gespeichert ist.
Sie können auch die Adresse verwenden, die ich als Operator für diesen Zeiger habe.
Sie können auch Zeigerarithmetik ausführen. Wir werden einen separaten Vortrag darüber halten.
Hier können Sie die Plus- und Minusoperatoren
verwenden, um einem Zeiger entweder Ganzzahlen hinzuzufügen oder Ganzzahlen von einem Zeiger zu subtrahieren.
Auf diese Weise können Sie eine bestimmte Notation
verwenden und schneller im Speicher herumspringen, insbesondere wenn Sie Arrays verwenden.
Wenn Sie also einem Zeiger mit dem Plus-Operator
eine Ganzzahl hinzufügen, wird
die Adresse
dieses Zeigers nur um so viele Bytes erhöht.
Wenn Sie eine
Zahl von einem Zeiger subtrahieren, wird
diese Adresse auf minus eine bestimmte Anzahl von Bytes gesetzt.
Sie können die Dekrementierung auch um eins erhöhen, und
Sie werden feststellen, dass dies sehr häufig vorkommt, wenn wir es in Arrays verwenden.
Wenn Sie sich also in einem Array befinden und zum nächsten Element wechseln möchten, anstatt den Index zu verwenden, können
Sie einen Zeiger verwenden und ihn einfach um eins erhöhen.
Wenn Sie zum vorherigen Element wechseln möchten, anstatt einen Index zu verwenden, können
Sie ihn einfach um eins dekrementieren.
Zeigerarithmetik, wir werden ausschließlich darüber sprechen, aber das ist etwas,
was Sie mit Zeigern tun können.
Und wieder ist es eine bestimmte Notation, die es Ihnen ermöglicht, sich schnell
im Speicher zu bewegen und
effizienter zu sein.
Sie können auch den Unterschied zwischen 2 Zeigern finden.
Wenn Sie also zwei Zeiger haben und sich die Elemente im selben Array befinden,
möchten Sie vielleicht herausfinden, wie weit sie voneinander
entfernt sind, die Elemente, die Sie abziehen können.
Dies wäre die Differenz von
2 Zeigern und. Wenn Sie also Index 5 sind und dann
einen Zeigerpunkt in Index 5 haben, haben Sie einen anderen Zeiger auf Index 15, der auf
Index 15 zeigt. Sie könnten sie minus und
das würde Ihnen geben,
wie viele Elemente sie entfernt sind, weil es so wäre Die hexadezimale Adresse abzüglich der
anderen hexadezimalen Adresse unter der Annahme, dass sich das Array
im kontinuierlichen Speicher befindet, zeigt an, wie weit sie voneinander entfernt sind.
Sie können Vergleichsoperatoren verwenden, um die Werte von 2 Zeigern zu vergleichen.
Zeiger müssen vom gleichen Typ sein. Wenn beide auf Ganzzahlen zeigen, müssen beide vom
gleichen Typ sein.
Hier erfahren Sie nur, ob die Adressen größer oder kleiner als sind.
Auch hier können Sie feststellen, in welchem Teil des Arrays Sie sich befinden.
Es gibt auch 2 Formen der Subtraktion.
Ich habe gerade über Subtraktion gesprochen,
bei der Sie tatsächlich einen Zeiger nehmen und von einem anderen subtrahieren
können, wodurch Sie
einen Zeiger erhalten, oder Sie können einen Zeiger von
einer Ganzzahl subtrahieren, wodurch Sie einen Zeiger erhalten.
Subtrahieren Sie also einen Zeiger von einem anderen, um eine Ganzzahl zu erhalten, oder
subtrahieren Sie eine Ganzzahl von einem Zeiger, um einen Zeiger zu erhalten. Das sind die 2 Fälle.
Wir werden also daran denken, dass wir noch einige Beispiele durchgehen werden.
Seien Sie vorsichtig, wenn Sie die Inkrementierung oder Dekrementierung von Zeigern verwenden und
das Array außerhalb der Grenzen halten. Das meiste, was Sie mit
Zeigerarithmetik machen, ist, wenn Sie mit Arrays arbeiten.
Da es Ihnen wiederum ermöglicht, sich schnell zu bewegen, ist es eine einfache Syntax.
Denken Sie jedoch daran, dass die Arrays einen Fehler außerhalb der Grenzen aufweisen.
Wenn Sie also zu weit inkrementieren, werden Sie
die Grenzen im Array überschreiten. Wenn Sie zu weit dekrementieren,
haben Sie eine Untergrenze, Sie gehen in eine negative Zahl.
Der Computer selbst wird nicht verfolgen, ob ein Zeiger noch auf ein Array-Element zeigt.
Wenn Sie also den Punkt der Arithmetik für Arrays verwenden, müssen Sie vorsichtig sein.
Wenn Sie Zeiger verwenden möchten, die in Ausdrücken verwendet werden, können Sie dies auch tun.
Also haben wir etwas früher darüber gesprochen und den Zeiger dereferenziert und
15 hinzugefügt. Ich denke wir haben 20.
Der Wert des pi-Zeigers kann also in arithmetischen Ausdrücken verwendet werden.
Wenn also eine Variable als Zeiger auf eine Ganzzahl definiert ist,
wird sie nach den Regeln der Ganzzahlarithmetik ausgewertet.
Und das haben wir mit der Dereferenzierung gezeigt. Wenn Sie also
eine Variable und einen Zeiger haben, initialisieren Sie ihn auf null und
signieren Sie dann die Adresse dieser Zeigerin. Sie können dann einfach sagen, Sternzahl plus gleich 25.
Denken Sie daran, dass die Sternnummer den Wert erhält, auf den sie zeigt.
Dies bedeutet also, dass der Wert von pnumber gleich
dem Wert pnumber plus 25 ist.
Der Wert wird also gleich 35 sein.
Dies ändert nichts an dem, worauf es zeigt, weil wir ein Sternchen verwenden. Es ändert also nicht
die Adresse, auf die wir zeigen, es ändert
nicht die Adresse selbst, weil wir nicht die Adresse des Operators haben.
Wir ändern den Wert, auf den es zeigt.
Wenn Sie also den Wert der Zahlenvariablen um 25 erhöhen, zeigt der Stern an, dass Sie nach
dem Inhalt fragen, auf den die Variable mit dem Namen pnumber zeigt.
Wenn ein Zeiger auf die Variable x
zeigt, wurde dieser Zeiger als Zeiger auf denselben Datentyp wie x definiert.
Wenn Sie also einen Endzeiger, einen Gleitzeiger, erstellen, können
Sie nur eine Adresse eines
Datentyps haben, der float oder int ist, je nachdem, welchen Sie deklariert haben.
Die Verwendung des Indirektionsoperators in einem Ausdruck
ist also identisch mit der Verwendung von x in demselben Ausdruck.
Und das ist alles, was es heißt: Wenn Sie einen Float verwenden oder einen Int
haben und den Indirektionsoperator verwenden, dereferenzieren Sie ihn, können Sie alles tun, was
Sie können, wenn Sie einen Float darin haben, auf was auch immer er zeigt.
Eine Variable, die als Zeiger auf ein int definiert ist, kann die Adresse jeder
Variablen vom Typ in speichern, das wissen wir.
Wenn also der int-Wert gleich 999 ist, können wir diesen int der pnumber zuweisen,
solange pnumber ein Zeiger auf einen int ist, und dann
können wir ihn hinzufügen.
Die Anweisung arbeitet mit dem neuen Variablenwert
und der neue Inhaltswert ist 1024.
Die Nummer zeigt auf den Wert,
die Adresse des Wertes. Wenn Sie also den Zeiger
ändern, auf den er zeigt, ändern Sie den Wert dieses Variablenwerts.
Denken Sie also daran, dass dies das Konzept ist, eine Variable an einer Stelle des Zeigers
zu ändern, und dass Sie sie in mehreren Variablen ändern.
Ein Zeiger kann die Adresse einer beliebigen Variablen des entsprechenden Typs enthalten.
Sie können also eine Zeigervariable verwenden, um die Werte vieler verschiedener Variablen zu ändern,
wenn Ints, Doubles oder Floats vorhanden sind. Solange es sich um den Typ handelt, der mit dem
Zeigertyp kompatibel ist, können Sie diesen Wert ändern. Sie können den Wert von
pnumbers nicht ändern, wenn pnumber auf ein Float zeigt und der
Wert eine Ganzzahl ist. Das würdest du nicht können. Sie hätten einen Kompilierungsfehler.
Ein weiteres Beispiel hier. Hier zeigen wir Ihnen,
wie Sie die Adresse einiger Variablen erhalten. Hier in diesem Hauptteil führen wir
also eine Zeigerarithmetik
für die tatsächlichen Ausdrücke durch.
Wir machen also nichts auf dem Array, also inkrementieren oder dekrementieren wir keine
Zeiger darin. Wir dekrementieren also die Werte. Wir haben also 2
lange Typen num1 und num2 und dann haben wir einen Zeiger vom Typ long, wir initialisieren ihn auf null.
Wir weisen unserem Zeiger pnum die Adresse num1 zu.
Und dann weisen wir L den Wert von pnum zu,
was bedeutet, dass num1 jetzt 2l sein wird.
Wenn wir num2 erhöhen, hat num2 jetzt noch
nichts getan.
Der Wert von pnum ist also 2l, das heißt, der Wert von num1 ist 2l.
L ist nur das Suffix, um anzuzeigen, dass es lang ist.
Wenn wir jetzt den langen num2-Wert erhöhen, ist es
0l, es wird 1l sein.
Wenn wir sagen, dass num2 plus gleich
Stern pnum ist, ist pnum 2l, also wird es
1l plus 2l sein, num2 wird jetzt gleich 3l sein.
Und wenn wir dann pnum die Adresse von num2 zuweisen, wird
pnum jetzt gleich der Adresse von num2 sein.
Wenn wir also pnum erhöhen,
auf das wir zeigen, haben wir jetzt 4l.
Und wir werden uns das in kalten Blöcken ansehen, aber
ich begleite Sie durch die Blöcke. Num1 wird gleich 2l sein.
Num2 wird gleich sein, wenn es
auf pnum zeigt.
Pnums 3l, also denke ich, dass es 3l sein wird.
Pnum wird 3l sein, und dann wird pneum plus num2
6l sein.
Mal sehen, ob ich Recht habe, gehen Sie dies in Codeblöcken durch.
Hier sind wir also in Codeblöcken und haben versucht, dies von Hand durchzugehen, aber
jetzt wollen wir sehen, ob wir Recht haben. Verwenden wir den Debugger.
Wir werden dies hier korrigieren und im Verlauf des Programms sehen, wie sich die Werte ändern.
Lassen Sie uns dies erstellen und debuggen.
Dies wird beginnen und bei Zeile 10 aufhören.
Und wenn wir unser Überwachungsfenster aufrufen, was wir
tun können, indem wir Windows-Uhren und -Uhren debuggen, können wir die Werte
so sehen, wie sie sind. Im Moment ist
also num1 Null, num2 ist Null, pnum zeigt auf Null.
Deshalb ist es 0x0, weil
wir wissen, dass null 0 in pnumber darstellt.
Und das können wir verwenden, wenn wir es in if-Anweisungen vergleichen.
Nachdem wir Zeile 10 ausgeführt haben, sollte pnum nun die Adresse num1 haben.
Also lasst uns einfach rübergehen.
Jetzt hat pnum eine aktuelle Adresse 0x60ff08.
Nachdem wir Zeile 11 ausgeführt haben, werden wir sagen, dass der Wert von pnum gleich 2l ist, und wir
werden dafür tatsächlich nichts im Überwachungsfenster sehen. Aber lassen Sie uns fortfahren und es ausführen, pnum
hat immer noch die gleiche Adresse.
Num1 wird jetzt geändert, da pnum die Adresse num1
hatte und wir sie geändert haben.
Also ist jetzt num1 2. In Zeile 12 erhöhen wir nun num2.
Also wird num2 nur 1l.
Es wird 1 sein. Die Adresse von pnum ist immer noch dieselbe.
Jetzt werden wir num2 hinzufügen, was auch
immer pnum war. Denken Sie daran, dass
num1 auf num1 zeigt, also sollte num2 3 sein.
Dann gehen wir zu 14, num2 ist 3, num1 ist immer noch 2.
Jetzt in Zeile 15 werden wir
pnum eine neue Adresse von num2 zuweisen. Danach werden
wir nicht mehr 0x60ff08 sein.
Wir werden 060ff04 sein.
Wenn wir also den Wert erhöhen, auf den pnum zeigt, auf den Nummer
2 und Nummer 2 3 ist, sollte Nummer 2 jetzt 4 sein.
Und wir sehen, es ist 4.
Jetzt werden wir alle diese Werte ausdrucken und Sie werden sehen, dass der Wert von num1
2 sein sollte.
Der Wert von num2 sollte 4 sein.
Pnum zeigt auf num2, also sollte das noch 4 sein.
Und dann werden wir sagen, dass der Wert von pnum, der 4 plus
ist, num2, der 4 ist, 8 sein sollte.
Also könnte ich tatsächlich mit 6 weg gewesen sein.
Jetzt können wir das im Überwachungsfenster nicht mehr sehen. Spielen wir es also
einfach ab und sehen die Ausgabe als printf-Anweisungen. Wir sollten 2448 sehen.
Lassen Sie uns dies jetzt im Nicht-Debug-Modus ausführen,
und wir sehen 2 4 4 8.
Also los geht's. Ich hoffe das hat Sinn gemacht.
Gehen wir zurück und setzen unsere Diskussion fort.
Wie wäre es also, wenn wir Eingaben erhalten, wie können wir Zeiger auf diese Weise verwenden?
Wenn wir bisher scanf zur Eingabe von Werten verwenden, müssen wir den kaufmännischen Und-Operator verwenden,
wenn wir einen Inter- oder Float-Datentyp haben. Das einzige Mal, dass wir es haben, ist,
wenn wir ein Zeichenarray hatten, und der Grund dafür ist, dass das Zeichen
a tatsächlich ein Zeichenzeiger ist, über den wir sprechen werden.
Wenn wir jedoch scanf zur Eingabe von Werten verwenden und diese für
normale Datentypen verwenden, die keine Zeichenarrays sind, mussten wir immer diesen Addier- oder Unteroperator verwenden.
Und der Grund dafür ist das zweite Argument von scanf, ein Zeiger.
Also müssen wir ihm eine Adresse schicken. Zeiger haben nur Adresswerte.
Wenn Sie also einen Zeiger haben, der bereits eine Adresse enthält, können Sie den Zeigernamen als Argument für scanf verwenden.
Jetzt müssen Sie den kaufmännischen Und-Operator nicht mehr verwenden, wenn Sie tatsächlich einen
Zeiger erstellt haben, da das zweite Argument für scanf ein Zeiger ist und
Sie einfach den Zeigernamen sagen können.
Wenn wir in der Vergangenheit einen Wert im Wert speichern wollten,
hätten wir im zweiten Argument
von scanf den Wert für kaufmännisches Und angegeben.
Wenn wir jedoch einen Zeiger haben, den wir erstellen, und der
bereits wie in diesem Beispiel auf eine
Adresse verweist, müssen wir bei Verwendung von scanf nur den Namen des Werts und den
Namen des Zeigers angeben.
Hier ist also ein Fall, in dem wir eine Ganzzahl haben,
aber kein kaufmännisches Und verwenden müssen, weil wir einen Zeiger auf eine Ganzzahl haben.
Wir sagen nur Prozent d, p Wert.
Es gibt also andere Zeiten, in denen Sie neben
Zeichenarrays auch reguläre Namen von Variablen an scanf übergeben können, wenn Sie
einen Zeiger haben.
Sie können auch ausdrucken, was sie anschließend eingegeben haben, und Sie werden feststellen,
dass der Wert tatsächlich in den von ihnen eingegebenen Wert geändert
wird, da wir auf diese Adresse verweisen.
Testen auf Null.
Es gibt eine Regel, die Sie in Ihr Gedächtnis einbrennen müssen. Das ist sehr sehr wichtig.
Wir haben über Dereferenzierung gesprochen, aber was passiert, wenn Sie einen
unbeabsichtigten Zeiger dereferenzieren, einen Zeiger, der auf nichts zeigt,
oder einen Zeiger, dem kein Speicher zugewiesen ist.
Was ist, wenn wir so etwas tun? Wir deklarieren einen
Zeiger, haben ihn jedoch nie initialisiert und versuchen dann, ihn zuzuweisen.
Wir verweisen darauf und weisen es zu, das ist ein großer Fehler.
Die zweite Zeile bedeutet also im Grunde, dass
Sie den Wert 5 an der Stelle speichern möchten, auf
die pt zeigt, aber pt zeigt auf nichts, weil es nicht initialisiert wurde.
Also wird pt jetzt einen zufälligen Wert haben.
Es ist also nicht bekannt, wo 5 platziert werden, es könnte irgendwo im Speicher platziert werden.
Dies könnte harmlos sein. Möglicherweise werden
vorhandene Daten oder vorhandene Statusvariablen in Ihrem Programm überschätzt.
Dies kann zum Absturz des Programms führen. Es ist sehr problematisch.
Wenn Sie also einen Zeiger erstellen und Speicher zum Speichern des Zeigers selbst zuweisen, wird
kein Speicher zum Speichern der Daten zugewiesen.
Wenn Sie also instar pt sagen,
wird dem Zeiger Speicher zugewiesen, aber es wird
kein Speicher für den Wert des
Zeigers, die Adresse, zugewiesen. Denken Sie daran, Zeiger enthalten Adressen.
Es hat den Zeiger erstellt, aber es wurde kein Speicher für das erstellt, auf das es zeigt.
Sie können es also nicht dereferenzieren.
Es wird also kein Speicher zum Speichern der Daten zugewiesen.
Bevor Sie einen Zeiger verwenden, sollte ihm ein Speicherplatz zugewiesen werden, der bereits zugewiesen
wurde, oder Sie müssen die dynamische Speicherzuweisung mit malloc verwenden, über die wir sprechen.
Sie weisen dem Zeiger also entweder die Adresse einer vorhandenen Variablen zu
oder Sie verwenden sie malloc, das ist dynamische Speicherzuordnung.
Aber denken Sie daran, wann immer Sie einen Zeiger verwenden, wenn Sie ihn erstellt
haben und er null war. Sie möchten ihn vorher auf
null prüfen. Wir werden gleich darauf eingehen. Wenn Sie jedoch einen Zeiger erstellt
haben, der nicht initialisiert wurde, weisen Sie ihm nichts zu,
es sei denn, er zeigt entweder auf eine andere auf diese Weise initialisierte Variable oder weist Speicher zu.
Hier kommt also null ins Spiel.
Sie können tatsächlich auf null testen, um
sicherzustellen, dass Sie keinen Dereferenzierungsfehler haben. Stellen Sie sicher, dass Ihr Programm nicht abstürzt.
Wir wissen also bereits, dass null grundsätzlich auf
nichts zeigt, und wir sollten alle unsere Variablen, unsere Zeiger
auf null, initialisieren.
Also sollten wir immer so etwas tun.
Null ist ein spezielles Symbol in c, das den Zeiger darstellt, der
Null mit gewöhnlichen Zahlen entspricht.
Im Folgenden wird auch ein Zeiger mit Null auf Null gesetzt.
Wenn wir es also nicht übergeben oder null zuweisen möchten, können wir einfach 0
sagen, und das entspricht dem Hinweis auf nichts.
Da null also gleich 0 ist, können
Sie, wenn Sie testen möchten, ob der p-Wert null ist,
explizite Tests durchführen. Sie können sagen, Zeiger ist gleich Null.
Und wenn der Zeiger gleich Null ist, was bedeutet, dass er
Null ist, können Sie tatsächlich etwas tun.
Wenn es also nicht Null oder nicht Null ist, ist es ein wahrer oder ein
anderer Wert. Dies ist eine Möglichkeit, um Abstürze zu vermeiden.
Bevor Sie tatsächlich versuchen, etwas zu dereferenzieren, stellen Sie
sicher, dass Ihnen mitgeteilt wird, ob Speicher zugewiesen ist oder nicht.
Sie möchten also nach Null suchen, bevor Sie einen Zeiger dereferenzieren.
Und Sie tun dies häufig in
Funktionen, da Funktionen Zeiger als Parameter verwenden.
Und wenn der Anrufer
fehlerhafte Daten übergibt oder wenn ein Zeiger keinen Speicher zugewiesen hat, kann dies
zu einem Absturz Ihres Codes führen. Sie möchten also sicherstellen, dass der
Anrufer eine gültige Adresse hat, damit Sie sie auf null überprüfen können.
Grundsätzlich bedeutet dies, diese immer zu haben, wenn überprüft wird,
ob kein p-Wert oder kein Zeiger vorhanden ist.
Und wenn es kein Zeiger ist, können Sie ihn dereferenzieren.
Wir reden viel über Hinweise. Wir haben ziemlich viel diskutiert.
Ich bin sicher, es wird ein wenig überwältigend. Vielleicht möchten Sie eine Pause
einlegen und die vorherigen Vorlesungen durchgehen, um dieses Konzept wirklich in Ihrem Kopf zu synchronisieren.
Zeiger enthalten nur Adressen.
Aber es gibt 3 Teile, so dass es problematisch werden kann.
Aber bleib positiv. Bleib bei mir und ich weiß,
dass es verwirrend ist.
Wir haben über die Arbeit mit Adressen gesprochen.
Wir haben darüber gesprochen, mit Werten zu arbeiten. Wir haben darüber gesprochen, mit dem Zeiger selbst zu
arbeiten, und wir haben darüber gesprochen, mit Variablen zu arbeiten, die auf den Zeiger zeigen.
Es gibt also all diese Dinge, an
die Sie sich erinnern müssen, und es kann sehr, sehr überwältigend und frustrierend sein.
Und es ist immer schwer herauszufinden, was los ist, und es wird viel Übung erfordern.
Der beste Weg, um dieses Konzept und alles, mit dem wir bisher gesprochen
haben, zu verstehen, besteht
darin, kurze Programme zu üben, die alle von mir erwähnten Konzepte verwenden.
Schreiben Sie also ein Programm, das
die Werte mithilfe eines Zeigers abruft. Dies würde möglicherweise
den Indirektionsoperator dereferenzieren. Schreiben Sie ein Programm, das Werte mithilfe von Zeigern ändert.
Dies wäre also eine Dereferenzierung. Das Abrufen der Werte mithilfe von Zeigern wäre nur
der Name des Zeigers, der die Adresse sein würde. Beim Drucken von Adressen haben wir uns die gesamte Syntax angesehen.
Übe dieses Zeug immer und immer wieder, so wirst du gut darin.
Sie müssen Ihr Vertrauen stärken und diese Konzepte im Detail studieren,
um sie zu beherrschen.
Wir haben noch viel mehr über Hinweise zu sprechen, aber dies kann eine Zeit sein, einfach einen Schritt zurückzutreten und
das, worüber wir bisher gesprochen haben, zu überdenken, damit es Ihnen in den Kopf bohrt.
Vielen Dank.