Apakah pass-by-value merupakan default yang wajar di C ++ 11?

Dalam C ++ tradisional, meneruskan nilai ke fungsi dan metode lambat untuk objek besar, dan umumnya disukai. Alih-alih, programmer C ++ cenderung meneruskan referensi, yang lebih cepat, tetapi yang memperkenalkan segala macam pertanyaan rumit seputar kepemilikan dan terutama seputar manajemen memori (jika objek dialokasikan dialokasikan)

Sekarang, di C ++ 11, kami memiliki referensi nilai dan memindahkan konstruktor, yang berarti bahwa mungkin untuk mengimplementasikan objek besar (seperti std::vector) yang murah untuk melewati nilai ke dalam dan keluar dari suatu fungsi.

Jadi, apakah ini berarti bahwa standarnya harus lewat nilai untuk contoh jenis seperti std::vectordan std::string? Bagaimana dengan objek kustom? Apa praktik terbaik yang baru?

Ini adalah standar yang masuk akal jika Anda perlu membuat salinan di dalam tubuh. Ini adalah apa Dave Abrahams menganjurkan :

Pedoman: Jangan menyalin argumen fungsi Anda. Sebagai gantinya, berikan nilai dan biarkan kompiler melakukan penyalinan.

Dalam kode ini berarti jangan lakukan ini:

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

tetapi lakukan ini:

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

yang memiliki keuntungan yang bisa digunakan oleh penelepon fooseperti:

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

dan hanya sedikit pekerjaan yang dilakukan. Anda perlu dua kelebihan untuk melakukan hal yang sama dengan referensi, void foo(T const&);dan void foo(T&&);.

Dengan mengingat hal itu, saya sekarang menulis konstruktor berharga saya seperti:

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

Kalau tidak, melewati referensi constmasih masuk akal.

Dalam hampir semua kasus, semantik Anda harus berupa:

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

Semua tanda tangan lainnya harus digunakan hanya dengan hemat, dan dengan justifikasi yang baik. Kompiler sekarang akan selalu bekerja dengan cara yang paling efisien. Anda bisa terus menulis kode Anda!

Lewati parameter dengan nilai jika di dalam fungsi tubuh Anda memerlukan salinan objek atau hanya perlu memindahkan objek. Lewati const&jika Anda hanya perlu akses non-mutasi ke objek.

Contoh copy objek:

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();
}

Contoh pemindahan objek:

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)); 
}

Contoh akses non-mutasi:

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

Untuk alasannya, lihat posting blog ini oleh Dave Abrahams dan Xiang Fan .

Tanda tangan suatu fungsi harus mencerminkan penggunaan yang dimaksudkan. Keterbacaan penting, juga untuk pengoptimal.

Ini adalah prasyarat terbaik bagi pengoptimal untuk membuat kode tercepat - setidaknya dalam teori dan jika tidak dalam kenyataan maka dalam beberapa tahun kenyataan.

Pertimbangan kinerja seringkali dinilai berlebihan dalam konteks parameter yang lewat. Penerusan yang sempurna adalah contohnya. Fungsi seperti emplace_backkebanyakan sangat pendek dan inline.