Vaut-il mieux passer par valeur pour les types mobiles au lieu de surcharger les fonctions?

La recommandation générale est la première manière. La seconde manière oblige à faire une allocation, alors que ce n'est pas toujours nécessaire. Pour un exemple:

value
allocate: 5
allocate: 5
allocate: 3
allocate: 3
allocate: 3
reference
allocate: 5

Ceci produit la sortie:

#include <vector>
#include <iostream>

bool my_log = false;

struct my_alloc : std::allocator<int> {
    int* allocate(std::size_t n) {
        if (my_log) std::cout << "allocate: " << n << '\n';
        return std::allocator<int>::allocate(n);
    }

    template<typename U>
    struct rebind {
        using other = my_alloc;
    };
};

using test_vec = std::vector<int, my_alloc>;
struct foo {
    test_vec v_;
    void set_value(test_vec v) { v_ = v; }
    void set_ref(const test_vec& v) { v_ = v; }
    void set_ref(test_vec&& v) { v_ = v; }
};

int main() {
    test_vec long_vec = { 0,1,2,3,4 };
    test_vec short_vec = { 0,1,2 };
    foo f;
    foo g;
    my_log = true;
    std::cout << "value\n";
    f.set_value(long_vec);
    f.set_value(short_vec);
    f.set_value(short_vec);
    f.set_value(short_vec);

    std::cout << "reference\n";
    g.set_ref(long_vec);
    g.set_ref(short_vec);
    g.set_ref(short_vec);
    g.set_ref(short_vec);
}

Comme vous pouvez le voir, dans certaines circonstances, passer par valeur nécessite un supplément allocation à chaque fois, ce qui peut être évité si vous passez simplement par référence.

En bref, vous devez écrire une fonction set (const X &) et une set (X &&) version à chaque fois. Il n'y a aucun moyen de le raccourcir.

Dans un second temps, je créerai toujours une copie car je passe par valeur

Non. L'argument peut être move construit à partir d'une xvalue ou initialisé directement à partir d'une prvalue (ce dernier uniquement depuis C ++ 17; avant cela, le déplacement peut être élidé comme une optimisation). Donc, même en créant un objet distinct (en ce qui concerne la machine abstraite), il n'y a pas nécessairement de copie.

Dans le cas d'une lvalue, l'argument sera copié; tout comme il sera copié dans l'option 1, auquel cas il appellera la surcharge de référence lvalue.

Laquelle des deux méthodes est recommandée?

Je recommande l'option 2 (passer par valeur) par défaut. Cela réduit de moitié la quantité de code standard, et la différence de performances entre une copie unique + un mouvement unique et une copie unique est généralement insignifiante.

Une exception à cela concerne les objets qui sont lents à se déplacer, comme un std :: array avec de nombreux éléments. Je recommande l'option 1 (surcharges de référence) si vous avez mesuré un goulot d'étranglement causé par l'option 2 et constaté que 1 est plus rapide.

La première version est généralement légèrement plus rapide mais elle introduit la duplication de code. La deuxième méthode est recommandée pour les objets peu coûteux à déplacer. Étant donné que la plupart des objets sont peu coûteux à déplacer en C ++, la deuxième méthode convient généralement. Mais, il y a une autre alternative:

template<typename T>
void SetParams(T&& params) { mParams = std::forward<T>(params); }

template<typename T>
void SetBoardInfo(T&& board_info) { mBoardInfo = std::forward<T>(board_info); }

Merci à références universelles , c'est le meilleur des deux mondes s'il est acceptable d'avoir des setters modélisés.

L'optimisation prématurée est la racine de tout mal.

Je veux réduire la copie au minimum, en particulier pour les types / classes coûteux.

Ne le faites pas. À moins que ces fonctions ne soient appelées des millions ou des milliards de fois, ou que votre carte de paramètres contienne des millions d'éléments, il est peu probable que cela prenne beaucoup de temps. À première vue, vous optimisez prématurément .

Si l'un de ces deux cas tient - ce dont je doute fort - vous perdez beaucoup plus de temps, et peut-être space, en utilisant un std :: map - car il est extrêmement inefficace . Et une carte de chaînes allouées individuellement par tas, rien de moins!

Alors, allez-y simplement avec:

void SetParams(std::map<int, std::string> params) : mParams(parameters) { }

et laissez le compilateur s'en occuper .

PS - Vous devez toujours mesurer avant de vous lancer dans un effort d'optimisation, et en particulier avant de préférer les avantages supposés en termes de performances à la simplicité, à la lisibilité, DRY (ne vous répétez pas) et ainsi de suite.