Tri de tableau d'objets...

Bonjour J’ai un petit souci en Visual C++6… Je détiens, après traitement, deux indices (i et j) d’un même tableau d’objet : m_oaBras[]. Je dois permuter ces deux objets. Si je déclare x comme étant un objet (comme ceux dans le tableau) et si j’écris : x=m_oaBras[j];m_oaBras[j]=m_oaBras[i];m_oaBras[i]=x , bien évidement cela ne fonctionne pas. Normal ! Es-ce que quelqu’un peux me dire comment procéder ? Merci d’avance

Redéfinie l'opérateur = dans ta classe:

class A
{
...
A & operator = (const A & _which)
{
    this->donne1 = _which.donne1;
    this->donne2 = _which.donne2;

    // tu fais ca pour toute ta classe, tu copies les membres de _which dans *this;
}
}

oups pardon, n'oublies pas:

return *this;

à la fin de la fonction.

Il faut aussi faire attention à l'auto-affectation (dans ce cas, il n'y a rien a faire) A & operator = (const A & _which) { if(this != &_which) { this->donne1 = _which.donne1; this->donne2 = _which.donne2; } return *this }

C'est la première fois que je vois ca. L'auto affectation n'est en général pas un problème. Mais j'ai du le rencontrer une fois.
Dans les include du C++, ils font pas ce test. (il me s emble)

Un autre problème important est celui de l'autoaffectation. Non seulement affecter un objet à lui-même est inutile et consommateur de ressources, mais en plus cela peut être dangereux. En effet, l'affectation risque de détruire les données membres de l'objet avant même qu'elles ne soient copiées, ce qui provoquerait en fin de compte simplement la destruction de l'objet ! http://casteyde.christian.free.fr/cpp/cours/online/x3244.html

Ca "consommateur de ressources", c'est pas valable comme argument, deja car copier un objet sur lui meme, ca doit pas etre fréquent, alors que effectuer le test de comparaison a chaque fois que le constructeur de copie est appelé, ca c'est une perte de tps inutile. Par contre, pour ce qu'il dit ensuite, je comprend pas pourquoi il détruirait l'objet membre avant de copier la valeur.
Quand tu fais
int x = 2;
x = 4; <= ici x ne va pas est détruit. Donc pourquoi, ce serait le cas pour les membres de la classe ?

Et si le test était vraiment vitale, il serait dans les includes du C++. Enfin je comprend pas bien.

La comparaison est une comparaison d'adresse, c'est donc très vite fait, et ca vaut largement le coup de la faire. A mon avis c'est une optimisation intéressante. Voici ce que j'ai trouvé dans le template list de VC++: _Myt& operator=(const _Myt& _Right) { // assign _Right if (this != &_Right) assign(_Right.begin(), _Right.end()); return (*this); } C'est exactement ca. Je ne comprends pas non plus l'autre argument

Voici un exemple donné par l'auteur, qui justifie qu'on doit vérifier l'auto-affectation class A { char *m_szData; public: A &operator=(const A &source) { // Libération de m_szData : delete[] m_szData; // Copie : m_szData = new char[strlen(source.m_szData) + 1]; strcpy(m_szData, source.m_szData); return *this; } ... }; A a("hello"); a = a; // Plantage. En effet, a= a exécute, sans protection : delete m_szData; m_szData = new char[strlen(m_szData) + 1]; // m_szData n'est plus valide et peut valoir n'importe quoi. Du coup strlen peut planter, ou la copie qui suivra, etc.

Oui ok, mais la c'est quand meme gros la plante potentielle :)