19 Ağustos 2019 Pazartesi

std::initializer_list

Giriş
Şu satırı dahil ederiz.
#include <initializer_list>
Bu sınıf bir diziye sadece iterator tutar. Verilen diziyi kopyalamaz. Dolayısıyla oldukça ucuz bir sınıftır. Kendimiz gerçekleştirsek şöyle yaparız.
template<class _E>
class my_initializer_list
{
public:
  typedef _E        value_type;
  typedef const _E&     reference;
  typedef const _E&     const_reference;
  typedef size_t        size_type;
  typedef const _E*     iterator;
  typedef const _E*     const_iterator;

private:
  iterator          _M_array;
  size_type         _M_len;

  // The compiler can call a private constructor.
  constexpr my_initializer_list(const_iterator __a, size_type __l)
    : _M_array(__a), _M_len(__l) { }

public:
  constexpr my_initializer_list() noexcept
    : _M_array(0), _M_len(0) { }

  // Number of elements.
  constexpr size_type
  size() const noexcept { return _M_len; }

  // First element.
  constexpr const_iterator
  begin() const noexcept { return _M_array; }

  // One past the last element.
  constexpr const_iterator
  end() const noexcept { return begin() + size(); }
};
std::initializer_list ve constructor
Effective Modern C++ kitabındaki açıklama şöyle. uniform initilizatin kullanılıyorsa std::initializer_list diğer parametreli constructor'a tercih edilir.
If, however, one or more constructors declare a parameter of type  std::initializer_list, calls using the braced initialization syntax strongly prefer the overloads taking std::initializer_lists. Strongly. If there’s any way for compilers to construe a call using a braced initializer to be to a constructor taking a std::initializer_list, compilers will employ that interpretation.
Örnek
Elimizde iki constructor sunan Foo sınıfı olsun
Foo(std::initializer_list<int>) {
  std::cout << "with initializer list\n";
}
ve
Foo(int) {
  std::cout << "with int\n";
}
Bu sınıfı şöyle çağıralım
Foo a{10};  // new style initialization
Foo b(20);  // old style initialization
Çıktı olarak şunu alırız.
with initializer list
with int
auto Tanımlama
Şöyle yaparız.
auto x={1,2,3};//auto deduces x to std::initializer_list
Şöyle yaparız.
auto items = {1,2,3}; //OK: items is inferred to be std::initializer_list<int>
                      //must #include <initializer_list>
Template Metodlar İle Kullanma
Örnek
Modern Effective C++'ta şöyle bir örnek ver. Elimizde şöyle bir metod olsun.
template<class T>
void f(T t){...}
Daha sonra x değişkeni şöyle kullanılır.
auto x={1,2,3};//auto deduces x to std::initializer_list
f(x);
Örnek
Şöyle yaparız.
template<typename T>
void f(T const & items); 

f({1,2,3}); //ILL-FORMED: T cannot be deduced to be
            //std::initializer_list<int> or anything else
            //even if you use #include <initializer_list>

f(std::initializer_list<int>{1,2,3}); //OK: #include <initializer_list>

f(std::vector<int>{1,2,3});//OK: #include <vector>
                           //because std::vector accepts std::initializer_list<T>
Tek Elemanlı Listeler
Tek elemanlı listeler overload olan metodlarla iyi çalışmıyor. Açıklaması şöyle
  • Otherwise, if the parameter type is not a class and the initializer list has one element, the implicit conversion sequence is the one required to convert the element to the parameter type
Elimizde şöyle bir kod olsun. initializer_list vermemize rağmen int alan metod seçilir.
void f (std::vector<int> v) {...}
void f (int n) {...}


f ({42}); // the int overload is being picked up
Çözümü çift parantez kullanmak. Şöyle yaparız.
f ({{42}});
Eğer std::set alan bir f metodu daha olsaydı şöyle yaparız.
f (std::vector<int>{42});
Return Value
std::initializer_list sonuç dönmek için kullanılamaz. Şöyle yapamayız.
std::initializer_list<int> f() {
  return {1,2,3};
}
Yine aynı şekilde şöyle yapamayız.
auto f() -> std::initializer_list<int>
{
    return {1,2,3};
}
Farklı Tipler
Şu kod derlenmez.
std::initializer_list<int> x{1,2,3,4,5,6};
std::initializer_list<int const> y = x; // error! cannot convert!
Açıklaması şöyle
It sounds like your question is why std::initializer_list<T const> cannot be constructed from std::initializer_list<T> despite the fact that it would be easy to implement such a conversion.

I think the answer is that you are not supposed to have std::initializer_list<T const> in the first place, given that, as you noted, std::initializer_list<T> only gives const access to its elements anyway.

It might therefore be said that there is a "cultural norm" in C++ that you are not supposed to have any constructors that require a std::initializer_list<T const> argument. None of the standard library containers do, for instance, since a cv-qualified value type is illegal anyway (except in the case of std::array, which, of course, has no user-defined constructors anyway).
Initializer List for Döngüsü ile Dolaşılabilir
std::initializer_list ve for Döngüsü yazısına taşıdım.

constructor - default
İmzası şöyle
constexpr initializer_list() noexcept;
constructor - iterator + size
İmzası şöyle.
// The compiler can call a private constructor.
constexpr initializer_list(const_iterator __a, size_type __l);
begin() metodu
İmzası şöyle
// First element.
constexpr const_iterator begin() const noexcept;
Elimizde bir dizi olsun.
int elements[N];
std::initializer_list'i diziye kopyalamak için şöyle yaparız
std::initializer_list<int> data = ...;

size_t size = data.size();
if ( size <= N )
{
  std::copy(data.begin(), data.end(), std::begin(elements));
}
else
{
  std::copy(data.begin(), data.begin()+N, std::begin(elements));
}
end metodu
İmzası şöyle
// One past the last element.
constexpr const_iterator end() const noexcept;
Şöyle yaparız.
std::initializer_list<int> data = ...;

auto it = data.end();
size metodu
İmzası şöyle
// Number of elements.
constexpr size_type size() const noexcept;
Şöyle yaparız
std::initializer_list<int> data = ...;
size_t size = data.size();


Hiç yorum yok:

Yorum Gönder