Bonjour,

Je suis entrain de faire le cours de zeste de savoir,j'en suis au TP de la matrice et j'essaie de surcharger l'opérateur += ainsi que d'autre et j'aimerais savoir si se que je fait est juste ou pas(si écrire sa,sa se fait) , pour éviter de recopier du code en plus ,étant donner que j'ai déjà surchargée l'opérateur +.

Matrice Matrice::operator+=(Matrice a)
{
	return *this = *this + a;
}

Merci de votre lecture/de vos réponse  (désolé si il y a des fautes d'orthographe).

-
Edité par toto771 13 avril 2021 à 1:29:28

En général on fait l'inverse, on réutilise l'opérateur += dans l'opérateur +.

L'opérateur += doit toujours retourner une référence.

De plus il prend une référence constante en argument (tout comme l'opérateur + qui prend deux références constantes).

+1, mais pas forcément pour la parenthèse. L'élision de copie peut s'avérer intéressante dans une première approximation. (et dans le cas de choses comme des matrices, on va en fait utiliser d'autres optimisations encore dans des vraies bibliothèques de calcul numérique)

Merci pour vos réponse,effectivement j'ai oublié de faire des passage par référence
Mais sinon l’emploie du *This nécessite certaine condition ou on peut l'employé "quand on veux" ?

et si on s'aide de la surcharge d'un += pour faire + sa veut dire on doit faire une copie de l'objet pour pas modifié celui ci ?

-
Edité par toto771 13 avril 2021 à 20:17:01

*this s'utilise dans une méthode de classe / structure :

class Foo {
    // attributs
public:
    void bar();
    // autres méthodes
};

void Foo::bar() {
    // on peut utiliser this
    // car on est dans la classe Foo
    // voir la signature => Foo::
}

void bar2() {
    // *this est inutilisable, car on n'est pas dans une structure / classe, donc le pointeur this ne renvoie vers rien
}

Du coup ça veut dire que tu fais comme ça :

class Addable {
// code
friend Addable& operator+=(Addable& first, const Addable& second);
};

Addable& operator+=(Addable& first, const Addable& second) {
    // algorithme, genre first.attribute_ += second.attribute_
    return first;
}

Addable operator+(Addable first, const Addable& second) {
    first += second;
    return first;
}

// ou aussi peut-être

Addable operator+(Addable&& first, const Addable& second) {
    first += second;
    return first;
}

donc du-coup sa nécessite de faire au moins une copie (passage par copie)

pour le this,je voulais dire y a pas de contrainte pour l'utiliser dans la classe/structure ?

Merci pour ta réponse

Je n'utilise this que quand je n'ai pas le choix (cas des templates avec héritage au milieu), ou quand j'ai explicitement besoin d'accéder à l'objet courant, genre pour le passer en paramètre à une autre fonction.

`this->`, en ce qui me concerne, c'est trop de trucs inutiles à taper qui n'apportent rien.

Pour la classe addable, la meilleure pratique sera plutôt:

class addable
{
...
public:
    addable& operator+=(addable const& rhs); // noexcept si je peux
    // et je me demande même s'il ne faudrait pas en fait que cela soit:
    addable& operator+=(addable const& rhs) &; // ?
    // mais je n'ai pas encore réfléchi à la question.

    friend /* il y a un friend ici!!! */ addable operator+(addable rhs, addable const& lhs) // noexcept si possible
    { // code ici => hidden friend
        lhs += rhs;
        return rhs;
    }
};

// et définition séparée de op+= si ça nous fait plaisir.

// Une définition séparée de op+ pourquoi pas, mais seulement si la classe n'est pas template
// Car avec une classe template, l'ami ne pourrait plus être caché vu que la définition devra être inclue partout

EDIT: Si on commence à jouer avec &&, il faut les 4 surcharges pour que cela commence à devenir intéressant, et parfois faire des moves explicites car les références bloquent l'élision de copie (à moins que cela ait changé depuis mes tests en C++11: https://github.com/LucHermitte/LucHermitte.github.io/blob/source/assets/ )

EDIT2:

> donc du-coup sa nécessite de faire au moins une copie (passage par copie)

Cela ne veut pas forcément dire qu'il y a une copie. Avec `addable a{42}; auto b = addable{12} + a;`, il n'y a pas de copie, mais une élision de copie: le compilo voit que copier un temporaire serait idiot, donc sur un passage par valeur, s'il le peut, il ne copie pas les temporaires (ou plus exactement les rvalues...)

-
Edité par lmghs 13 avril 2021 à 21:41:11

toto771 a écrit:

pour le this,je voulais dire y a pas de contrainte pour l'utiliser dans la classe/structure ?

En général, on l'utilise pour lever les ambiguïtés, ou se referer à l'instance courrante.
Evite de l'employer à tort et à travers, ca nuit à la lisibilité.

Donc dans le code que j'ai montré au tout début je l'ai bien employé ?

c'est juste que je me suis aidé du + pour faire le +=

Ce n'est pas efficace. Tout l'intérêt du += c'est d'éviter des opérations. Si cela déclenche une création d'objet temporaire pour lui stocker un résultat (d'addition) pour ensuite renvoyer ce temporaire pour l'affecter à un objet qui se trouvait être l'ancienne opérande gauche de l'addition, c'est beaucoup de manipulations.

De plus,

- tu dupliques potentiellement l'opérande droit de ton opération += alors que rien ne le justifie.

- tu ne renvoies pas l'objet courant mais un copie de celui-ci -- et une duplication de matrice peut couter cher.

Bref, pour l'addition l'approche idiomatique version débutants (dans le cas des matrices) est celle de mon code.

Toute fois, il ne serait pas possible d'écrire directement *= pour des matrices. Si on voulait le proposer, il faudrait l'implémenter à partir de * -- mais ... parfois il vaut mieux éviter d'offrir des sucres syntaxiques qui peuvent inciter à des mauvaises/maladroites utilisations de nos bibliothèques: et donc seule *, et non *=, devrait être définie pour des matrices.

D’accord, après c'est juste qu'a part dans le TP de zeste de savoir je n'ai jamais entendu parlé des matrice, donc je ne sais pas forcément se que l'on peut faire avec

Merci pour vos réponse !

C'est des maths post-BAC qui servent à pas mal de choses: faire des rotations en 3D (le truc le plus connu chez les développeurs), participer à la propagation des états d'activations entre couches dans des réseaux de neurones artificiels (dans les autres trucs à la mode ces dernières années), mais bien d'autres choses également. Si tu as déjà croisé des déterminants en maths, tu as alors d'une certaine façon déjà manipulé des matrices 2x2, sans qu'on ne te le formalises.

Pour l'instant retient juste que c'est un gros tableau 2D qui supporte diverses opérations.