Le pass-by-value est-il un défaut raisonnable en C++11 ?

Question

Dans le C++ traditionnel, le passage par valeur dans les fonctions et les méthodes est lent pour les gros objets, et est généralement mal vu. Au lieu de cela, les programmeurs C++ ont tendance à passer des références, ce qui est plus rapide, mais introduit toutes sortes de questions compliquées concernant la propriété et surtout la gestion de la mémoire (dans le cas où l'objet est alloué au tas).

Maintenant, en C++11, nous avons des références Rvalue et des constructeurs mobiles, ce qui signifie qu'il est possible d'implémenter un objet de grande taille (comme un std::vector ) qui est bon marché pour passer par valeur dans et hors d'une fonction.

Cela signifie-t-il que la valeur par défaut devrait être le passage par valeur pour les instances des types tels que std::vector et std::string ? Qu'en est-il des objets personnalisés ? Quelle est la nouvelle meilleure pratique ?

Answer 1

C'est un défaut raisonnable si vous devez faire une copie à l'intérieur du corps. C'est ce que Dave Abrahams préconise :

Ligne directrice : Ne copiez pas les arguments de vos fonctions. Passez-les plutôt par valeur et laissez le compilateur se charger de la copie.

En code, cela signifie "ne faites pas ça" :

void foo(T const& t)
{
    auto copy = t;
    // ...
}

mais faites ça :

void foo(T t)
{
    // ...
}

qui a l'avantage de permettre à l'appelant d'utiliser foo comme ça :

T lval;
foo(lval); // copy from lvalue
foo(T {}); // (potential) move from prvalue
foo(std::move(lval)); // (potential) move from xvalue

et seul un travail minimal est effectué. Il faudrait deux surcharges pour faire la même chose avec les références, void foo(T const&); et void foo(T&&); .

Avec cela en tête, j'ai maintenant écrit mes constructeurs de valeur comme tel :

class T {
    U u;
    V v;
public:
    T(U u, V v)
        : u(std::move(u))
        , v(std::move(v))
    {}
};

Sinon, le passage par référence à const est encore raisonnable.

Answer 2

Dans presque tous les cas, votre sémantique devrait être soit :

bar(foo f); // want to obtain a copy of f
bar(const foo& f); // want to read f
bar(foo& f); // want to modify f

Toutes les autres signatures ne doivent être utilisées qu'avec parcimonie, et avec une bonne justification. Le compilateur va maintenant presque toujours les résoudre de la manière la plus efficace. Vous pouvez simplement continuer à écrire votre code !

Answer 3

Passez les paramètres par valeur si, dans le corps de la fonction, vous avez besoin d'une copie de l'objet ou si vous avez seulement besoin de déplacer l'objet. Passer par const& si vous avez seulement besoin d'un accès non-mutant à l'objet.

Exemple de copie d'objet :

void copy_antipattern(T const& t) { // (Don't do this.)
    auto copy = t;
    t.some_mutating_function();
}

void copy_pattern(T t) { // (Do this instead.)
    t.some_mutating_function();
}

Exemple de déplacement d'objet :

std::vector<T> v; 

void move_antipattern(T const& t) {
    v.push_back(t); 
}

void move_pattern(T t) {
    v.push_back(std::move(t)); 
}

Exemple d'accès non mutant :

void read_pattern(T const& t) {
    t.some_const_function();
}

Pour en savoir plus, consultez les articles de blog suivants Dave Abrahams et Xiang Fan .

Answer 4

Quand passe-t-on les arguments par référence ou par pointeur ?

1) Pour modifier les variables locales de la fonction appelante :

Une référence (ou un pointeur) permet à la fonction appelée de modifier une variable locale de la fonction appelante. Par exemple, considérons l'exemple de programme suivant où fun() est capable de modifier la variable locale x de main().

void fun(int &x) {
    x = 20;
}

int main() {
    int x = 10;
    fun(x);
    cout<<"New value of x is "<<x;
    return 0;
}

Sortie : La nouvelle valeur de x est 20

---

2) Pour faire passer des arguments de grande taille :

Si un argument est grand, le passage par référence (ou pointeur) est plus efficace car seule une adresse est réellement passée, et non l'objet entier. Par exemple, considérons la classe Employé suivante et une fonction printEmpDetails() qui imprime les détails de l'employé.

class Employee {
private:
    string name;
    string desig;

    // More attributes and operations
};

void printEmpDetails(Employee emp) {
     cout<<emp.getName();
     cout<<emp.getDesig();

    // Print more attributes
}

Le problème avec le code ci-dessus est le suivant : chaque fois que printEmpDetails() est appelé, un nouvel objet Employee est construit, ce qui implique la création d'une copie de tous les membres de données. Une meilleure implémentation serait donc de passer Employee comme une référence.

void printEmpDetails(const Employee &emp) {
     cout<<emp.getName();
     cout<<emp.getDesig();

    // Print more attributes 
}

Ce point n'est valable que pour les variables de type struct et class, car nous n'obtenons aucun avantage en termes d'efficacité pour les types de base comme int, char, etc.

---

3) Pour éviter le découpage des objets :

Si nous passons un objet de sous-classe à une fonction qui attend un objet de super-classe alors l'objet passé est tranché s'il est passé par valeur. Par exemple, considérons le programme suivant, il imprime "This is Pet Class".

#include <iostream>
#include<string>

using namespace std;

class Pet {
public:
    virtual string getDescription() const {
        return "This is Pet class";
    }
};

class Dog : public Pet {
public:
    virtual string getDescription() const {
        return "This is Dog class";
    }
};

void describe(Pet p) { // Slices the derived class object
    cout<<p.getDescription()<<endl;
}

int main() {
    Dog d;
    describe(d);
    return 0;
}

Sortie : Voici la Classe des animaux

Si nous utilisons le passage par référence dans le programme ci-dessus, il imprime correctement "This is Dog Class". Voir le programme modifié suivant.

#include <iostream>
#include<string>

using namespace std;

class Pet {
public:
    virtual string getDescription() const {
        return "This is Pet class";
    }
};

class Dog : public Pet {
public:
    virtual string getDescription() const {
        return "This is Dog class";
    }
};

void describe(const Pet &p) { // Doesn't slice the derived class object.
    cout<<p.getDescription()<<endl;
}

int main() {
    Dog d;
    describe(d);
    return 0;
}

Sortie : Voici la classe de chien

Ce point n'est pas non plus valable pour les types de données de base comme int, char, etc.

---

4) Pour réaliser le Polymorphisme à l'exécution dans une fonction

Nous pouvons rendre une fonction polymorphe en lui passant des objets comme référence (ou pointeur). Par exemple, dans le programme suivant, print() reçoit une référence à l'objet de classe de base. print() appelle la fonction de classe de base show() si l'objet de classe de base est passé, et la fonction de classe dérivée show() si l'objet de classe dérivée est passé.

#include<iostream>
using namespace std;

class base {
public:
    virtual void show() {  // Note the virtual keyword here
        cout<<"In base \n";
    }
};

class derived: public base {
public:
    void show() {
        cout<<"In derived \n";
    }
};

// Since we pass b as reference, we achieve run time polymorphism here.
void print(base &b) {
    b.show();
}

int main(void) {
    base b;
    derived d;
    print(b);
    print(d);
    return 0;
}

Sortie : En base
En dérivé

Answer 5

Un exemple tiré de l'expérience personnelle. Un thread possède un objet chaîne de caractères. Il est passé à une fonction qui génère un autre thread, mais à l'insu de l'appelant, la fonction a pris la chaîne en tant que const. l'appelant, la fonction a pris la chaîne en tant que const std::string& et non en tant que une copie. Le premier thread est alors sorti...

pour cela, il existe une fonction d'encapsulage

void original(const std::string & str);

void wrapper(std::string * str) // takes ownership
{
   original(*str);
   delete str;
}

vois thread_mother(...)
{
   //...
   spawn_me_thread(wrapper, new std::string("this string should be used by the thread and i don't care about it anymore"));
   //...
}