Geçiş değeri C ++ 11 için makul bir varsayılan mı?

Geleneksel C ++ 'da, değere göre işlevlere ve yöntemlere geçmek büyük nesneler için yavaştır ve genellikle kaşlarını çatır. Bunun yerine, C ++ programcıları referansları aktarma eğilimindedir, bu da daha hızlıdır, ancak sahiplik ve özellikle bellek yönetimi hakkında her türlü karmaşık soruyu ortaya çıkarır (nesnenin yığın halinde ayrılması durumunda)

Şimdi, C ++ 11'de Rvalue referanslarımız ve hareket yapıcılarımız var, bu std::vectorda bir fonksiyonun değerine ve fonksiyonunun dışına geçmek için ucuz olan büyük bir nesneyi (an gibi ) uygulamak anlamına geliyor .

Öyleyse, bu, varsayılan gibi std::vectorve gibi tür örnekleri için değere göre geçilmesi gerektiği anlamına std::stringmı geliyor? Özel nesneler ne olacak? Yeni en iyi uygulama nedir?

Makul bir varsayılan var ise sen vücudun içinde bir kopyasını yapmak gerekir. Dave Abrahams'ın savunduğu şey bu :

Yönerge: İşlev argümanlarınızı kopyalamayın. Bunun yerine, bunları değere göre iletin ve derleyicinin kopyalamayı yapmasına izin verin.

Kodda bu, bunu yapma anlamına gelir:

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

ama bunu yapın:

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

arayanın şu şekilde kullanabileceği bir avantaja sahiptir foo:

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

ve çok az iş yapılır. Aynı işlemleri referanslarla yapmak için iki aşırı yüklemeye ihtiyacınız vardır void foo(T const&);ve void foo(T&&);.

Bunu göz önünde bulundurarak, şimdi değerli kurucularımı şöyle yazdım:

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

Aksi takdirde, consthala referans olarak geçilmesi makuldür.

Neredeyse tüm durumlarda, anlambiliminiz şunlardan biri olmalıdır:

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

Diğer tüm imzalar sadece az miktarda ve iyi bir gerekçe ile kullanılmalıdır. Derleyici şimdi hemen hemen her zaman en verimli şekilde çalışacaktır. Sadece kodunuzu yazarak devam edebilirsiniz!

İşlev gövdesi içinde nesnenin bir kopyasına veya yalnızca nesneyi taşımanız gerekiyorsa parametreleri değere göre geçirin. Tarafından geçmek const&yalnızca nesneye olmayan mutasyona erişmeniz gerekiyorsa.

Nesne kopyalama örneği:

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

Nesne taşıma örneği:

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

Değişmeyen erişim örneği:

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

Gerekçe için Dave Abrahams ve Xiang Fan'ın bu blog gönderilerine bakın .

Bir işlevin imzası, amaçlanan kullanımını yansıtmalıdır. Okunabilirlik, optimize edici için de önemlidir.

Bu, bir optimizasyoncunun en azından en azından en azından gerçekte olmasa da teoride en hızlı kodu yaratması için en iyi önkoşuldur.

Performans değerlendirmeleri genellikle parametre geçirme bağlamında abartılır. Mükemmel yönlendirme buna bir örnektir. Gibi fonksiyonlar emplace_backçoğunlukla çok kısa ve eğiktir.