[C++] operator=() doet zijn werk niet

[SH4D3H]

Ik krijg bij het compileren de volgende error:

code:

In function `int main()':
no match for 'operator=' in 'ob = input()()' 
candidates are: sample sample::operator=(sample&)

De boosdoener bevind zich volgens de compiler op deze regel:

C++:

int main( )
{
    sample ob;
    
    ob = input( ); // DEZE REGEL
    ob.show( );
    
    system( "pause" );
    return 0;
}

Het vreemde is, en dat is ook gelijk het probleem, dat de functie om die regel te regelen wél bestaat:

C++:

sample sample::operator=( sample &ob )
{
       if( strlen( ob.s ) > strlen( s ) ) {
           delete [] s;
           s = new char[ strlen( ob.s ) + 1 ];
           if( ! s ) {
               cout << "Allocation error!\n";
               exit( 1 );
           }
       }
       strcpy( s, ob.s );
       return *this;
}

En ook input() is goed bezig, die returnt namelijk gewoon een object van type sample ...

C++:

sample input( )
{
       char instr[80];
       sample str;
       
       cout << "Enter a string: ";
       cin >> instr;
       
       str.set( instr );
       return str;
}

Ik heb ook al geprobeerd de functie te verwijderen, maar zelfs een bitwise copy wil hij niet
Ik gebruik Dev-C++ op Windows XP Prof SP2.

Wat doe ik verkeerd of zie ik over het hoofd?

[Verwijderd]

Ik ken de compiler die je gebruikt helaas niet, en kan dus ook niet veel zeggen over de foutmelding. Heb je de operator= wel gedeclareerd in de class sample?

Er is ook nog een ander probleem met je code. In de functie input() declareer je de variabele "str". Deze houdt aan het einde van de functie weer op te bestaan. Het is dus niet correct om aan het eind van de functie nog "return str" te doen, want daarna kan er van alles gebeuren....

Een mogelijke manier om het probleem op te lossen is als volgt (het kan ook nog op allerlei andere manieren):

C++:

void input( sample& s ) 
{ 
       std::string instr; 
        
       cout << "Enter a string: "; 
       cin >> instr; 
        
       s.set( instr.c_str() );  
}

In je main() doe je dan

C++:

input( ob );

en hier is dan ook de operator= niet meer nodig.

[NMe]

Moet de operator= functie geen reference returnen?

C++:

sample & sample::operator=( const sample &ob )

Voor zover ik weet, met mijn ietwat roestige C++ kennis, hoort het zo.

[.oisyn]

Simpel: sample::operator=() verwacht een sample&, dus een reference naar een sample, ook wel een l-value genoemd. Je input() functie returnt een sample by value, wat geen l-value is. Zorg dus dat operator= een sample of een const sample& verwacht.

Ook is het gebruikelijk om een reference naar this te returnen ipv een kopie in een operator=()

[SH4D3H]

Nu werkt het idd

Ook is het gebruikelijk om een reference naar this te returnen ipv een kopie in een operator=()

Ah, dan gaat er 1 minder out-of-scope idd.
Is dat dan ook de reden?
Mijn boek ( door Herbert Schild oid ) gebruikte altijd deze vorm dacht ik

[Verwijderd]

Weten jullie wel zeker dat operator=() een reference moet retourneren? Ik kan me dat niet herinneren uit de C++ standaard, maar dat is dan ook wel weer een aardig tijdje geleden. GCC compileert overigens zonder problemen (heb -Wall en -pedantic flags aan staan) als ik geen reference teruggeef. Volgens mij kan het dus prima zonder reference....

Edit:
Sorry, niet goed gelezen. Oisyn heeft gelijk. De foutmelding wordt veroorzaakt door het ontbreken van het keyword "const":

C++:

sample & sample::operator=( sample const &ob ){} //correct
sample & sample::operator=( sample &ob ){} //incorrect

De incorrecte variant geeft bij mij dezelfde foutmelding. Komt inderdaad door het hele l-value verhaal.

[ Voor 36% gewijzigd door Verwijderd op 25-12-2005 17:39 ]

[NMe]

Ik kan me niet voorstellen dat die eerste regel compileert, aangezien const AFAIK voor het type moet staan, en niet erachter?

[SH4D3H]

Dat lijkt me inderdaad verkeerd
Edit: Niet dus, het compileerd idd.
Maarja, dat ik const vergeet was ook niet al te slim, als ik bijv. naar de opzet van mijn copy-constructor kijk, waar ik het wel netjes toepas, is het stom dat ik dat hier niet deed

[ Voor 8% gewijzigd door SH4D3H op 25-12-2005 22:08 . Reden: Tiepvout ]

[Eelis]

.

[ Voor 99% gewijzigd door Eelis op 18-02-2015 19:01 ]

[JeromeB]

Eelis schreef op zondag 25 december 2005 @ 21:16:
[...]

Mag allebei.

Er is toch een verschil tussen const ervoor en const erna?

[LauPro]

Als je het ervoor zet slaat const op de variabele (die is dan constant), en anders slaat het op een constante verwijzing (bijvoorbeeld een pointer). Het kan ook beiden dan maak je een constante variable met (bijv.) een constante pointer. Die kan je dus maar 1 keer initiëren en verder alleen maar uitlezen.

[.oisyn]

JeromeB schreef op zondag 25 december 2005 @ 22:49:
[...]

Er is toch een verschil tussen const ervoor en const erna?

C++:

const int a;  // #1
int const b;  // #2

int * pa;  // #3
int const * pb;  // #4
int * const pc;  // #5
int const * const pd;  // #6

#1 en #2 zijn identiek, const mag zowel voor als na het type worden gespecificeerd. #3 is een gewone pointer naar int, #4 is een pointer naar een const int (de pointer mag je dus wijzen, datgene waarnaar de pointer wijst niet), #5 is een const pointer naar int (de pointer mag je dus niet wijzigen, datgene waarnaar verwezen wordt wel) en #6 is een const pointer naar een const int (hier mag je dus zowel de pointer als de int niet wijzigen)

[ Voor 6% gewijzigd door .oisyn op 26-12-2005 00:41 ]

[JeromeB]

.oisyn en LauPro, dat had ik eigenlijk al wel begrepen. Ik vroeg me af wat het in de situatie van SH4D3H moet zijn, omdat pointers net iets anders zijn dan references.

Ik denk zelf een const ervoor, omdat je de compiler wil laten weten dat ob niet gewijzigt mag worden. Een const erna lijkt me zoiezo onzinnig, omdat het zoiezo niet mogelijk is om de reference te wijzigen.

----------------------

.oisyn, bedankt

[ Voor 6% gewijzigd door JeromeB op 26-12-2005 13:40 ]

[.oisyn]

Een int & const bestaat idd niet

[Verwijderd]

Om nog even in te gaan op de const-verwarring: eigenlijk zet je in c++ het keyword const altijd achter hetgeen wat const moet zijn. Bijvoorbeeld:

C++:

char const * const str; // constante pointer naar een constante char
class A{
public:
  int get() const; // const memberfunctie get()
};

Er is eigenlijk maar een uitzondering: als datgene wat const moet zijn, aan het begin staat. In dat geval mag je het keyword const ook vooraan zetten. Dus mag je schrijven:

C++:

const int i;
int const i;

Dat is dus allebei hetzelfde. Naar mijn mening is dit een van de vele minder slimme keuzes in het design van de taal c++: het schept voornamelijk verwarring. Ikzelf zet, om consequent te zijn, const altijd achter het type.