Fouten zijn de bewerkingen die het gevolg kunnen zijn van de abnormale werking van een code. De fout kan op het moment van schrijven niet worden gedetecteerd totdat we de code hebben uitgevoerd of deze is gecompileerd. Sommige fouten voorkomen dat de code wordt uitgevoerd totdat ze zijn verwijderd. Vandaag bespreken we ook een fout die ook optreedt bij het compileren van het programma, namelijk “error: no match for ‘operator=’”. Deze fout kan worden veroorzaakt om redenen zoals: als we de aanwijzer zijn gepasseerd waar de string moet worden doorgegeven, de constante variabele wijzigen, enz. Het is niet moeilijk om de fout 'niet levensvatbaar overbelast' te verwijderen, maar de belangrijkste taak is om begrijp de fout omdat het alleen de fout toont zonder enige beschrijving van de fout.
Syntaxis
Er is niet zo'n vooraf gedefinieerde syntaxis voor deze fout omdat deze geen deel uitmaakt van de code of de uitvoer, het is slechts een dubbelzinnigheid die kan worden veroorzaakt door de verkeerde code. Zoals we kunnen zien, is hieronder een voorbeeld van hoe de fout eruit kan zien.
fout : geen match voor ‘operator = '
Voorbeeld # 01:
Laten we een idee hebben over deze fout en de methode om dit op te lossen. Om het beter te begrijpen, zullen we een voorbeeld uitvoeren waarin we de namen met behulp van objecten aan de functie doorgeven en deze vervolgens weergeven. We zullen eerst het headerbestand iostream opnemen. Daarna declareren we een klasse met de naam 'my_object'. Daarbinnen hebben we twee stringvariabelen gedeclareerd met de naam 'F_name en'L_name', de 'F_name' die de voornaam van de persoon aangeeft, waarbij de 'L_name' de achternaam van de persoon aangeeft.
Vervolgens hebben we een openbare constructor met de naam 'my_object ()' gedeclareerd waarin we null-waarden hebben toegewezen aan zowel de variabelen 'F_name' als 'L_name'. Daarna hebben we een andere functie gedeclareerd waaraan we de stringtypevariabelen 'fn' en 'ln' hebben doorgegeven. Daarbinnen hebben we de methode name_set() genoemd. Vervolgens hebben we twee lidfuncties 'show()' en 'name_set()' gedeclareerd. Wanneer de functie 'show() wordt aangeroepen, worden de voornamen en achternamen samen weergegeven. Terwijl we in de lidfunctie 'set_name()' twee tekenreeksvariabelen van het tekenreekstype 'fn' en 'ln' hebben doorgegeven, die we ook hebben doorgegeven aan de tweede constructor.
Nu gebruiken we de kopieertoewijzingsoperator van de klasse my_object en nemen we één parameter van het type 'my_object'. De compiler verklaart het altijd als een inline openbaar lid van een klasse. Binnen dit lid hebben we de src.F_name toegewezen aan de 'F_name' en src.L_name aan de 'L_name' die we de kopie van de 'F_name' en 'L_name' hebben behouden. Dit wordt doorgegeven aan de leden van de klasse my_object. Nu hebben we een object van de klasse my_cobject met de naam 'name1' gedeclareerd waaraan we twee strings 'Anna' en 'smith' als argument hebben doorgegeven. Hiermee wordt de constructor aangeroepen en wordt de voornaam samen met de achternaam weergegeven.
Daarna hebben we een ander object 'name2' gemaakt en vervolgens de naam afzonderlijk aan dat object toegewezen. Na het doorgeven van waarden aan de constructor voor beide objecten, hebben we de methode show() aangeroepen die vervolgens de namen voor beide objecten 'nam1' en 'name2' zal weergeven. Aan het einde van de code hebben we de null-waarde geretourneerd en onze code uitgevoerd.
erbij betrekkenklas mijn_voorwerp {
privaat :
soa :: snaar F_naam, L_naam ;
openbaar :
mijn_voorwerp ( ) { F_naam = ' ' ; L_naam = ' ' ; }
mijn_voorwerp ( soa :: snaar fn, standaard :: snaar In ) {
naam_set ( fn, ln ) ;
}
leegte show ( ) { soa :: cout << 'De naam is ' << F_naam << ' ' << L_naam << '. \n ' ; }
leegte naam_set ( soa :: snaar fn, standaard :: snaar In ) { F_naam = fn ; L_naam = In ; }
mijn_voorwerp & exploitant = ( const mijn_voorwerp & src ) {
F_naam = src. F_naam ;
L_naam = src. L_naam ;
opbrengst * deze ;
}
} ;
int hoofd ( int argc, char ** argv ) {
mijn_object naam1 ( 'Anna' , 'smid' ) ;
mijn_objectnaam2 ;
naam2 = ( 'Anna' , 'smid' ) ;
naam1. show ( ) ;
naam2. show ( ) ;
opbrengst 0 ;
}
Na de uitvoering van onze code hebben we deze fout die aangeeft dat we de verkeerde code op regel 24 hebben geschreven en het type fout aangeven dat is opgetreden 'error: no match for 'operator=''. Nu zullen we proberen deze fout op te lossen.
Om deze fout op te lossen, hebben we meerdere manieren om de waarden door te geven aan de constructor van een klasse. Bij de eerste methode wijzen we eenvoudig het object 'name1' toe aan het object 'name2' omdat we dezelfde waarden aan beide objecten hebben doorgegeven, dus het is niet nodig om ze afzonderlijk door te geven. Nu voeren we de code uit.
int hoofd ( int argc, char ** argv ) {mijn_object naam1 ( 'Anna' , 'smid' ) ;
mijn_objectnaam2 ;
naam2 = naam1 ;
naam1. show ( ) ;
naam2. show ( ) ;
Nadat we de code hebben gewijzigd zoals hierboven weergegeven, hebben we het resultaat in het onderstaande fragment. We hebben weergegeven dat de naam die aan de constructor is doorgegeven, zonder fouten wordt weergegeven.
De tweede methode om deze fout op te lossen is wanneer we de verschillende waarden aan beide objecten moeten doorgeven. We gebruiken gewoon de klassenaam samen met de waarden die als argument aan de constructor moeten worden doorgegeven. We passeerden de voornaam 'jhone' en de tweede naam 'smith'. Vervolgens hebben we de code uitgevoerd.
int hoofd ( int argc, char ** argv ) {mijn_object naam1 ( 'Anna' , 'smid' ) ;
mijn_objectnaam2 ;
naam2 = mijn_voorwerp ( 'John Smith' ) ;
naam1. show ( ) ;
naam2. show ( ) ;
Na het uitvoeren van de hierboven toegevoegde code, hebben we de uitvoer zoals hieronder weergegeven. Voor het object 'name1' werd de naam 'Anna Smith' weergegeven en voor het tweede object 'name2' werd 'Jhone Smith' weergegeven. Maar deze keer werkte onze code goed zonder fouten erin.
Nu zullen we een andere methode proberen om onze code met succes uit te voeren. Net als in de bovenstaande gevallen hebben we geprobeerd de waarden aan de objecten toe te wijzen met behulp van de toewijzingsoperator. Maar deze keer zullen we de waarden doorgeven op het moment van declaratie van het object. Zoals we in het onderstaande fragment kunnen zien, hebben we op het moment van de declaratie van een object 'name1' de waarden als een argument doorgegeven aan het object door dezelfde stap te herhalen voor de 'name2'. Nu voeren we de code nogmaals uit.
int hoofd ( int argc, char ** argv ) {mijn_object naam1 ( 'Anna' , 'smid' ) ;
mijn_objectnaam2 ( 'John Smith' ) ;
naam1. show ( ) ;
naam2. show ( ) ;
Nadat de code ook voor deze tijd is uitgevoerd, zijn we geen fouten tegengekomen, wat betekent dat dit ook voorkomt dat we fouten krijgen.
Conclusie
We hebben kort een fout besproken die we kunnen tegenkomen tijdens het werken aan functies die toegankelijk zijn vanuit klassen. We hebben ook de oorzaken en methoden bestudeerd om de fout 'niet levensvatbaar overbelast' op te lossen. Meestal is deze fout moeilijk te begrijpen voor nieuwe programmeurs, dus we hebben geprobeerd om het voor hen gemakkelijk te maken om hiervan af te komen door voorbeelden te implementeren en ook met uitleg.