Programmier-Tutorial - Seite 3
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
OOP-Konstruktoren – Arten von Konstruktoren, die Sie kennen müssen (von den Grundlagen zur Beherrschung)
OOP-Konstruktoren – Arten von Konstruktoren, die Sie kennen müssen (von den Grundlagen zur Beherrschung)
In diesem Video besprechen wir verschiedene Arten von Konstruktoren, ihren Zweck und warum sie für die Programmierung unerlässlich sind. Ich werde Beispiele bereitstellen und die Funktionsweise von Konstruktoren im Hintergrund erläutern. Aber bevor wir eintauchen, möchte ich ein Tool namens PBS Studio empfehlen, das ich seit Jahren verwende. Es handelt sich um einen leistungsstarken statischen Code-Analysator, der dabei hilft, Fehler aufzuspüren und die Codequalität zu verbessern. Es lässt sich problemlos in verschiedene IDEs integrieren und unterstützt Sprachen wie C, C++, C# und Java. Sie können den Download-Link finden und sogar Möglichkeiten entdecken, es kostenlos zu erhalten, wenn Sie Student sind. Kehren wir nun zum Video zurück.
Erstellen wir zunächst eine Klasse namens „User“ mit öffentlichen Mitgliedern: „firstName“, „lastName“, „age“ und „email“. Derzeit weisen wir diesen Eigenschaften für jeden von uns erstellten Benutzer manuell Werte zu. Dieser Ansatz wird jedoch mit zunehmender Benutzerzahl unpraktisch.
Stattdessen werden wir mithilfe von Konstruktoren eine bessere Lösung untersuchen. Konstruktoren werden zum Konstruieren von Objekten verwendet und automatisieren den Prozess der Initialisierung von Objekteigenschaften. Wir beginnen mit der Erläuterung der Hintergrundfunktionen von Konstruktoren anhand von Beispielen.
Zu Demonstrationszwecken entfernen wir den zweiten Benutzer und drucken die Informationen des ersten Benutzers aus. Wenn Sie das Programm ausführen, werden Sie feststellen, dass in der Ausgabe leere Werte für Vorname, Nachname und E-Mail sowie eine große oder kleine Zahl für das Alter angezeigt werden. Wir werden untersuchen, warum dies geschieht und ob keine Fehler vorliegen.
Der Grund für dieses Verhalten ist der von C++ bereitgestellte Standardkonstruktor. Es initialisiert Eigenschaften mit Standardwerten, wie zum Beispiel der großen Zahl, die wir für das Alter sehen. Wenn wir jedoch eine einfache Variable wie „test“ erstellen, ohne sie zu initialisieren, tritt ein Fehler auf, da einfache Typen keine Standardkonstruktoren haben.
Schauen wir uns nun die Eigenschaften von Konstruktoren an. Erstens haben Konstruktoren denselben Namen wie die Klasse und keinen Rückgabetyp. Zweitens müssen sie im öffentlichen Bereich der Klasse platziert werden. Drittens haben Standardkonstruktoren keine Parameter. Viertens generiert C++ automatisch einen Standardkonstruktor, wenn Sie keinen erstellen. Fünftens erhalten parametrisierte Konstruktoren Parameter, um Objekteigenschaften zu initialisieren. Schließlich wird automatisch ein Standardkonstruktor aufgerufen, wenn ein Objekt dieser Klasse erstellt wird.
Lassen Sie uns unseren eigenen Standardkonstruktor implementieren, indem wir den Eigenschaften Standardwerte zuweisen. Mit dieser Änderung wird jedes Mal, wenn wir einen Benutzer erstellen, unser Standardkonstruktor aufgerufen. Wenn wir nun die Benutzerinformationen drucken, sehen wir die von uns zugewiesenen Standardwerte.
Lassen Sie uns nun den zweiten Konstruktortyp untersuchen, den parametrisierten Konstruktor. Im Gegensatz zum Standardkonstruktor akzeptiert der parametrisierte Konstruktor bestimmte Werte als Parameter und verwendet sie zum Instanziieren von Objekteigenschaften. Ich werde ein Beispiel für einen parametrisierten Konstruktor bereitstellen, der Parameter für Vorname, Nachname und Alter akzeptiert.
Mit diesen Parametern können wir die bereitgestellten Werte den entsprechenden Eigenschaften zuordnen. Dadurch können wir direkt bei der Objekterstellung Benutzer mit spezifischen Informationen anlegen.
Dies deckt die Grundlagen von Konstruktoren und deren Verwendung ab. Weitere Beispiele und Einblicke finden Sie in zukünftigen Videos.
Friend-Funktionen und -Klassen in C++ (Programmierung für Anfänger)
Friend-Funktionen und -Klassen in C++ (Programmierung für Anfänger)
Ich freue mich, Ihnen in diesem Video etwas über Friend-Funktionen und Friend-Klassen in C++ beizubringen. Dieses Konzept der Freundschaft in der Programmierung ähnelt der Freundschaft im wirklichen Leben. So wie Ihre Freunde Zugang zu privaten Bereichen Ihres Lebens haben, die andere nicht haben, haben Freundfunktionen und Freundklassen in der objektorientierten Programmierung Zugriff auf private und geschützte Mitglieder einer Klasse.
In diesem Video erfahren Sie, wie und wann Sie Freundesfunktionen und Freundesklassen nutzen. Zur Demonstration verwenden wir Visual Studio Community, und ich stelle Ihnen auch eine hervorragende Erweiterung namens Visual Assist vor. Den Download-Link finden Sie in der Beschreibung unten. Visual Assist ist ein intelligenter Codierungsassistent, den viele professionelle Entwickler verwenden, insbesondere für große Projekte oder die Spieleentwicklung mit Engines wie der Unreal Engine. Es verbessert die Codevervollständigung, bietet intelligente Vorschläge für das Refactoring, stellt Codeausschnitte bereit und verbessert die Navigation und Suche innerhalb Ihres Projekts.
Kommen wir nun zum Thema Friend-Funktionen. Um dieses Konzept zu erklären, erstellen wir ein Problem und lösen es mithilfe von Friend-Funktionen. Wir erstellen eine Klasse namens „EquilateralTriangle“, um ein Dreieck darzustellen, bei dem alle drei Seiten gleich lang sind. Die Klasse verfügt über private Variablen für Seitenlänge, Umfang und Fläche. Wir werden außerdem eine öffentliche Setter-Methode hinzufügen, um die Seitenlänge festzulegen und den Umfang und die Fläche innerhalb dieser Methode zu berechnen.
Wenn wir jedoch versuchen, auf die privaten Mitglieder außerhalb der Klasse zuzugreifen, treten Fehler auf. Eine Lösung besteht darin, die privaten Mitglieder öffentlich zu machen oder öffentliche Getter zu erstellen, aber dadurch sind sie für alle zugänglich. Stattdessen können wir Friend-Funktionen verwenden, um selektiv Zugriff zu gewähren. Wir erstellen eine globale Funktion namens „PrintResults“, die den Umfang und die Fläche des Dreiecks druckt. Indem diese Funktion als Freund der EquilateralTriangle-Klasse deklariert wird, erhält sie Zugriff auf die privaten Mitglieder.
Denken Sie jedoch daran, Ihre Freundesfunktionen sorgfältig auszuwählen und eine übermäßige Nutzung zu vermeiden, um die Kapselung aufrechtzuerhalten. Darüber hinaus können Sie in C++ auch Friend-Klassen haben. Wenn wir die Funktion „PrintResults“ in eine Klasse namens „Homework“ verschieben und sie zu einer öffentlichen Mitgliedsfunktion machen, können wir „Homework“ als befreundete Klasse von „EquilateralTriangle“ deklarieren. Auf diese Weise kann die Klasse „Homework“ auf die privaten und geschützten Mitglieder von „EquilateralTriangle“ zugreifen.
Es ist wichtig zu beachten, dass Freundschaften beim Programmieren nicht auf Gegenseitigkeit beruhen oder vererbt werden. Verwenden Sie Friend-Funktionen und Friend-Klassen mit Bedacht und denken Sie daran, dass Vererbung und Operatorüberladung auch häufige Anwendungsfälle für Friend-Funktionen betreffen. Weitere Informationen und eine entsprechende Hausaufgabe finden Sie in meinem Video zur Bedienerüberlastung (in der Beschreibung verlinkt).
Ich hoffe, dass Ihnen dieses Video dabei hilft, Friend-Funktionen und Friend-Klassen in Ihren Programmierprojekten zu verstehen und zu nutzen. Seien Sie gespannt auf weitere spannende Inhalte und vergessen Sie nicht, einen Blick auf die Visual Assist-Erweiterung für Visual Studio zu werfen!
Destruktoren in der Programmierung: Praktische Demonstration
Destruktoren in der Programmierung: Praktische Demonstration
In diesem Video zeige ich Ihnen etwas über Destruktoren in der Programmierung. Sie erfahren, was Destruktoren sind, wie Sie sie verwenden und wann Sie sie verwenden. Schauen Sie sich unbedingt das gesamte Video an, denn am Ende habe ich eine besondere Überraschung für Sie. Bevor wir uns mit Destruktoren befassen, ist es wichtig, Konstruktoren zu verstehen. Wenn Sie mit Konstruktoren nicht vertraut sind, schauen Sie sich mein vorheriges Video an, das hier und in der Beschreibung verlinkt ist.
Destruktoren sind spezielle Funktionen, die aufgerufen werden, wenn ein Objekt zerstört wird. Sie führen notwendige Bereinigungsaufgaben durch, z. B. die Freigabe von Ressourcen wie Speicher oder Dateien, die vom Objekt gehalten werden. Wenn diese Ressourcen nicht freigegeben werden, kann dies die Leistung und Stabilität beeinträchtigen und zu Speicherverlusten führen.
Bevor wir mit der Diskussion von Destruktoren beginnen, möchte ich Ihnen ein Tool namens PBS Studio vorstellen, das ich gerne verwende. Es ist ein statischer Code-Analysator, der mir hilft, besseren Code ohne Fehler zu schreiben. Es analysiert Ihren Code auf potenzielle Probleme und Fehler und spart Ihnen Zeit und Geld, indem Fehler erkannt werden, bevor sie in die Produktion gehen. Es lässt sich leicht in gängige IDEs integrieren und unterstützt mehrere Programmiersprachen. Sie können es über den Link in der Beschreibung herunterladen und kostenlos testen. Wenn Sie Student sind, schauen Sie auf deren Website nach kostenlosen Optionen.
Lassen Sie uns nun tiefer in die Destruktoren eintauchen. Ein Destruktor ist eine spezielle Funktion mit einem Namen, der mit dem Klassennamen identisch ist und der eine Tilde (~) vorangestellt ist. Es hat keinen Rückgabetyp, empfängt keine Parameter und sollte im öffentlichen Abschnitt Ihrer Klasse platziert werden. Es kann nur einen Destruktor pro Klasse geben.
Um Destruktoren zu veranschaulichen, erstellen wir eine Klasse namens „Book“ mit zwei Eigenschaften: „title“ und „author“. Wir erstellen außerdem einen Konstruktor und einen Destruktor. Denken Sie daran, dass der Destruktor alle vom Objekt gehaltenen Ressourcen freigeben sollte.
Im Konstruktor weisen wir die übergebenen Parameter den entsprechenden Eigenschaften zu. Innerhalb des Destruktors geben wir eine Meldung aus, die angibt, dass der Destruktor für ein bestimmtes Buch aufgerufen wurde.
Lassen Sie uns nun einige Buchobjekte erstellen, um zu sehen, wann der Konstruktor und der Destruktor aufgerufen werden. Wir debuggen das Programm und beachten die Reihenfolge der Aufrufe.
Wenn Ihre Klasse keine Zeiger enthält, führt der Compiler die Speicherfreigabe automatisch durch. Wenn Sie jedoch mit Zeigern arbeiten, müssen Sie den Speicher im Destruktor manuell freigeben, um Speicherlecks zu vermeiden. Denken Sie daran, „delete[] arrayName“ für Arrays zu verwenden und Zeiger nach der Freigabe auf nullptr zu setzen.
Ich hoffe, dieses Video hat Ihnen geholfen, Destruktoren und ihre Bedeutung für die Ressourcenverwaltung zu verstehen. In meinem nächsten Video werden wir uns mit Kopierkonstruktoren befassen, also bleiben Sie dran.
C++-Kopierkonstruktoren (einsteigerfreundliches Tutorial + praktische Beispiele)
C++-Kopierkonstruktoren (einsteigerfreundliches Tutorial + praktische Beispiele)
Hallo zusammen, willkommen auf meinem Kanal. In diesem Video zeige ich Ihnen Kopierkonstruktoren, ein wichtiges, aber verwirrendes Thema für Anfänger. Bevor Sie sich dieses Video ansehen, schauen Sie sich bitte unbedingt mein vorheriges Video zu verschiedenen Arten von Konstruktoren an, einschließlich Standard- und parametrisierten Konstruktoren (Link in der Beschreibung). Schauen Sie sich auch mein Video zu Zeigern und dynamischen Arrays an (Link in der Beschreibung), da es Ihnen hilft, dieses Thema besser zu verstehen.
In diesem Video erkläre ich alles, was Sie über Kopierkonstruktoren wissen müssen. Anfänger verstehen oft das Konzept hinter Kopierkonstruktoren, haben aber Schwierigkeiten zu verstehen, wann und wie sie verwendet werden und welche potenziellen Fehler auftreten können. Ich werde alle diese Aspekte Schritt für Schritt behandeln.
Beginnen wir mit der Untersuchung des Codes aus meinem vorherigen Video. Ich habe eine Klasse namens „Book“ mit Eigenschaften wie Titel, Autor und einem Zeiger namens „Rates“ erstellt. Der „Rate“-Zeiger stellt ein dynamisches Array dar, in das Benutzer Bewertungen für das Buch eingeben können. Es gibt auch einen „Ratenzähler“, um die Array-Größe zu verfolgen. Wenn Sie mit Zeigern und dynamischen Arrays nicht vertraut sind, empfehle ich Ihnen, sich mein Video zu diesem Thema anzusehen (Link in der Beschreibung).
Ich habe einen parametrisierten Konstruktor für die Book-Klasse implementiert, der Titel und Autor als Parameter verwendet und auf der Grundlage dieser Werte ein Buchobjekt erstellt. Ich habe auch einen Destruktor eingefügt, der für die Freigabe des vom Konstruktor zugewiesenen Speichers wichtig ist. Es ist wichtig, einen Code-Analysator wie PVS-Studio zu verwenden, um versteckte Fehler und Schwachstellen in Ihrem Code zu erkennen. Ich persönlich empfehle die Verwendung von PVS-Studio, da es Fehler effektiv findet und Vorschläge zu deren Behebung liefert. Sie können es über den Link in der Beschreibung kostenlos herunterladen.
Konzentrieren wir uns nun auf das Thema Kopierkonstruktoren. Der Zweck eines Kopierkonstruktors besteht darin, ein neues Objekt basierend auf einem vorhandenen Objekt zu erstellen. Es ermöglicht Ihnen, eine Kopie eines Objekts zu erstellen und daraus ein neues zu erstellen. Standardmäßig stellt C++ einen Standardkopierkonstruktor bereit. Beim Arbeiten mit Zeigern ist es jedoch erforderlich, einen benutzerdefinierten Kopierkonstruktor zu erstellen, um Fehler zu vermeiden.
Ohne einen benutzerdefinierten Kopierkonstruktor kann die Verwendung von Zeigern zu Ausnahmen und Fehlern führen. Betrachten wir das folgende Szenario: Ich möchte „Book3“ basierend auf den Daten von „Book1“ erstellen. Ich möchte alle Eigenschaften von „Book1“ kopieren, um „Book3“ zu erstellen. Hier kommt der Kopierkonstruktor ins Spiel.
Befolgen Sie diese Regeln, um einen Kopierkonstruktor zu erstellen:
Lassen Sie uns den Kopierkonstruktor erstellen. Im Kopierkonstruktor erhalten wir das Originalobjekt als konstante Referenz (const Book& original). Dadurch werden Änderungen am Originalobjekt innerhalb des Kopierkonstruktors verhindert.
Lassen Sie uns nun einen häufigen Fehler ansprechen, den Anfänger beim Erstellen eines Kopierkonstruktors machen. Der Fehler besteht darin, den Zeiger direkt zu kopieren, anstatt neuen Speicher zuzuweisen und den Inhalt zu kopieren. Wenn wir den Zeiger kopieren, zeigen sowohl das Original als auch die Kopie auf denselben Speicherort. Wenn der Destruktor aufgerufen wird, versucht er daher zweimal, den Speicher freizugeben, was zu Fehlern führt.
Um dieses Problem zu beheben, müssen wir neuen Speicher für die Kopie zuweisen und den Inhalt des ursprünglichen Zeigers kopieren. Anstatt den Zeiger direkt zuzuweisen, erstellen wir ein neues dynamisches Array und kopieren die Elemente. Dadurch wird sichergestellt, dass Original und Kopie getrennte Speicherorte haben.
Indem wir diese Richtlinien befolgen, können wir einen korrekten Kopierkonstruktor erstellen, der speicherbezogene Fehler vermeidet.
Ich hoffe, dass diese Erklärung das Konzept der Kopierkonstruktoren und ihre Bedeutung verdeutlicht.
Code-It-Yourself! Tetris – Programmieren von Grund auf (Schnell und einfach C++)
Code-It-Yourself! Tetris – Programmieren von Grund auf (Schnell und einfach C++)
Hallo! Heute begeben wir uns auf die aufregende Reise, unsere eigene Version von Tetris zu erstellen. Bevor wir uns mit dem Codieren befassen, möchte ich Ihnen einen kleinen Einblick in das geben, was wir erstellen werden.
Wie Sie sehen, haben wir eine klassische Tetris-Form auf dem Bildschirm. Dank der Möglichkeiten der Codierung werden wir in der Lage sein, diese Formen zu drehen. Das Spiel verfügt über eine Kollisionserkennung, die sicherstellt, dass die Teile korrekt miteinander interagieren. Wenn wir es schaffen, eine Reihe durch strategisches Platzieren der zufälligen Teile zu vervollständigen, verschwindet sie und unsere Punktzahl erhöht sich entsprechend. Wenn wir jedoch nicht aufpassen und der Steinstapel die Spitze erreicht, ist das Spiel vorbei.
Jetzt fragen Sie sich vielleicht, warum wir uns eher auf die Spiel-Engine als auf die Grafik konzentrieren. Während Ästhetik wichtig ist und Spieler anziehen kann, liegt die wahre Essenz eines Spiels in seiner Engine – dem Teil, der für die Umsetzung von Gameplay, Logik, Regeln, Herausforderungen und mehr verantwortlich ist. Grafik-Engines können jederzeit später hinzugefügt werden, und Sie können sogar einen Künstler hinzuziehen, um Ihr Spiel zu verschönern. Aber um die Spieleentwicklung wirklich zu verstehen, müssen Sie die Grundlagen des Aufbaus einer Spiel-Engine verstehen.
Um zu beginnen, benötigen wir einige Spielressourcen. In Tetris sind diese Vermögenswerte die verschiedenen Formen, die „Tetromino-Blöcke“ genannt werden. Wir speichern diese Formen als Zeichenfolgen, was uns die Visualisierung erleichtert. Es gibt sieben gängige Formen, die in Tetris verwendet werden, und wir werden sie durch Zeichen wie Punkte (.) für Leerzeichen und Großbuchstaben X für die Form selbst darstellen. Durch die Anordnung dieser Zeichen erstellen wir Zeichenfolgen, die die Formen visuell darstellen.
Anstatt mehrdimensionale Arrays zur Darstellung der 2D-Formen zu verwenden, verwenden wir nun ein eindimensionales Array und manipulieren die Indizes mithilfe einfacher mathematischer Berechnungen. Dieser Ansatz ermöglicht es uns, Rotationen und Spiegelungen der Formen effizienter zu handhaben. Wir verwenden Formeln, um die entsprechenden Indizes für jede Rotation zu bestimmen. Durch Multiplikation der X-Koordinate mit 4 können wir beispielsweise den gewünschten Index für eine 90-Grad-Drehung erhalten. Diese Technik erspart uns die Erstellung separater Assets für jede mögliche Formvariation.
Neben den Tetromino-Blöcken brauchen wir auch ein Spielfeld. Wir definieren die Abmessungen des Feldes mithilfe von Variablen für Breite und Höhe. In diesem Fall gehen wir von einer Feldgröße von 12 Zellen in der Breite und 18 Zellen in der Höhe aus. Um die Elemente des Spielfelds darzustellen, verwenden wir ein Array von Zeichen ohne Vorzeichen. Jeder Zelle wird ein Wert zugewiesen, der ihren Inhalt angibt, z. B. leeren Raum, Teil einer Form oder die Begrenzungswände.
Um unser Spiel zu visualisieren, verwenden wir die Eingabeaufforderung als Bildschirmpuffer. Indem wir ein Array mit den Abmessungen des Eingabeaufforderungsfensters erstellen, können wir unsere Spielelemente darauf zeichnen. Wir werden bestimmte Charaktere verwenden, um verschiedene Elemente des Spiels darzustellen, wie etwa die Formen, leeren Räume und die Begrenzungsmauern. Anschließend zeigen wir den Inhalt des Arrays auf dem Eingabeaufforderungsbildschirm an.
Lassen Sie uns nun über die Spielschleife sprechen. Spielschleifen sind wichtige Bestandteile jeder Spiel-Engine, da sie die Abfolge der Spielelemente steuern. Im Fall von Tetris kümmert sich unsere Spielschleife um Timing, Benutzereingaben, Spiellogik und Ausgaberendering.
Das Timing ist entscheidend, um ein konsistentes Gameplay auf verschiedenen Systemen sicherzustellen. Wir möchten, dass das Spiel unabhängig von der Geschwindigkeit des Computers im gleichen Tempo läuft. Wir werden Timing-Mechanismen verwenden, um die Geschwindigkeit zu steuern, mit der die Formen fallen und die Spielaktualisierungen.
Als Nächstes befassen wir uns mit Benutzereingaben. Da wir eine einfache Befehlszeilenversion von Tetris erstellen, verlassen wir uns nicht auf ereignisbasierte Eingaben. Stattdessen verarbeiten wir grundlegende Benutzereingaben wie Pfeiltasten oder andere dafür vorgesehene Tasten.
In diesem Code implementieren wir die Verarbeitung von Tastatureingaben für ein Spiel und konzentrieren uns dabei insbesondere auf vier Tasten: den Pfeil nach links, den Pfeil nach rechts, den Pfeil nach unten und die Taste „Z“ zum Drehen der Spielfigur.
Um den aktuellen Status der vom Benutzer gedrückten Tasten zu ermitteln, verwenden wir die Funktion „Status der asynchronen Taste abrufen“. Indem wir ein Array durchlaufen, das den Zustand der Tasten darstellt, können wir feststellen, ob jede Taste gerade gedrückt ist oder nicht. Diese Funktion gibt einen booleschen Wert zurück: true, wenn die Taste gedrückt wurde, und false, wenn dies nicht der Fall ist. Um den Status einer bestimmten Taste zu überprüfen, verwenden wir einen konstanten Zeichenfolgenausdruck, der die virtuellen Tastencodes für jede Taste darstellt.
Indem wir den Zustand dieser vier Tasten überprüfen, können wir ein Array erstellen, das wahre oder falsche Werte enthält, die angeben, ob jede Taste gedrückt wird oder nicht. Dies vereinfacht den Prozess und gibt uns ein Array, das den aktuellen Status der Schlüssel darstellt.
Betrachten wir als Beispiel die linke Taste. Wenn der Benutzer die linke Taste drückt, müssen wir prüfen, ob die Spielfigur links von ihrer aktuellen Position passt. Dazu verwenden wir eine Funktion namens „Passt das Teil?“, die das aktuelle Teil, seine Drehung und die aktuelle X-Position berücksichtigt. Indem wir 1 von der aktuellen X-Position subtrahieren, können wir feststellen, ob das Teil nach links passt. Wenn es passt, aktualisieren wir die aktuelle X-Position entsprechend.
Ebenso führen wir für die richtige Taste eine ähnliche Prüfung durch, um zu sehen, ob das Teil rechts von seiner aktuellen Position passt. Wenn dies möglich ist, aktualisieren wir die aktuelle X-Position entsprechend.
Wenn der Benutzer die Abwärtstaste drückt, müssen wir die vertikale Bewegung des Teils steuern. Da die Position oben links auf dem Spielfeld immer (0, 0) ist, können wir einfach die Y-Position erhöhen, um die Figur nach unten zu bewegen. Wir führen Kontrollen durch, um sicherzustellen, dass das Bewegen der Figur nach links, rechts oder unten innerhalb der Grenzen des Spielfelds bleibt.
Um den Code zu optimieren, können wir die verschachtelten if-Anweisungen durch logische UND-Operatoren ersetzen. Dies vereinfacht den Code und verbessert seine Prägnanz. Darüber hinaus verwenden wir bedingte Anweisungen, um basierend auf dem Ergebnis der Bedingung 1 von der aktuellen X-Position zu addieren oder davon zu subtrahieren, wodurch der Code weiter optimiert wird. Die gleiche Optimierung wird bei der Handhabung der Drehung des Teils angewendet, wenn der Benutzer die Taste „Z“ drückt.
Bei Tetris zwingt das Spiel die Figur regelmäßig alle paar Zehntelsekunden dazu, sich nach unten zu bewegen, um die Schwerkraft zu simulieren. Dies erreichen wir durch den Einsatz des Spiel-Tick-Zählers. Anfangs fällt die Figur langsam, aber im Laufe des Spiels verkürzen wir die Zeit zwischen den einzelnen Steinwürfen, wodurch das Spiel schneller und anspruchsvoller wird. Indem wir Spielticks sammeln und sie mit der aktuellen Geschwindigkeit vergleichen, bestimmen wir, wann wir die Figur nach unten drücken müssen. Dies führt dazu, dass die Figur in regelmäßigen Abständen fällt, wodurch der Effekt der Schwerkraft im Spiel entsteht.
Um die aktuelle Figur auf dem Spielfeld zu fixieren, aktualisieren wir das Feldarray mit den Werten aus dem Tetromino-Array. Dies erfolgt durch Durchlaufen jedes Elements des Tetromino-Arrays und Aktualisieren der entsprechenden Position im Feldarray. Wenn ein Element im Tetromino-Array ein „X“ ist, erhöhen wir den entsprechenden Wert im Feld-Array um 1. Dies markiert diese Position als vom aktuellen Stück besetzt.
Wenn sich auf dem Spielfeld eine Linie bildet, möchten wir dies dem Spieler visuell anzeigen. Wir ersetzen die Linie durch einen speziellen Marker oder führen einen anderen visuellen Effekt durch, um die Fertigstellung der Linie anzuzeigen.
Nachdem wir die fertige Linie visuell angezeigt haben, müssen wir uns um das Löschen der Linie und die entsprechende Aktualisierung des Spielfelds kümmern. Wir durchlaufen jede Reihe des Spielfelds von unten beginnend und prüfen, ob die Reihe gefüllt ist. Wenn eine Zeile gefüllt ist, löschen wir sie, indem wir alle ihre Elemente auf 0 setzen. Anschließend verschieben wir alle darüber liegenden Zeilen um eine Position nach unten, um die gelöschte Zeile zu füllen. Dieser Vorgang wird wiederholt, bis alle gefüllten Zeilen gelöscht wurden.
Um den Punktestand des Spielers im Auge zu behalten, erhöhen wir ihn jedes Mal, wenn eine Linie gelöscht wird. Die Punktzahl kann auf der Anzahl der geräumten Linien basieren oder je nach Spieldesign ein komplexeres Punktesystem haben.
Um mit Game-Over-Bedingungen umzugehen, müssen wir prüfen, ob die aktuelle Figur an ihrer ursprünglichen Position oben auf dem Spielfeld Platz findet. Wenn es nicht passt, ist das Spiel vorbei und wir stoppen die Spielschleife oder lösen alle notwendigen Game-Over-Aktionen aus.
Um die Spielschleife zu verwalten, verwenden wir schließlich einen Timer oder einen ähnlichen Mechanismus, der in regelmäßigen Abständen eine Aktualisierungsfunktion auslöst. Diese Funktion kümmert sich um die Aktualisierung des Spielstatus, einschließlich der Überprüfung auf Benutzereingaben, das Verschieben der Figur nach unten und das Durchführen notwendiger Aktionen basierend auf dem aktuellen Spielstatus.
Zusammenfassend implementiert dieser Code die Verarbeitung von Tastatureingaben für ein Spiel und konzentriert sich dabei insbesondere auf Tasten wie Pfeiltasten und die „Z“-Taste. Es prüft den Zustand dieser Tasten, verwaltet die Bewegung der Spielfigur entsprechend, implementiert die Schwerkraft und die Figurensperre, löscht abgeschlossene Linien, aktualisiert das Spielfeld, verfolgt den Punktestand des Spielers und prüft, ob das Spiel beendet ist. Die Spielschleife stellt sicher, dass der Spielstatus in regelmäßigen Abständen aktualisiert wird, wodurch ein dynamisches und interaktives Spielerlebnis entsteht.
C++-VOLLSTÄNDIGER KURS für Anfänger (Lernen Sie C++ in 10 Stunden)
C++-VOLLSTÄNDIGER KURS für Anfänger (Lernen Sie C++ in 10 Stunden)
Dies ist ein vollständiger C++-Programmierkurs. Es besteht aus vielen Vorlesungen, deren Ziel es ist, Sie vom Anfänger- zum fortgeschrittenen Programmierniveau zu bringen. Ich empfehle, das gesamte Video anzusehen, da spätere Vorlesungen Kenntnisse aus früheren Vorlesungen erfordern.
Inhalt:00:00:00 – Ziele des Kurses
00:01:31 – Tun Sie dies, bevor Sie mit dem Kurs beginnen
00:02:41 – Einführung in C++ (Was ist C++? Welche Art von Apps kann man mit C++ erstellen? Warum wurde C++ erstellt?)
00:06:39 – Was ist Quellcode, Objektcode, Compiler, Algorithmus?
00:08:42 - Visual Studio 2019 – Erstes Projekt erstellen (Setup)
00:11:32 – Erläuterung der Grundlagen von Visual Studio 2019 und erstes „Hello World“-Programm
00:29:51 – Einführung in Variablen
00:44:36 – Regeln für die Benennung von Variablen
00:52:15 – Datentypen in C++ und Verwendung des Operators „sizeof“.
01:01:58 – Datentypüberlauf
01:05:00 – Was ist eine ASCII-Tabelle?
01:09:50 – Einfaches, unterhaltsames Programm zum Verschlüsseln von Wörtern in ASCII
01:18:12 – If/else-Anweisung (Erstellen Sie ein Programm, das ungerade/gerade Zahlen prüft + Erklärung des Flussdiagramms)
01:35:52 – Verschachtelte if/else-Anweisung (Erstellen Sie ein Programm, das den Typ eines Dreiecks + Flussdiagramms bestimmt)
01:55:50 – Operatoren in C++ (arithmetische, relationale, logische, Zuweisungsoperatoren)
02:21:02 – Werte zweier Variablen mit oder ohne dritte Variable austauschen
02:29:20 – BMI-Rechneranwendung + Flussdiagramm erstellen
02:49:55 – Ternärer (bedingter) Operator (Erstellen einer Ratespiel-App)
03:01:00 – Switch/Case-Anweisung Teil 1 (Build Calculator-App)
03:26:36 – Switch/Case-Anweisung Teil 2 (Programm erstellen, das die Anzahl der Tage in einem Monat überprüft)
03:39:35 – While-Schleife Teil 1 + Beispiel für eine Endlosschleife
03:53:39 – While-Schleife Teil 2 (Erstellen Sie ein Programm zum Zählen von Ziffern einer Zahl)
04:12:39 – While-Schleife Teil 3 (Erstellen Sie ein Programm zum Umkehren der Ziffern einer Zahl)
04:25:25 – While-Schleife ausführen (Programm zur PIN-Validierung)
04:39:09 – Was ist der Unterschied zwischen While-Schleife und Do While-Schleife?
04:40:34 – For-Schleife (Erstellen Sie ein Programm zur Berechnung der Fakultät einer Zahl)
04:58:12 – Verschachtelte Schleifen (Verschachtelung von do-while-Schleifen und for-Schleifen)
05:11:08 – Verschachtelte for-Schleife (App zum Erstellen von Multiplikationstabellen)
05:21:45 – Programm zum Zeichnen von Rechteckformen
05:33:05 – Programm zum Zeichnen von Dreiecken und umgekehrten Dreiecksformen
05:44:30 – Einführung in Funktionen
05:56:02 – Funktionen mit Parametern/Argumenten (multiple und default)
06:11:42 – Funktionsrückgabeanweisung (Programm zum Überprüfen von Primzahlen erstellen)
06:37:39 – Funktionsüberlastung
06:48:06 – Erstellen Sie eine Geldautomaten-App
07:03:03 – Allgemeine Funktionen und Vorlagen
07:14:30 – Rekursion und rekursive Funktionen
07:30:01 – Einführung in OOP, Was sind Klassen und Objekte
07:42:06 – OOP-Konstruktoren und Klassenmethoden
07:57:10 – OOP-Kapselung, GIT: https://github.com/TrueCodeBeauty/EncapsulationCpp
08:08:31 – OOP-Vererbung, GIT: https://github.com/TrueCodeBeauty/InheritanceCpp
08:24:59 – OOP Polymorphisam, GIT: https://github.com/TrueCodeBeauty/PolymorphismCpp
08:40:04 – Einführung in Zeiger
08:51:14 – Leere Zeiger
09:06:27 – Zeiger und Arrays
09:19:18 – Mehrere Werte von einer Funktion mithilfe von Zeigern zurückgeben
09:34:50 – Dynamische Arrays, Arrays zur Laufzeit erstellen/ändern
09:48:35 – Mehrdimensionale dynamische Arrays, zweidimensionale Arrays
10:07:00 – Erkennen von Fehlern im Code mit PVS Studio
10:17:19 – Erklärung von Speicherlecks
10:26:25 – Pannen
C++-FUNKTIONEN (2020) – Was sind Funktionen?
C++-FUNKTIONEN (2020) – Was sind Funktionen? PROGRAMMIERTUTORIAL
Willkommen zum ersten Video meines Kanals! Wenn Sie ein Anfänger in C++ sind, schauen Sie sich unbedingt meine Playlist zu C++ für Anfänger an. Dort finden Sie wichtige Konzepte, die Sie verstehen und kennen müssen, um mit C++ arbeiten zu können. In diesem Video besprechen wir C++-Funktionen, die unerlässlich sind, um ein guter Programmierer zu werden, nicht nur in C++, sondern in den meisten Programmiersprachen.
Bevor wir beginnen, abonnieren Sie bitte meinen Kanal und klicken Sie auf das Glockensymbol, um Benachrichtigungen zu erhalten, wenn ich mein nächstes Video veröffentliche. Wenn Sie daran interessiert sind, einen Blick hinter die Kulissen zu werfen und zu sehen, wie das Entwicklerleben wirklich aussieht, folgen Sie mir auf Instagram und Twitter über meine Konten „CodeBeauty“.
Kommen wir nun zum Thema Funktionen. Eine Funktion ist ein Codeblock, der gruppiert ist, um ein bestimmtes Problem zu lösen oder eine bestimmte Aufgabe auszuführen. Der Code innerhalb einer Funktion wird nur ausgeführt, wenn die Funktion aufgerufen oder aufgerufen wird. Jedes C++-Programm enthält mindestens eine Funktion, die Hauptfunktion. Die Ausführung Ihres Programms beginnt in der ersten Zeile der Hauptfunktion und endet entweder in der letzten Zeile oder wenn eine Return-Anweisung auftritt (wir werden später in diesem Kurs auf Return-Anweisungen eingehen).
Um Ihre eigene Funktion zu erstellen, müssen Sie einige Dinge wissen. Zunächst müssen Sie den Rückgabetyp der Funktion angeben. Vorerst verwenden wir den Rückgabetyp „void“, was bedeutet, dass die Funktion nichts zurückgibt. Als Nächstes geben Sie Ihrer Funktion einen Namen. Innerhalb der Klammern können Sie beliebige Argumente oder Parameter definieren, die Ihre Funktion empfängt. In diesem Fall haben wir keine Argumente, daher sind die Klammern leer. Abschließend definieren Sie den Funktionskörper in geschweiften Klammern.
In unserem Beispiel haben wir eine Funktion namens „function“ mit dem Rückgabetyp „void“ und ohne Argumente erstellt. Im Hauptteil der Funktion verwenden wir die „cout“-Anweisung, um „Hello from function“ anzuzeigen und eine Endzeile hinzuzufügen. Durch einfaches Erstellen der Funktion wird jedoch nicht der Code ausgeführt. Um die Funktion auszuführen, müssen Sie sie aufrufen oder aufrufen. In unserem Fall rufen wir die Funktion nach der „cout“-Anweisung in der Hauptfunktion auf, indem wir ihren Namen gefolgt von Klammern eingeben.
Nach dem Kompilieren und Ausführen des Programms sehen Sie die Ausgabe „Hello from main“, gefolgt von „Hello from function“. Dies liegt daran, dass zuerst die Hauptfunktion ausgeführt wird und dann die von uns erstellte Funktion ausgeführt wird, wenn sie aufgerufen wird.
Um Ihren Code besser lesbar zu machen, wird empfohlen, Ihre Funktionen separat zu deklarieren und zu definieren. Die Deklaration umfasst den Rückgabetyp, den Funktionsnamen und alle Parameter und sollte vor der Hauptfunktion platziert werden. Die Definition, die den Hauptteil der Funktion enthält, wird nach der Hauptfunktion platziert. Auf diese Weise kann jemand anderes, der Ihren Code liest, problemlos zu der spezifischen Funktion navigieren, die er verstehen muss.
Denken Sie daran, dass Funktionen Ihren Code wiederverwendbar machen. Anstatt denselben Code mehrmals zu schreiben, können Sie ihn einmal in eine Funktion schreiben und diese Funktion jederzeit aufrufen, wenn Sie sie benötigen. Diese Vorgehensweise trägt dazu bei, Redundanz zu reduzieren und erleichtert die Verwaltung Ihres Codes.
In zukünftigen Videos werden wir die Funktionen genauer untersuchen. Vergessen Sie nicht, meinen Kanal zu abonnieren und Benachrichtigungen zu aktivieren, um über die kommenden Inhalte auf dem Laufenden zu bleiben. Vielen Dank fürs Zuschauen, wir sehen uns im nächsten Video!
C++-FUNKTIONEN (2020) – Was ist ein Funktionsparameter/-argument (mehrfach, Standard)? PROGRAMMIERTUTORIAL
C++-FUNKTIONEN (2020) – Was ist ein Funktionsparameter/-argument (mehrfach, Standard)? PROGRAMMIERTUTORIAL
Hallo an alle! Willkommen zurück auf meinem Kanal. Wenn Sie ein Anfänger in C++ sind, freue ich mich, dass Sie hier sind. Bevor wir uns mit dem heutigen Thema befassen, möchte ich Sie daran erinnern, sich meine C++-Playlist für Anfänger anzusehen. Es behandelt wesentliche Konzepte und enthält zahlreiche Übungen, die Ihnen beim Üben helfen. Vergessen Sie außerdem nicht, meinen Kanal zu abonnieren und auf das Glockensymbol zu klicken, um Benachrichtigungen zu erhalten, wenn ich ein neues Video veröffentliche. Sie können mir auch auf meinen Social-Media-Profilen CodeBeauty Instagram und Twitter folgen, um einen kleinen Einblick in das Leben eines Entwicklers zu erhalten. Okay, ohne weitere Umschweife, fangen wir mit der heutigen Lektion an.
In diesem Video möchte ich C++-Funktionsparameter oder -argumente diskutieren. Was genau sind also Parameter und Argumente? Wenn Sie mein vorheriges Video zu C++-Funktionen noch nicht gesehen haben, empfehle ich Ihnen, es sich anzusehen (Link bereitgestellt). Manchmal muss eine Funktion einen bestimmten Wert oder eine bestimmte Variable empfangen, um eine bestimmte Aufgabe auszuführen. Diese Werte oder Variablen werden Parameter genannt.
Jetzt lernen wir, wie man in C++ eine Funktion erstellt, die Parameter akzeptiert. Dazu definieren wir eine Funktion mit dem Rückgabetyp void. Nennen wir die Funktion „introduceMe“. In den Klammern geben wir die Parameter an, die die Funktion erhalten wird. Der Hauptteil unserer Funktion wird in geschweifte Klammern eingeschlossen.
Um einen Parameter zu definieren, geben wir zunächst den Typ des Parameters an, gefolgt von seinem Namen. In unserem Fall möchten wir den Namen unseres Benutzers an die Funktion übergeben, sodass der Parameter vom Typ String ist. Wir nennen den Parameter „Name“. Die Funktion stellt unseren Benutzer dann vor, indem sie „Mein Name ist“ gefolgt vom angegebenen Namen ausgibt.
Um unsere Funktion aufzurufen oder aufzurufen, verwenden wir einfach ihren Namen „introduceMe“. Da unsere Funktion ein Argument (den Namensparameter) erfordert, müssen wir beim Aufruf der Funktion einen Wert übergeben. In diesem Fall übergeben wir als Argument den Namen „Selena“.
Wenn wir das Programm ausführen, führt die Funktion den Benutzer erfolgreich mit dem angegebenen Namen ein. Es wird wie erwartet „Mein Name ist Selena“ gedruckt.
Wenn wir mehrere Benutzer einführen möchten, können wir die Funktion mit anderen Argumenten erneut aufrufen. Wir können beispielsweise die Aufrufzeile kopieren und einen anderen Namen übergeben, beispielsweise „Anna“. Die Funktion stellt dann beide Benutzer entsprechend vor.
Sehen wir uns nun die Übergabe mehrerer Argumente an eine Funktion an. Dazu trennen wir die Parameter durch Kommas. Fügen wir zusätzlich zum Namensparameter zwei weitere Parameter hinzu: Stadt (vom Typ String) und Alter (vom Typ Int). Wir werden die Funktion so ändern, dass sie auch Informationen über die Stadt und das Alter des Benutzers enthält.
Innerhalb der Funktion verwenden wir „cout“ von C++, um die Stadt und das Alter des Benutzers zusammen mit seinem Namen auszugeben. Wir strukturieren die Ausgabe wie folgt: „Ich komme aus [Stadt] und bin [Alter] Jahre alt.“
Wenn wir die Funktion aufrufen, übergeben wir die Werte für alle drei Parameter: Name, Stadt und Alter. Beispielsweise können wir die Funktion aufrufen und „Selena“ als Namen, „Moskau“ als Stadt und 25 als Alter übergeben. Die Funktion stellt dem Benutzer alle bereitgestellten Informationen vor.
Wir können den Vorgang für einen zweiten Benutzer wiederholen. Übergeben wir „Anna“ als Namen, „New York“ als Stadt und 27 als Alter. Wenn wir das Programm ausführen, sehen wir, dass beide Benutzer mit ihren jeweiligen Daten vorgestellt wurden.
Lassen Sie uns als Nächstes die Standardparameter untersuchen. Manchmal möchten Sie möglicherweise einen Standardwert für einen Parameter definieren. Dieser Wert wird verwendet, wenn beim Aufruf der Funktion kein Argument für diesen Parameter angegeben wird.
Um einen Standardwert anzugeben, weisen wir ihn bei der Parameterdeklaration zu. Legen wir beispielsweise den Standardwert für den Parameter „Alter“ auf 18 fest. Wenn wir nun die Funktion aufrufen, ohne ein Alter anzugeben, nimmt sie den Standardwert an.
Rufen wir die Funktion für einen dritten Benutzer auf und übergeben dabei nur den Namen und die Stadt, lassen aber das Alter weg. Wie erwartet stellt die Funktion dem Benutzer den Standardalterswert 18 vor.
Damit ist unsere Diskussion über C++-Funktionsparameter und -Argumente abgeschlossen. Ich hoffe, dass Sie dieses Video hilfreich fanden und dass Sie ein solides Verständnis für die Arbeit mit Funktionsparametern in C++ haben. Wenn Sie Fragen haben oder weitere Erläuterungen benötigen, hinterlassen Sie bitte unten einen Kommentar. Ich helfe Ihnen gerne weiter. Seien Sie gespannt auf weitere C++-Tutorials und vergessen Sie nicht, dieses Video zu liken und zu teilen, wenn Sie es wertvoll finden. Vielen Dank fürs Zuschauen und viel Spaß beim Codieren!
C++-FUNKTIONEN (2020) – Funktionsrückgabeanweisung, So überprüfen Sie Primzahlen
C++-FUNKTIONEN (2020) – Rückgabeanweisung für Funktionen, So prüfen Sie Primzahlen. PROGRAMMIER-TUTORIAL
Hallo zusammen, willkommen auf meinem Kanal. In diesem Video möchte ich Rückgabeanweisungen und Rückgabetypen von Funktionen in C++ diskutieren. Wenn Sie ein Anfänger sind, schauen Sie sich unbedingt meinen C++-Anfängerkurs an, der nützliche Beispiele enthält, die Ihnen den Einstieg in das Erlernen von C++ erleichtern. Vergessen Sie nicht, meinen Kanal zu abonnieren und auf die Benachrichtigungsglocke zu klicken, um über neue Videos auf dem Laufenden zu bleiben. Wenn Sie außerdem daran interessiert sind, Entwickler zu werden und Einblicke in das Leben des Entwicklers zu gewinnen, folgen Sie mir auf Instagram und Twitter unter @truecodebeauty (Links in der Videobeschreibung). Lassen Sie uns ohne weitere Umschweife in das heutige Thema eintauchen.
Ein Rückgabetyp einer Funktion kann ein beliebiger Datentyp sein, einschließlich int, float, bool, char, double oder sogar benutzerdefinierte Datentypen. Es kann auch „void“ sein, was darauf hinweist, dass die Funktion nichts zurückgibt. In früheren Videos habe ich erklärt, dass eine Funktion ein Codeblock ist, der eine bestimmte Aufgabe ausführen soll. Funktionen können in zwei Typen eingeteilt werden: solche, die einen Wert zurückgeben, und solche, die keinen Wert zurückgeben.
Funktionen, die keinen Wert zurückgeben, führen normalerweise eine bestimmte Aktion aus, beispielsweise die Anzeige eines Menüs für den Benutzer. Andererseits werden Funktionen, die einen Wert zurückgeben, verwendet, um Berechnungen oder Operationen durchzuführen und ein Ergebnis bereitzustellen. Es ist wichtig zu beachten, dass eine Funktion nur einen Wert zurückgeben kann und sobald die Return-Anweisung angetroffen wird, die Funktionsausführung stoppt.
Um die Bedeutung von Funktionen zu veranschaulichen, betrachten wir ein Beispiel ohne die Verwendung von Funktionen. Wir erstellen ein Programm, um festzustellen, ob eine Zahl eine Primzahl ist oder nicht. Eine Primzahl ist nur durch eins und sich selbst teilbar. Zuerst bitten wir den Benutzer, eine Nummer einzugeben. Dann durchlaufen wir alle Zahlen zwischen 2 und der vom Benutzer eingegebenen Zahl minus 1. Wenn die Zahl durch einen dieser Werte teilbar ist, ist sie keine Primzahl. Ansonsten ist es erstklassig. Abschließend zeigen wir das Ergebnis an.
Lassen Sie uns nun das Programm mithilfe von Funktionen umgestalten, um den Code lesbarer und wiederverwendbar zu machen. Wir erstellen eine Funktion namens „isPrimeNumber“, die ein ganzzahliges Argument akzeptiert und einen booleschen Wert zurückgibt, der angibt, ob die Zahl eine Primzahl ist oder nicht. Innerhalb der Funktion implementieren wir die gleiche Logik wie zuvor, prüfen die Teilbarkeit und setzen entsprechend ein Flag. Zum Schluss geben wir den Flag-Wert zurück.
Durch die Verwendung von Funktionen können wir die Logik zur Bestimmung von Primzahlen kapseln und so den Code leichter verständlich und wiederverwendbar machen.
C++-FUNKTIONEN (2020) – Was ist Funktionsüberladung? PROGRAMMIERTUTORIAL
C++-FUNKTIONEN (2020) – Was ist Funktionsüberladung? PROGRAMMIERTUTORIAL
Hallo an alle! Willkommen zurück auf meinem Kanal. Im heutigen Video werden wir uns mit dem Konzept der Funktionsüberladung in C++ befassen. Durch Funktionsüberladung können wir mehrere Funktionen mit demselben Namen, aber unterschiedlichen Parametern erstellen. Lassen Sie uns also untersuchen, was Funktionsüberladung ist und wie sie funktioniert.
Öffnen wir zunächst unser Visual Studio und erstellen eine Funktion namens „sum“. Wir beginnen mit der Definition des Rückgabetyps unserer Funktion, der eine Ganzzahl sein wird. Wenn Sie mit Rückgabetypen nicht vertraut sind, empfehle ich Ihnen, sich mein Video zu diesem Thema anzusehen (Link bereitgestellt). Als nächstes geben wir den Namen unserer Funktion als „sum“ an und deklarieren zwei Parameter. Beide Parameter sind vom Typ Integer und wir nennen sie „a“ bzw. „b“.
Jetzt erstellen wir eine weitere Funktion mit demselben Namen, „sum“, aber dieses Mal mit dem Rückgabetyp „double“. Wir deklarieren zwei Parameter vom Typ double mit den Namen „a“ und „b“.
Erstellen wir außerdem eine dritte Funktion namens „sum“ mit dem Rückgabetyp „float“. Dieses Mal übergeben wir drei Parameter, die alle vom Typ float sind. Wir nennen sie jeweils „a“, „b“ und „c“.
Nachdem wir unsere Funktionen deklariert haben, bemerken wir, dass sie unterstrichen sind, was darauf hinweist, dass ihnen ihre Definitionen fehlen. Fahren wir fort, indem wir die Definitionen für jede Funktion bereitstellen. Wir beginnen mit der ersten Funktion, die eine Ganzzahl zurückgibt.
Innerhalb der geschweiften Klammern definieren wir eine Variable namens „result“ vom Typ int. Wir weisen ihm den Wert „a + b“ zu, der die Summe der beiden Parameter darstellt. Schließlich verwenden wir das Schlüsselwort „return“, um den Wert von „result“ von der Funktion zurückzugeben.
Anstatt eine separate Variable zu erstellen, können wir alternativ auch direkt die Summe von „a“ und „b“ zurückgeben, ohne sie einer Variablen zuzuweisen. Dadurch kann der Code kürzer und besser lesbar werden.
Als nächstes definieren wir die zweite Funktion, die ein Double zurückgibt. Wir kopieren die Deklaration, fügen die geschweiften Klammern hinzu und verwenden darin das Schlüsselwort „return“, gefolgt von „a + b“. Da die Parameter vom Typ double sind, wird die Summe mit doppelter Genauigkeit durchgeführt.
Definieren wir nun die dritte Funktion, die einen Float zurückgibt. Wir kopieren die Deklaration, fügen die geschweiften Klammern hinzu und verwenden darin das Schlüsselwort „return“, gefolgt von „a + b + c“. Da alle Parameter wiederum vom Typ Float sind, wird die Summe entsprechend ausgeführt.
Um unsere Funktionen zu testen, rufen wir sie in der „main“-Funktion auf. Wir verwenden die „cout“-Anweisung, um die Ergebnisse anzuzeigen. Beginnen wir damit, die erste Funktion „sum“ aufzurufen und zwei ganzzahlige Werte wie 4 und 3 zu übergeben. Das Ergebnis geben wir mit „cout“ aus und beenden die Zeile.
Wenn wir das Programm ausführen, können wir damit rechnen, das Ergebnis der Summierung von 4 und 3 zu sehen, das 7 sein sollte. Wenn das Programm erfolgreich ausgeführt wird, haben wir unsere erste Funktion getestet.
Als nächstes testen wir die zweite Funktion, indem wir „sum“ aufrufen und zwei Double-Werte übergeben, z. B. 4,4 und 3,3. Auch hier geben wir das Ergebnis mit „cout“ aus und beenden die Zeile.
Wenn wir das Programm ausführen, sollten wir das Ergebnis der Summierung von 4,4 und 3,3 sehen, das 7,7 sein sollte. Wenn die Ausgabe korrekt ist, haben wir unsere zweite Funktion erfolgreich getestet.
Lassen Sie uns abschließend die dritte Funktion testen, indem wir „sum“ aufrufen und drei Float-Werte übergeben, z. B. 4,4, 3,3 und 2,2. Das Ergebnis geben wir mit „cout“ aus und beenden die Zeile.
Beim Ausführen des Programms sollte das Ergebnis der Summierung von 4,4, 3,3 und 2,2 angezeigt werden, was der korrekten Summe entsprechen sollte. Überprüfen Sie die Ausgabe bei Bedarf mit einem Taschenrechner.
Zusammenfassend haben wir hier eine Funktionsüberladung demonstriert. Wir haben drei Funktionen mit demselben Namen, „sum“, aber mit unterschiedlichen Parametern und Rückgabetypen erstellt. Die erste Funktion akzeptiert zwei Ganzzahlen, die zweite zwei Doubles und die dritte drei Floats. Wenn wir diese Funktionen aufrufen, bestimmt der Compiler anhand der bereitgestellten Argumente, welche Funktion zum Aufrufen geeignet ist.
Durch das Überladen von Funktionen können wir prägnanteren und lesbareren Code schreiben, indem wir denselben Namen für Funktionen verwenden, die ähnliche Aufgaben ausführen. Wir müssen nicht für jede Variante separate Funktionen mit unterschiedlichen Namen erstellen.
Ich hoffe, Sie verstehen jetzt das Konzept der Funktionsüberladung und wie sie in C++ nützlich sein kann. Wenn Ihnen dieses Video gefallen hat, abonnieren Sie bitte meinen Kanal und klicken Sie auf das Glockensymbol, um Benachrichtigungen für zukünftige Videos zu erhalten. Sie können mir auch auf meinen anderen Social-Media-Plattformen folgen (Links in der Beschreibung).
Vielen Dank fürs Zuschauen, wir sehen uns in meinem nächsten Video. Tschüss!