Kurucular için, variadic-templates vs std :: initializer_list arasında nasıl seçim yapabilirim?

Question

Geçerli durumda, C++ 11 (diyelim ki gcc 4.7.2), değişken argümanları alabilecek bir kurucuya ihtiyacım olduğunda variadic-template veya std::initializer_list arasında nasıl seçim yapmalıyım?

Answer 1

Variadic bir şablon, farklı türlerde bağımsız değişkenler sağlarken, std::initializer_list argümanın türü ile templated edilir. Bu, listedeki tüm öğelerin türünün aynı olması gerektiği (veya temeldeki türe dönüştürülebilmesi, ancak daraltma dönüşümlerine izin verilmemesi) anlamına gelir. Bunun sizin için tercih edilip edilmeyeceğine bağlı olarak, birini veya diğerini seçebilirsiniz.

Ayrıca variadic şablon benzer tip kesinti initializer_list için gerçekleştirilemez yaparken, sözdizimsel formu T&& lvalue referanslar ve rvalue referanslar hem bağlanabildiği içinde, mükemmel yönlendirme gerekiyorsa genellikle varsayılan seçimdir:

struct A 
{ 
    // Deduces T& for lvalue references, T for rvalue references, and binds to both 
    template<typename... Ts> 
    A(Ts&&...) { } 

    // This is an rvalue reference to an initializer_list. The above type deduction 
    // does not apply here 
    template<typename T> 
    A(initializer_list<T>&&) { } 
}; 

Ayrıca tek tip başlatma sözdizimi (yani küme parantezleri) kullandığınızda bir initializer_list kabul eden bir yapıcı uygulanabilir, yeni bir kurucu var olsa bile, varsayılan olarak çağrılan olacağını fark.

struct A 
{ 
    A(int i) { } 
}; 

struct B 
{ 
    B(int) { } 
    B(std::initializer_list<A>) { } 
}; 

int main() 
{ 
    B b {1}; // Will invoke the constructor accepting initializer_list 
} 

Answer 2

Ben variadic şablonları seçilmesi hep tavsiye ve mümkün std::initializer_list kaçının: Bu ya sahip olmak istediklerine şey olabilir veya olmayabilir.

Bu

Birlikte std::vector hayata nasıl olurdu C++ 11:

nedeni olarak oldu parantez türüne göre farklı davranışlara yol açabilir jenerik kodunda initializer_list kullanarak, main gösterdi edilir

#include <iostream> 
#include <vector> 

struct exp_sequence { 
    template <typename... T> 
    exp_sequence(T&&...) {} 
}; 

struct from_arglist_t {} from_arglist; 

template <typename T> 
class my_vector { 
    std::vector<T> data; 

public: 
    my_vector(int n, T const& e) : data(n, e) {} 

    template <typename... Args> 
    my_vector(from_arglist_t, Args&&... args) { 
    data.reserve(sizeof...(Args)); 
    exp_sequence{(data.push_back(std::forward<Args>(args)),1)...}; 
    } 

    std::size_t size() { return data.size(); } 
}; 

int main() 
{ 
    std::vector<int> v1{13, 13}; std::cout << v1.size() << '\n'; // 2 
    std::vector<int> v2(13, 13); std::cout << v2.size() << '\n'; // 13 

    my_vector<int> v3{13, 13}; std::cout << v3.size() << '\n'; // 13 
    my_vector<int> v4(13, 13); std::cout << v4.size() << '\n'; // 13 
    my_vector<int> v5(from_arglist, 13, 13); std::cout << v5.size() << '\n'; // 2 
    my_vector<int> v6{from_arglist, 13, 13}; std::cout << v6.size() << '\n'; // 2 
} 

seçilen. Böyle bir kurucu ekleyerek kodu sessizce değiştirme olasılığı da vardır. variadic şablonla

//std::vector<move_only> m1{move_only{}}; // won't compile 
my_vector<move_only> m2{from_arglist, move_only{}}; // works fine 

Answer 3

, argüman sayısı (sizeof... yoluyla ve erişilebilir) derleme sırasında bilinmektedir:

başka neden

hareket okunur türleridir. std::initializer_list ile argüman sayısı sadece çalışma zamanında bilinir. Bu yüzden kararın bir kısmı, kaç argümanınızın bulunduğunu bilmek veya bilmek istediğiniz zamana bağlıdır.