In diesem Artikel geht es um cout mehrdeutige Fehler in der Programmiersprache C++. Die unklare Situation tritt auf, wenn der Compiler die für verschiedene Aufgaben zu verwendenden Methoden oder Operatoren nicht bestimmen kann. Manchmal verwenden wir dieselbe Parameterfunktion mit demselben Namespace, und dann wird in beiden Fällen cout definiert. Wenn wir das Programm ausführen, generiert der Compiler den Fehler „cout mehrdeutig“, da der Compiler nicht versteht, welche Bedeutung dieser Code zeigt. Die Cout-Mehrdeutigkeit entsteht, wenn ein Konflikt zwischen den definierten Namespaces oder mehreren Funktionsdeklarationen innerhalb des Programms besteht.
Beispiel 1:
Dies ist ein Beispiel für einen Cout-Mehrdeutigkeitsfehler, der hauptsächlich bei der C++-Programmierung auftritt. Hier sehen wir, wie der Compiler die mehrdeutigen Fehler bei cout generiert, wenn wir mehrere Namespaces verwenden. Der Codeausschnitt dieses Beispiels wird im Folgenden erwähnt:
#include
Namensraum Laptop {
Leere Anzeige ( ) {
std :: cout << „Das ist der Laptop-Namespace“ << std :: endl ;
}
}
Namensraum Handy, Mobiltelefon {
Leere Anzeige ( ) {
std :: cout << „Dies ist ein mobiler Namespace“ << std :: endl ;
}
}
int hauptsächlich ( ) {
verwenden Namensraum Laptop ;
verwenden Namensraum Handy, Mobiltelefon ;
Anzeige ( ) ;
zurückkehren 0 ;
}
Hier haben wir ein Programm mit zwei Namensräumen genommen, die entsprechend unserem Bedarf definiert sind. Wir möchten die Zeichenfolgen auf dem Bildschirm anzeigen. Die Ausgabe dieses Codes ist im Folgenden beigefügt:
Bei der Codeausführung wird der Fehler bezüglich der nicht eindeutigen Situation generiert. Der Fehler wird generiert, weil der Compiler beim Lesen des Codes keine klare Eingabe vom Benutzer erhält. Wir haben in unserem Code mehrere Namespace-Deklarationen verwendet. Im gesamten Code haben wir die Methode „display“ ausschließlich dazu verwendet, die Ausgabe auf dem Bildschirm anzuzeigen. Der Compiler hat keine Ahnung, welche Anzeigemethode zu welchem Namespace gehört. Wir müssen den Code einfach und klar gestalten, damit der Compiler die Schritte leicht versteht, ohne den Code mehrdeutig zu machen.
Die Lösung für diesen Fehler besteht darin, die Methode mit einem zugehörigen Namespace in der Hauptfunktion aufzurufen, damit der Compiler sie besser versteht. Wir geben in unserem Hauptausführungsteil klar an, welche Methode des Namespace wir aufrufen möchten.
#includeNamensraum Laptop {
Leere Anzeige ( ) {
std :: cout << „Das ist der Laptop-Namespace“ << std :: endl ;
}
}
Namensraum Handy, Mobiltelefon {
Leere Anzeige ( ) {
std :: cout << „Dies ist ein mobiler Namespace“ << std :: endl ;
}
}
int hauptsächlich ( ) {
verwenden Namensraum Laptop ;
verwenden Namensraum Handy, Mobiltelefon ;
Laptop :: Anzeige ( ) ;
zurückkehren 0 ;
}
Hier können wir einfach die Methode display() mit dem Namespace „laptop“ in der Hauptfunktion verknüpfen, wie im vorherigen Screenshot zu sehen ist. Führen Sie nun das Programm aus. Die Ausgabe wird im Konsolenfenster angezeigt.
Beispiel 2:
Dieses Szenario hängt mit dem Fehler „cout mehrdeutig“ in C++ zusammen. Der Compiler zeigt einen Fehler an, wenn er den Ausführungsablauf nicht versteht. Der Codeausschnitt dieses Beispiels ist im Folgenden beigefügt:
#includeNamensraum C Sprache {
Leere drucken ( int ich ) {
std :: cout << „Namespace der C-Sprache:“ << ich << std :: endl ;
}
}
Namensraum Java {
Leere drucken ( int J ) {
std :: cout << „Namespace der Java-Sprache:“ << J << std :: endl ;
}
}
verwenden Namensraum C Sprache ;
verwenden Namensraum Java ;
int hauptsächlich ( ) {
drucken ( 5 ) ;
zurückkehren 0 ;
}
In diesem Code definieren wir alle erforderlichen Bibliotheksheader. Wir erstellen zwei Namensräume für unterschiedliche Zwecke. Im Namensraum „CLanguage“ definieren wir eine „Print“-Methode, die den ganzzahligen Wert vom Benutzer übernimmt. In der Funktion „Drucken“ möchten wir den Wert anzeigen, den der Benutzer auf dem Konsolenbildschirm übergeben hat. Wir zeigen die erforderliche Ausgabe mithilfe des Streams „cout“ in unserem Code an. Danach definieren wir einen weiteren Namespace mit dem Namen „Java“.
In diesem „Java“-Namespace verwenden wir erneut die Methode „print“, um den Wert anzuzeigen, den der Benutzer mit „cout“ übergibt. Wir rufen beide Namespaces zur Verwendung in unserer Hauptfunktion auf, um die gewünschte Ausgabe im Konsolenfenster in C++ zu erhalten. In der Funktion „main“ rufen wir die überladene Funktion „print()“ auf, um den übergebenen Wert auf dem Konsolenbildschirm anzuzeigen.
Klicken Sie im Hauptmenü auf die Option „Ausführen“ und wählen Sie die Option „Kompilieren und Ausführen“. Bei dieser Codeausführung tritt der Fehler wegen Mehrdeutigkeit auf. Der Fehler-Screenshot ist wie folgt beigefügt:
Dieser Fehler weist darauf hin, dass der Compiler über die aufgerufene überladene print()-Funktion verwirrt ist. Dieser Fehler befindet sich in Zeile 19, „print (5)“. Der Compiler ist verwirrt über den Namespace, zu dem diese überladene Funktion gehört. Die Anfänger bleiben die meiste Zeit in solchen Fehlern stecken.
Lassen Sie uns diesen Fehler beheben, der in Wirklichkeit nicht komplex ist. Die mehrdeutigen Fehler lassen sich leicht beheben. Wir müssen den Namespace entlang der überladenen Funktion in der „Haupt“-Funktion angeben, um die Sichtbarkeit und das Verständnis des Compilers zu gewährleisten. Wie in diesem Programm fügen wir dieses „java::print(5)“ in unseren vorhandenen Code ein, wie im Folgenden erwähnt:
#includeNamensraum C Sprache {
Leere drucken ( int ich ) {
std :: cout << „Namespace der C-Sprache:“ << ich << std :: endl ;
}
}
Namensraum Java {
Leere drucken ( int J ) {
std :: cout << „Namespace der Java-Sprache:“ << J << std :: endl ;
}
}
verwenden Namensraum C Sprache ;
verwenden Namensraum Java ;
int hauptsächlich ( ) {
Java :: drucken ( 5 ) ;
zurückkehren 0 ;
}
Jetzt wird das Programm perfekt und ohne eindeutige Fehler ausgeführt und zeigt die Ausgabe auf dem Konsolenbildschirm an. Die Ausgabe dieses Programms ist im Folgenden beigefügt:
Beispiel 3:
Dies ist das letzte und letzte Beispiel für einen Fehler, der aufgrund eines mehrdeutigen Problems generiert wird. Der Compiler kann nicht das richtige Ergebnis erhalten. Der Codeausschnitt dieses Beispiels ist zum besseren Verständnis des Benutzers im Folgenden beigefügt:
Hier definieren wir die benötigten Bibliotheken. Danach definieren wir einen Namespace, der die Klasse enthält, in der wir den String im Konsolenfenster anzeigen möchten. Diesen definierten Namensraum rufen wir in der Funktion „main“ mit der Variablen „c“ auf. Danach rufen wir die print()-Methode mithilfe eines Namespace-Objekts auf. Wir zeigen den String nach dem Methodenaufruf erneut auf dem Konsolenbildschirm an. Die Ausgabe muss aus beiden Zeichenfolgen bestehen und wird auf dem Konsolenbildschirm angezeigt. Wenn wir diesen Code ausführen, tritt der Fehler wie im Folgenden gezeigt auf:
#includeverwenden Namensraum std ;
Namensraum meinNamespace {
Klasse cout {
öffentlich :
Leere drucken ( ) {
cout << „Benutzerdefinierter Schnitt“ << std :: endl ;
}
} ;
}
int hauptsächlich ( ) {
meinNamespace :: cout C ;
C. drucken ( ) ;
cout << 'Hallo Welt!' << std :: endl ;
zurückkehren 0 ;
}
Der Compiler hat die cout-Anweisung, die die Daten auf dem Konsolenbildschirm anzeigt, nicht ausgewählt. Der Compiler kann den Namespace, der zur cout-Anweisung gehört, nicht verstehen und generiert einen Fehler. Die Lösung für diesen Fehler besteht darin, ein Namespace-Objekt mit einer Cout-Anweisung hinzuzufügen, um die Lesbarkeit und das Verständnis des Compilers zu gewährleisten. Fügen Sie „std::“ entlang der cout-Anweisung hinzu und führen Sie den Code aus. Die folgende Ausgabe wird auf dem Konsolenbildschirm angezeigt:
Abschluss
Hier können wir sagen, dass auch die Anzeige einer Ausgabe auf dem Konsolenbildschirm einen Fehler erzeugt, der weder ein Syntaxfehler noch ein logischer Fehler ist. Meistens schreibt der Benutzer einen guten Code, der für den Compiler jedoch nicht verständlich ist. Der Compiler ist hinsichtlich der Eingabe nicht eindeutig. Klären Sie daher jeden Codeschritt mit dem richtigen Namensraum und der richtigen Syntax, um Fehler in der Programmiersprache C++ zu vermeiden. Die zur Lösung dieses Problems erforderlichen Schritte bestehen darin, explizite Qualifizierer zu verwenden, Namespace-Konflikte zu verhindern und sicherzustellen, dass die beabsichtigten Funktionen oder Objekte die zur Lösung dieses Problems erforderlichen Schritte identifiziert haben.