Ayraçlı başlatıcı ne zaman kullanılır?

C ++ 11'de, sınıfları başlatmak için, değişkenleri nasıl başlatacağımız konusunda bize çok sayıda olasılık veren yeni sözdizimimiz var.

{ // Example 1
  int b(1);
  int a{1};
  int c = 1;
  int d = {1};
}
{ // Example 2
  std::complex<double> b(3,4);
  std::complex<double> a{3,4};
  std::complex<double> c = {3,4};
  auto d = std::complex<double>(3,4);
  auto e = std::complex<double>{3,4};
}
{ // Example 3
  std::string a(3,'x');
  std::string b{3,'x'}; // oops
}
{ // Example 4
  std::function<int(int,int)> a(std::plus<int>());
  std::function<int(int,int)> b{std::plus<int>()};
}
{ // Example 5
  std::unique_ptr<int> a(new int(5));
  std::unique_ptr<int> b{new int(5)};
}
{ // Example 6
  std::locale::global(std::locale("")); // copied from 22.4.8.3
  std::locale::global(std::locale{""});
}
{ // Example 7
  std::default_random_engine a {}; // Stroustrup's FAQ
  std::default_random_engine b;
}
{ // Example 8
  duration<long> a = 5; // Stroustrup's FAQ too
  duration<long> b(5);
  duration<long> c {5};
}

Açıkladığım her değişken için, hangi ilkleme sözdizimini kullanmam gerektiğini düşünmem gerekiyor ve bu benim kodlama hızımı yavaşlatıyor. Küme parantezlerini tanıtmak niyetinin bu olmadığına eminim.

Şablon kodu söz konusu olduğunda, sözdizimini değiştirmek farklı anlamlara yol açabilir, bu nedenle doğru yoldan gitmek çok önemlidir.

Birinin seçmesi gereken sözdizimi evrensel bir kılavuz olup olmadığını merak ediyorum.

Ben düşünüyorum şu iyi kılavuz olabilir:

• Başlattığınız (tek) değerin nesnenin tam değeri olması amaçlanıyorsa , copy ( =) başlatmayı kullanın (çünkü bu durumda hata durumunda, genellikle sağlanan değeri yorumlayan açık bir kurucuyu asla yanlışlıkla çağırmazsınız. farklı). Kopya başlatmanın mümkün olmadığı yerlerde, küme ayracı başlatmanın doğru anlamlara sahip olup olmadığına bakın ve eğer öyleyse, bunu kullanın; aksi takdirde parantez başlatma kullanın (eğer bu da yoksa, yine de şansınız kalmaz).

• Başlattığınız değerler nesnede saklanacak değerlerin bir listesiyse ( bir vektör / dizinin öğeleri veya karmaşık bir sayının gerçek / sanal kısmı gibi), varsa küme parantezlerini kullanın.

• Başlattığınız değerler depolanacak değerler değilse , ancak nesnenin amaçlanan değerini / durumunu açıklıyorsa , parantez kullanın. Örnekler, a'nın boyut bağımsız değişkeni vectorveya bir fstream.

Asla evrensel bir kılavuz olmayacağından oldukça eminim. Benim yaklaşımım, bunu hatırlayarak her zaman küme parantezi kullanmaktır.

1. Başlatıcı listesi oluşturucuları diğer oluşturuculara göre önceliklidir
2. Tüm standart kitaplık kapsayıcıları ve std :: basic_string, başlatıcı liste yapıcılarına sahiptir.
3. Küme ayracı başlatma, daraltılmış dönüşümlere izin vermez.

Bu yüzden yuvarlak ve küme parantezleri birbirinin yerine kullanılamaz. Ancak nerede farklı olduklarını bilmek çoğu durumda kıvrımlı parantez başlangıcını kullanmama izin veriyor (şu anda yapamadığım bazı durumlarda derleyici hataları)

Genel kod (ör. Şablonlar) dışında, her yerde parantez kullanabilirsiniz (ve ben de kullanıyorum) . Bir avantajı, örneğin sınıf içi başlatma için bile her yerde çalışmasıdır:

struct foo {
    // Ok
    std::string a = { "foo" };

    // Also ok
    std::string b { "bar" };

    // Not possible
    std::string c("qux");

    // For completeness this is possible
    std::string d = "baz";
};

veya işlev bağımsız değişkenleri için:

void foo(std::pair<int, double*>);
foo({ 42, nullptr });
// Not possible with parentheses without spelling out the type:
foo(std::pair<int, double*>(42, nullptr));

T t = { init };Veya T t { init };stilleri arasında fazla dikkat etmediğim değişkenler için, farkı küçük buluyorum ve en kötü ihtimalle yalnızca bir kurucunun kötüye kullanılması hakkında yararlı bir derleyici mesajı ile sonuçlanacaktır explicit.

Kabul eden türler için, std::initializer_listaçıkça bazen std::initializer_listyapıcı olmayanlara ihtiyaç duyulur (klasik örnek std::vector<int> twenty_answers(20, 42);). O zaman diş teli kullanmamak sorun değil.

Genel kod söz konusu olduğunda (ör. Şablonlarda) son paragraf bazı uyarılara neden olmalıydı. Aşağıdakileri göz önünde bulundur:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{ return std::unique_ptr<T> { new T { std::forward<Args>(args)... } }; }

Sonra auto p = make_unique<std::vector<T>>(20, T {});eğer büyüklüğü 2'nin bir vektör oluşturur Törn olduğunu intveya olmadığını büyüklüğü 20 bir vektör Tolduğunu std::string. Burada çok ters giden bir şeyler olduğuna dair çok açık bir işaret, sizi burada kurtarabilecek hiçbir özellik olmadığıdır (örneğin SFINAE ile): std::is_constructibledoğrudan başlatma anlamındadır, oysa biz yönlendirmeyi erteleyen küme ayracı başlatmayı kullanıyoruz. başlatma, ancak ve ancak kurucu std::initializer_listmüdahale eden yoksa . Benzer şekilde std::is_convertiblehiçbir faydası yok.

Bunu düzeltebilecek bir özelliği elden geçirmenin gerçekten mümkün olup olmadığını araştırdım, ancak bu konuda aşırı iyimser değilim. Her halükarda çok şey kaçıracağımızı düşünmüyorum, buna make_unique<T>(foo, bar)eşdeğer bir yapı ile sonuçlanmanın T(foo, bar)çok sezgisel olduğunu düşünüyorum; Özellikle göz önüne alındığında make_unique<T>({ foo, bar })oldukça farklı olup olmadığını sadece mantıklı foove baraynı tür.

Bu nedenle , genel kod için sadece değer başlatma (örneğin T t {};veya T t = {};) için parantez kullanıyorum , bu çok uygun ve bence C ++ 03 yolundan daha üstün T t = T();. Aksi takdirde, ya doğrudan başlatma sözdizimi (yani T t(a0, a1, a2);) ya da bazen varsayılan yapı ( T t; stream >> t;düşündüğümde kullandığım tek durum).

Bu, tüm parantezlerin kötü olduğu anlamına gelmez, düzeltmelerle önceki örneği düşünün:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{ return std::unique_ptr<T> { new T(std::forward<Args>(args)...) }; }

Bu std::unique_ptr<T>, gerçek tür şablon parametresine bağlı olsa da, yine de köşeli ayraçları kullanır T.