C ++ Fehler Nein überlastet '='

Fehler sind die Operationen, die das Ergebnis der abnormalen Arbeit eines Codes sein können. Der Fehler kann zum Zeitpunkt des Schreibens erst dann erkannt werden, bis wir den Code ausgeführt haben oder er zusammengestellt wird. Einige Fehler verbieten den Code, auszuführen, bis sie entfernt werden. Heute werden wir auch einen Fehler diskutieren, der auch auftritt, wenn das Programm zusammengestellt wird, dh "Fehler: Keine Übereinstimmung für 'operator ='" ". Dieser Fehler kann aus Gründen verursacht werden wie: Wenn wir den Zeiger übergeben haben, an dem die Zeichenfolge übergeben werden soll, die konstante Variable usw. ändern soll usw. Es ist nicht schwierig, den Fehler „No praktikabel überlastet“ zu entfernen, aber die Hauptaufgabe besteht darin, den Fehler zu verstehen, da er nur den Fehler ohne Beschreibung des Fehlers zeigt.

Syntax

Für diesen Fehler gibt es keine solche vordefinierte Syntax, da es sich nicht um einen Teil des Codes oder der Ausgabe handelt. Es handelt sich nur um eine Unklarheit, die durch den falschen Code verursacht werden kann. Wie wir sehen können, ist unten ein Beispiel dafür, wie der Fehler aussehen kann.

Fehler: Keine Übereinstimmung für 'operator ='

Beispiel # 01:

Lassen Sie uns eine Vorstellung von diesem Fehler und der Methode haben, um dies zu beheben. Um es besser zu verstehen, werden wir ein Beispiel ausführen, in dem wir die Namen mit Objekten an die Funktion übergeben werden, und es wird sie dann angezeigt. Wir werden zuerst die Header -Datei iSstream einschließen. Danach werden wir eine Klasse namens "my_Object" deklarieren. In diesem Fall haben wir zwei Zeichenfolgevariablen mit dem Namen "F_Name und" L_Name "deklariert, den" F_NAME ", der den Vornamen der Person anzeigt, in der der" l_name "den Nachnamen der Person anzeigt.

Als nächstes haben wir einen öffentlichen Konstruktor mit dem Namen "my_Object ()" deklariert, in dem wir den Variablen "f_Name" als auch "l_name" Nullwerte zugewiesen haben. Danach haben wir eine weitere Funktion deklariert, an die wir die Variablen Typ "FN" und "LN" über die String -Typ -Variablen übergeben haben. In diesem Bereich haben wir die Methode name_set () bezeichnet. Dann haben wir zwei Mitgliedsfunktionen "show ()" und "name_set ()" deklariert, "name_set ()". Wenn die Funktion „show () aufgerufen wird, zeigt sie die Vornamen und Nachnamen zusammen an. Während wir in der Member -Funktion "set_name ()" zwei Zeichenfolgevariablen des Zeichenfolge -Typs "FN" und "LN" übergeben haben, die wir auch an den zweiten Konstruktor übergeben haben.

Mit dem Kopierzuweisungsbetreiber von My_Object nehmen wir nun einen Parameter vom Typ "my_Object" auf. Der Compiler erklärt es immer als Inline -öffentliches Mitglied einer Klasse. In diesem Mitglied haben wir die SRC zugewiesen.F_name zum "f_name" und src.L_NAME zum "l_name", dass wir die Kopie des "F_NAME" und "L_NAME" beibehalten haben. Dies wird an die Mitglieder der Klasse My_Object übergeben. Jetzt haben wir ein Objekt der Klasse my_cobject namens "name1" deklariert, an die wir zwei Zeichenfolgen "Anna" und "Smith" als Argument bestanden haben. Dadurch wird der Konstruktor aufgerufen und den Vornamen zusammen mit dem Nachnamen angezeigt.

Danach haben wir ein anderes Objekt "Name2" erstellt und dem Namen diesem Objekt dann separat zugewiesen. Nachdem wir die Werte für beide Objekte an den Konstruktor übergeben hatten, haben wir die Show () -Methode aufgerufen, die dann die Namen für beide Objekte "NAM1" und "name2" angezeigt wird. Am Ende des Code haben wir den Nullwert zurückgegeben und unseren Code ausgeführt.

enthalten
Klasse my_object
Privatgelände:
std :: string f_name, l_name;
öffentlich:
my_object () f_name = ""; L_name = "";
my_object (std :: string fn, std :: string ln)
name_set (fn, ln);

void show () std :: cout << "The name is " << F_name << " " << L_name << ".\n";
void name_set (std :: string fn, std :: string ln) f_name = fn; L_name = ln;
my_object & operator = (const my_object & src)
F_name = src.F_Name;
L_name = src.L_name;
kehre das zurück;

;
int main (int argc, char ** argv)
my_Object name1 ("Anna", "Smith");
my_Object name2;
name2 = ("Anna", "Smith");
Name1.zeigen();
Name2.zeigen();
Rückkehr 0;

Nach der Ausführung unseres Codes haben wir diesen Fehler, der angezeigt wird, dass wir den falschen Code in Zeile 24 geschrieben haben, der den Fehlertyp angibt, der auf "Fehler: No -Übereinstimmung für 'operator ='" angezeigt wird. Jetzt werden wir versuchen, diesen Fehler zu beheben.

Für die Lösung dieses Fehlers haben wir mehrere Möglichkeiten, die Werte an den Konstruktor einer Klasse zu übergeben. In der ersten Methode weisen wir einfach das Objekt „Name1“ dem „Namen2“ zu, da wir beide Objekte dieselben Werte übergeben haben, sodass sie nicht separat übergeben werden müssen. Jetzt führen wir den Code aus.

int main (int argc, char ** argv)
my_Object name1 ("Anna", "Smith");
my_Object name2;
name2 = name1;
Name1.zeigen();
Name2.zeigen();

Nachdem Änderungen am Code wie oben gezeigt vorgenommen wurden, haben wir das Ergebnis im Snippet unten angegeben. Wir haben angezeigt, dass der an den Konstruktor übergebene Name ohne Fehler erfolgreich angezeigt wird.

Die zweite Methode zur Behebung dieses Fehlers ist, wenn wir die verschiedenen Werte an beide Objekte weitergeben müssen. Wir werden einfach den Klassennamen zusammen mit den Werten verwenden, die als Argument an den Konstruktor übergeben werden sollen. Wir haben den Vornamen "Jhone" und den zweiten Namen "Smith" übergeben. Dann haben wir den Code ausgeführt.

int main (int argc, char ** argv)
my_Object name1 ("Anna", "Smith");
my_Object name2;
name2 = my_object ("jhone", "smith");
Name1.zeigen();
Name2.zeigen();

Nachdem wir den oben genannten Code ausgeführt haben, haben wir die Ausgabe, wie unten gezeigt. Für das Objekt "Name1" zeigte es den Namen "Anna Smith" und für das zweite Objekt "Name2" "Jhone Smith" angezeigt. Aber diesmal funktionierte unser Code ordnungsgemäß ohne Fehler darin.

Jetzt werden wir eine andere Methode versuchen, um unseren Code erfolgreich auszuführen. Wie in den obigen Fällen haben wir versucht, die Werte den Objekten mit dem Zuordnungsoperator den Objekten zuzuweisen. Aber diesmal werden wir die Werte zum Zeitpunkt der Deklaration des Objekts übergeben. Wie wir im Snippet unten sehen können, haben wir zum Zeitpunkt der Deklaration eines Objekts „Name1“ die Werte als Argument an das Objekt übergeben, das denselben Schritt für den „Namen2“ wiederholte. Jetzt führen wir den Code noch einmal aus.

int main (int argc, char ** argv)
my_Object name1 ("Anna", "Smith");
my_Object name2 ("jhone", "smith");
Name1.zeigen();
Name2.zeigen();

Nachdem der Code auch für diese Zeit ausgeführt wurde, haben wir keinen Fehler aufgetreten, was bedeutet, dass wir uns auch daran hindern, Fehler zu haben.

Abschluss

Wir haben kurz einen Fehler besprochen, mit dem wir an Funktionen gearbeitet haben, auf die aus den Klassen zugegriffen wird. Wir haben auch die Ursachen und Methoden untersucht, um den Fehler „kein überlasteter Überlastung“ zu beheben. Meistens ist dieser Fehler für neue Programmierer schwer zu verstehen, daher haben wir versucht, dies leicht zu machen, indem wir Beispiele und auch mit seiner Erklärung implementieren, und auch mit seiner Erklärung.