question concernant « ce » pointeur dans C++

Question

je suis classe donnée avec des variables int x et y en privé, et une fonction de surcharge de l'opérateur,

class Bag{ 
private: 
    int x; 
    int y; 
public: 
    Bag(); 
    ~Bag(); 
    //....... 
    //.....etc 
}; 


Bag operator+ (Bag new) const{ 
    Bag result(*this); //what does this mean? 
    result.x += new.x;   
    result.y += new.y; 
} 

Quel est l'effet d'avoir « résultat Sac (* ce) " Là?.

Answer 1

Bag result(*this) crée une copie de l'objet sur lequel la fonction opérateur a été appelée.

Exemple s'il y avait:

sum = op1 + op2; 

alors result sera une copie de op1. Puisque la fonction operator+ fait une somme de ses opérandes et retourne la somme, nous avons besoin d'un moyen d'accéder à l'opérande op1 qui est fait par le pointeur this.

Sinon, nous aurions pu faire:

Bag result; 
result.x = (*this).x + newobj.x; // note you are using new which is a keyword. 
result.y = (*this).y + newobj.y; // can also do this->y instead 
return result; 

Answer 2

La fonction operator+ retourne une copie. La déclaration:

Bag result(*this); 

fait une copie de cet objet pour revenir à l'appelant. Selon la signature, il doit retourner une valeur, donc il fait une copie et ensuite ajouter l'objet new.

Answer 3

Tout d'abord, dites à l'éditeur de code de ne pas utiliser new comme nom de variable - c'est un mot-clé. Aussi, rappelez-vous au return result;. Et soit passer par const-référence ou directement modifier le sac new.

---

l'intérieur d'une struct/classe, this est un pointeur sur lui-même. Par conséquent, *this est une référence à toute l'instance de Bag elle-même.

La déclaration Bag result(a_bag_reference) appellera le constructeur de copie de Bag, ce qui en fait une copie de a_bag_reference en result.

Par conséquent,

Bag result(*this); 

fait une copie de lui-même, puis stocker dans result. Cela rend les 2 prochaines déclarations

result.x += new.x; 
result.y += new.y; 

n'affectent pas l'instance elle-même (à savoir this->x et this->y sont maintenues constantes).

Answer 4

Votre code ressemblerait à ceci:

class Bag { 
public: 
    Bag(); 
    Bag(Bag const& other); // copy ctor, declared implicitly if you don't declare it 
    ~Bag(); 

    Bag operator+(Bag const& other) const; 

private: 
    int x; 
    int y; 
}; 

Bag Bag::operator+(Bag const& other) const { 
    Bag result (*this); 
    result.x += other.x;   
    result.y += other.y; 
    return result; 
} 

L'implicite « objet courant » pour les fonctions de membre est pointée par une valeur spéciale nommée ce.Puis obtient cet objet (en déréférencant ce), et il est utilisé pour construire (via le constructeur de copie) un autre sac nommé résultat.

Je soupçonne que ce code est tiré d'un devoir à la maison, alors vous pourriez ne pas être en mesure d'utiliser le modèle one true addition operator, mais il est courant et vous devriez être au courant:

struct Bag { 
    //... 
    Bag& operator+=(Bag const& other) { 
    x += other.x; 
    y += other.y; 
    return *this; // return a reference to the "current object" 
    // as almost all operator=, operator+=, etc. should do 
    } 
}; 

Bag operator+(Bag a, Bag const& b) { 
    // notice a is passed by value, so it's a copy 
    a += b; 
    return a; 
} 

Answer 5

Bag result(*this); est la déclaration d'une variable result et en appelant son constructeur de copie .

Vous pouvez imaginer que C++ déclare automatiquement un constructeur de copie par défaut pour toutes les classes. Son travail est tout simplement d'initialiser un objet en utilisant un autre objet:

Bag::Bag(Bag const& src) { 
    x = src.x; 
    y = src.y; 
}

L'expression *this peut sembler un peu dérangeant, mais est juste l'horreur habituelle de C++ lorsque vous traitez avec & paramètres.