Yeni C++ Standartları: C++0x Bu Notlar Kaan Aslan’ın C ve Sistem Programcıları Derneği’nde vermiş olduğu Yeni C++ Standartları: C++0x seminerinde kullanılmak üzere hazırlanmıştır. Notlar üzerinde düzeltme yapılmamıştır...

C++ Standartlarının Gelişimi İlk standartlar 98 yılında çıktı: ISO/IEC 14882:1998, kısaca C++98 denir. 2003 yılında düzeltmeler yapıldı fakat eklemeler yapılmadı: ISO/IEC 14882:2003, kısaca C++03 denir. Yeni standartlar muhtemelen 2009’da çıkacak. Fakat ne zaman çıkacağı belli olmadığı için C++0X deniyor (tabi 2009’u geçmemesi gerekir) Standardizasyon grubu ISO/IEC JTC1/SC22/WG21 isimli gruptur. Resmi web sitesi: http://www.open-std.org/JTC1/SC22/WG21 Standardizasyon grubu senede 2 kez toplanıyor. Son taslaklar: N2723=08-0233 (2008)

Kaynaklar www.open-std.org http://www.open-std.org/JTC1/SC22/WG21 C++ Standards Committee Papers: http://www.open-std.org/JTC1/SC22/WG21/docs/papers The Design of C++0x: B. Stroustrup

C++0x’deki YENİLİKLER Dile Yönelik Yenilikler (Seminer Konusu) Standart Kütüphaneye Yönelik Yenilikler

Yeniliklerdeki Temel Prensipler Geçmişe Uyumun Korunması Performansın İyileştirilmesi Modern sistemlerin gereksinimlerin karşılanması Tür güvenliğinin artırılması Standart Kütüphanenin Genişletilmesi Daha kolay öğrenim ve kullanımın sağlanması

Dile Yönelik Yenilikler

auto Tür Belirleyicisi Amaç derleyicinin ifadeye dayalı tür belirlemesi yapmasını sağlanması auto a = 10; // a int türden const auto p = &a; // p const int * türünden std:: vector<int> v; //... for (auto iter = v.begin(); iter != v.end(); ++iter) { } auto belirleyicisi ile bildirilen değişkenlere ilkdeğer verilmek zorundadır. İlgili Standart Raporu: N1984

decltype Tür Belirleyicisi Amaç bir ifadenin türüne uygun türden bildirim yapmak a = 10; decltype(a) b; std:: vector<int> v; //... for (decltype(v.begin()) iter = v.begin(); iter != v.end(); ++iter) { } Operand bir ifadedir, ifadenin türüne bakılır ifade hesaplanmaz (sizeof’’da olduğu gibi) İlgili Standart Raporu: N2343

constexpr Belirleyicisi Amaç sabit ifadesi (constant expression) kavramını daha da genelleştirmek. constexpr belirleyicisi fonksiyon ya da nesne tanımlamasında kullanılabilir. Fonksiyon tanımlamasında kullanılacaksa fonksiyon otomatik inline kabul edilir (yani başlık dosyalarında bildirilmelidir) Fonksiyonun gövdesi yalnızca { return <ifade>; } biçiminde olmalıdır. Buradaki ifade sabit ifadesi olmak zorundadır. return ifadesinde parametre değişkeni kullanılabilir fakat fonksiyon çağrılırken argüman olarak sabit ifadesi girilmek zorundadır.

constexpr Belirleyicisi (Devam) constexpr int square(int x) { return x * x; } //... int a[square(10)]; // geçerli! constexpr nesne tanımlamasında kullanılabilir. Bu durumda nesne otomatik olarak const durumdadır. Fakat verilen ilkdeğerin sabit ifadesi olması gerekir. constexpr int a = 10; // geçerli! constexpr int b = a + 20; // geçerli! int c = 10; constexpr d = c + 30; // geçersiz!

constexpr Belirleyicisi (Devam) Başlangıç fonksiyonları (constructors) constexpr olabilir. Bu durumda gövde boş olmalı ve tüm elemanlara MIL sintaksı ile ilkdeğer verilmelidir. Verilen ilkdeğerlerin de sabit ifadesi olması gerekir. struct Length { explicit constexpr Length(int i = 0) : val(i) { } private: int val; }; İlgili Standart Raporu: N2235

Sağ Taraf Değeri Alan Referanslar (RValue Refrences) Amaç nesne taşıma özelliğini mümkün hale getirerek performansı artırmak Normal referenslara sol taraf değeri alan referanslar (lvalue references) denilmektedir. Sol taraf değeri alan referanslar dekleratörde & ile, sağ taraf değeri alan referanslar && ile bildirilirler. int x; int Func(); int &a = x; // Sol taraf değeri alan referans int &&b = Func(); // Sağ taraf değeri alan referans Sağ taraf değeri alan referanslar ile sol taraf değeri alan referansların kullanımı aynıdır. Her iki referans da bildirimden sonra sol taraf değeri olarak kullanılabilir. Sağ taraf değeri alan referanslar const olmadıkları için geçici nesneleri değiştirebilirler.

Sağ Taraf Değeri Alan Referanslar (Devam) Aşağıdaki örnekte gereksiz bir biçimde kopya başlangıç fonksiyonu çağrılmaktadır: std:.vector<int> Func() { vector<int> v; // elemanlar ekleniyor return v; } //... std::vector<int> v; v = Func(); // Kopya atama operatör fonksiyonu ve kopya başlangıç fonksiyonu çağrılacak

Sağ Taraf Değeri Alan Referanslar (Devam) Kopyalama yerine taşıma yapılabilir: std:.vector<int> Func() { vector<int> v; // elemanlar ekleniyor return std::move(v); } //... v = Func(); // Taşıma yapılıyor

Sağ Taraf Değeri Alan Referanslar (Devam) Sağ taraf değeri alan refererans hem sol taraf değeri ile hem de sağ taraf değeri ile bağlanabilir: int a; int &&r = a; // geçerli! int &&r = 10; // geçerli Sağ taraf değeri alan refererans kullanım sırasında tamamen sol taraf değeri alan referans gibidir ve sol taraf değeri belirtir.

Sağ Taraf Değeri Alan Referanslar (Devam) Overload resolution için kural: void Func(int &r); // #1 void Func(int &&r); // #2 //... int a; int Foo(); Func(a); // #1 Func(10); // #2 Func(Foo()); // #2 Sol taraf değeri için sol taraf değeri alan referans daha iyi dönüştürme sağlar!

null Adres Sabiti : nullptr Amaç NULL adres sabitinin iki anlamlılığını engellemek Standartlara göre sıfır değerini veren int türden sabit ifadeleri null adres sabiti olarak kullanılabilir. Fakat bu durum overload resolution sırasında sorunlara yol açmaktadır: void Foo(int a); // #1 void Foo(int *p); // #2 //... Foo(0); // #1 Foo(NULL); // #1 nullptr bir anahtar sözcüktür ve null adres sabiti anlamına gelir: Foo(nullptr); // #2

C99’daki Yenilikler Amaç C99’daki makul yenilikleri almak ve C99 uyumlululuğunda da ilerlemeler yapmak long long türü C++’a ekleniyor C99’un önişlemcisi alınıyor __func__ makrosu ekleniyor extended integer types kavarmı ekleniyor

Yeni Karakter Sabitleri ve String İfadeleri Amaç Unicode kodlama biçimini resmi olarak dersteklemek char sabitler u, U ya da L önekini alabilir: ‘a’ // char türden sabit u’a’ // char16_t türden sabit (UTF16) U’a’ // char32_t türden sabit (UTF32) L’a’ // wchar_t türünden sabit string ifadeleri u8, u, U ya da L önekini alabilir: “deneme” // const char [] türünden u8”deneme” // const char [] türünden (UTF8 string) u”deneme” // const char16_t [] türünden (UTF16) U”deneme” // const char32_t [] türünden (UTF32) L”deneme” // const wchar_t [] türünden

Yeni Karakter Sabitleri ve String İfadeleri (Devam) String ifadeleri R soneki ile “raw string” biçimine getirilebilir. Bu durumda string içerisindeki Escape karakterleri dikkate alınmaz: R”[Bu bir denemedir]” u8R”...[Bu bir denemedir]...” uR”xxx[Bu bir denemedir]xxx” UR”zzz[Bu bir denemedir]zzz” LR”?[Bu bir denemedir]?”

Özel Fonksiyonlar Üzerinde default ve delete işlemleri Amaç Başlangıç, bitiş fonksiyonları ve new operatör fonksiyonlarının derleyici tarafından yazılmasına izin vermek ya da engellemek class Sample { public: Sample() = default; Sample(int a); //... }; struct NonCopyable { Noncopyable(const Noncopyable &r) = delete; Noncopyable & operator =(const Noncopyable &r) = delete; Noncopyable() = default;

Özel Fonksiyonlar Üzerinde default ve delete işlemleri (Devam) struct NonNewable { void *operator new(std::size_t) = delete; }; Ancak özel fonksiyonlar (default başlangıç fonksiyonu, kopya başlangıç fonksiyonu, kopya atama operatör fonksiyonu default olabilir. Fakat herhangi bir fonksiyon delete olabilir: struct Test { void Foo(int a); void Foo(double a) = delete; //... Foo fonksiyonu double parametreyle çağrılırsa derleme zamanında error oluşur.

Küme Parantezleriyle Değer Atama Amaç Tüm türlere aynı biçimde değer atamasını mümkün hale getirmek int a = 10; // geçerli! int a(10); // geçerli! int a = {10}; // geçerli! int a{10}; // geçerli! Eskiden yalnızca aggregate sınıflara küme paranteziyle değer atanabilirdi. Şimdi her türlü sınıfa atanabilir: class Sample { public: Sample(int a, int b) : m_a(a), m_b(b) {} //... private: int a, b; }; Sample s{10, 20};

Küme Parantezleriyle Değer Atama (Devam) Küme parantezleri içerisindeki listeden std::initializer_list<T> türüne ilkdeğer verilebilir: void Func(std::initiazlier_list<int> a); //... Func({1, 2, 3}); // geçerli! Sınıfın std::initializer_list<T> türünden parametreli başlangıç fonksiyonu bulunabilir. Overload resolution işleminde bu parametrenin önceliği vardır: class Sample { public: Sample(int a, int b); {} Sample(std::initializer_list<int> v); private: int a, b; }; Sample s{10, 20}; // initializer_list<int> parametreli başlangıç fonksiyonu çağrılır:

Küme Parantezleriyle Değer Atama (Devam) Küme parantezleri içerisindeki değerler büyük türden küçük türe dönüştürmeye yol açmamalıdır: void Func(std::initiazlier_list<int> a); //... Func({1, 2.3, 3}); // geçersiz! initializer_list<T> sınıfı <initializer_list> başlık dosyasında aşağıdaki gibi bildirilmiştir: template<class E> class initializer_list { public: initializer_list(); size_t size() const; // number of elements const E* begin() const; // first element const E* end() const; // one past the last element };

Başlangıç Fonksiyonlarının Birbirlerini Çağırması Artık sınıfın bir başlanıç fonksiyonu MIL sintaksı ile başka bir başlangıç fonksiyonunu çağırabilir: class Sample { public: Sample(int val) : m_val(val) {} Sample() : Sample(0) private: int m_val; };

Yeni enum Türleri enum türlerinin ilişkin olduğu tamsayı türleri artık belirtilebilir: enum Days : long { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday }; enum class ve enum struct türleri faaliyet alanlı enum oluşturur: enum class Meyva { Elma, Armut, Kayisi //... Meyva m = Meyva::Elma; // geçerli! int val = Meyva::Elma; // geçersiz! Eski enum türleri de faaliyet alanı ile kullanılabilir: enum Test { XX, YY}; int val = Test::XX; // geçerli

Lambda İfadeleri [] (int a, int b) { return a * b; } Amaç küçük predikative fonksiyonların çabuk ve okunabilir bir biçimde ifade edilmesi [] (int a, int b) { return a * b; } [] (int a, int b) -> int { int c = a * b; return c; } std::list<int> x; int total = 0; std::for_each(x.begin(), x.end(), [&total] (int x) { total += x} ) ; İstenirse stack’teki tüm değişneler kullanılabilir: std::for_each(x.begin(), x.end(), [&] (int x) { total += x} )

Lambda İfadeleri (Devam) Stack nesnelerinin bazıları değerle geçilebilir: std::list<int> x; int total = 0; int a = 10; std::for_each(x.begin(), x.end(), [&, a] (int x) { total += x * a} ) ; Lambda fonksiyonları sınıfın bir üye fonksiyonunda kullanılmışsa friend kabul edilmektedir. Lamda fonksiyonları derleyici tarafından oluşturulmuş bir sınıfa ilişkin fonksiyon nesnesi olarak ele alınır.