[c++ linux] Array van zelfgemaakte objecten met constructor?

[Verwijderd]

Beste mensen,

Ik ben nu al een paar maanden aan het prutsen met C++, en meestal kom ik er wel uit met google en diverse tutorials, maar dit keer moet ik toch jullie hulp inroepen

Ik ben bezig met het schrijven van een mailfilter (die SMTP praat) en daarvoor heb ik op dit moment de (uiterst simpele) klasse Email. In een andere klasse ('SMTPserver') wil ik in een array (pointer) een aantal van deze 'Email'-objecten hebben, die array moet echter klasse-breed zijn. Een stukje uit SMTPserver.h:

code:

class SMTPServer {
    public: 
        SMTPServer(void);
        
    private:
        Email * listEmails;
};

(dit gaat goed)

Echter, nu ga ik in SMTPServer.cpp die variabele 'listEmails' gebruiken:

code:

listEmails = new Email[numRecips];                      
for (i = 0; i < numRecips; i++){
    listEmails[i] = new Email(strEmail, listRecips->get(i));
}

De regel "listEmails = new Email[numRecips];" levert geen problemen, maar op de rege l waar de array gevuld wordt, krijg ik de volgende compile-error:

(...)/src/SMTPServer.cpp:89: error: no match for 'operator=' in '*(this->SMTPServer::listEmails + (+(i * 28))) = (operator new(28), ((true, (<anonymous>->Email::Email(basic_string<char,std::char_traits<char>,std::allocator<char> >((&strEmail)), StringList::get(int)(i)), (<anonymous> <unknown operator> false))), <anonymous>))'
* (...)/src/Email.h:28: error: candidates are: Email& Email::operator=(const Email&)

En ik heb geen idee wat ik hiermee aanmoet. Volgens mij gebruik ik toch die array niet nelemaal goed, maar dat is slechts een vermoeden . Heeft iemand enig idee waardoor dit veroorzaakt wordt?

[Soultaker]

Ik kan me voorstellen dat die compiler error je absoluut niet helpt. Wat er mis gaat is dat je een Email* probeert toe te kennen aan een Email object en dat kan natuurlijk niet. Zo gaat het waarschijnlijk al een stuk beter:

C++:

listEmails = new Email[numRecips];
for(int i = 0; i < numRecips; ++i)
    listEmails[i] = Email(strEmail, listRecips->get(i));

Dit gaat er wel van uit dat er een operator= is gedefineerd. Als je die niet zelf hebt gedefinieerd dan is dat by default een memberwise assignment. Verder is het de moeite waard om op te merken dat alle objecten bij het alloceren van de array al geconstruct worden. De code is dus misschien niet optimaal omdat voor elk object eerst de default constructor uitgevoerd wordt, daarna wordt een temporary object geinstantieerd met de juiste gegevens en tenslotte wordt de assignment operator uitgevoerd. Dat kan voor problemen in de performance zorgen indien je default constructor of assignment operator erg kostbaar zijn (in dat geval moet je maar een array van pointers alloceren zodat je direct de juiste constructor kunt gebruiken). De kans is echter groot dat het geen probleem is.

[Verwijderd]

Hmmm... Ik wist niet dat het zo simpel zou zijn. Bedankt!
Ik neem aan dat ik nu die array van 'Email'-objecten weer moet vrijgeven door

code:

delete[] listEmails;

Dit lijkt tenminste goed te werken...

[.oisyn]

Het is wellicht handig om gewoon gebruik te maken van een std::list<Email>, dan hoef je je ook niet zo bezig te houden met memorymanagement

Soultaker schreef op 10 juni 2004 @ 14:24:
Dit gaat er wel van uit dat er een operator== is gedefineerd.

^{een = teveel}

[Verwijderd]

.oisyn schreef op 10 juni 2004 @ 14:35:
Het is wellicht handig om gewoon gebruik te maken van een std::list<Email>, dan hoef je je ook niet zo bezig te houden met memorymanagement

Of mischien in dit geval mischien eerder een std:vector<Email*> ?

Overigens hoor en zie je steeds vaker dat de primitieve arrays minder gebruikt worden in zowel C++ als Java. Tenzij je het echt nodig hebt, en weet waarom, is de eerste keuze toch vaak een collection class.

Dit is opzich wel een interesante ontwikkeling.

[MSalters]

Voor mij is een new[]/delete[] vrijwel altijd reden om te twijfelen aan het nivo van de coder. Ik ken erg weinig mensen die goede redenen hebben om geen std::vector<> te gebruiken.

PS. is de TS een Java-switcher? De array allocatie stijl suggereert het, en wat ik over C++ in de Java documentatie heb gelezen is typisch zo'n 5 tot 15 jaar verouderd. Ook de ->get(i) in plaats van [i] suggereert het. C++ heeft operator overloading, ook voor je eigen classes.

[Verwijderd]

MSalters schreef op 10 juni 2004 @ 17:19:
Voor mij is een new[]/delete[] vrijwel altijd reden om te twijfelen aan het nivo van de coder. Ik ken erg weinig mensen die goede redenen hebben om geen std::vector<> te gebruiken.

PS. is de TS een Java-switcher? De array allocatie stijl suggereert het, en wat ik over C++ in de Java documentatie heb gelezen is typisch zo'n 5 tot 15 jaar verouderd. Ook de ->get(i) in plaats van [i] suggereert het. C++ heeft operator overloading, ook voor je eigen classes.

Ten eerste staat er in m'n topicstart dat ik een paar maanden bezig ben met C++, dus echt ervaren ben ik niet. Maar dat maakt toch helemaal niet uit? Ik ben van mening dat je dit soort dingen alleen kunt leren door het gewoon te doen.
Ten tweede: ja, Java is een taal waar ik veel mee gedaan heb. Ik heb wel e.e.a. gelezen over operator-overloading, maar zo gevorderd ben ik dus nog niet...

Ik zal eens gaan kijken naar een std::list