Haftalık C++ 60 - "Big Four" - Yazılımperver'in Dünyası

Merhaba sevgili yazılımperver dostlarım, öncelikle hepinize 2024 yılında sevdiklerinize mutlu bir sene geçirmenizi diliyorum 🙂

Uzun süredir uEngine4 ile ilgili yazılar paylaştıktan sonra C++ maceramıza dönmenin vakti geldi. Elbette, uEngine’e ilişkin paylaşacağım daha bir çok konu var ama ufak bir ara vermekte bir sakınca yok sanırım. C++ 11, 14, 17’ye ilişkin bir çok konuya bakmış olduk hatta C++ 20’ye dair de bazı kabiliyetlere baktık ama artık dikkatimizi tamamen C++ 20’ye verme vakti geldi sanırım. Hele de ufukta C++ 23 göründükten sonra 🙂

Önceki yazılarıma yukarıdaki yazı dizileri sayfasından ulaşabilirsiniz (https://www.yazilimperver.com/index.php/kodlar/).

C++ 20 denilince aslında öne çıkan dört temel kabiliyet bulunmakta (“The Big Four”), bu yazımda da kısaca bunlara ve diğer özelliklere bakıyor olacağız. İlgili kabiliyetlerin detaylarına ise sonraki yazılarımda bakacağız. Bu konuda da, sayfasında özellikle C++’a yönelik yazılar paylaşan ve bu konu ile ilgili kitapları bulunan Rainer Grimm’in hazırladığı şekle bakalım:

Öncelikle 4 büyüğe bakalım, neler bunlar? “Concepts”, “Ranges” kütüphanesi, “Modules” ve “Coroutines”.

İçerik

1 Concepts
2 Ranges ve Views
3 Modules
4 Coroutines
5 Kaynaklar

Concepts

Temel olarak template mekanizması kullanılarak geliştirilen kodlarda karşılaştığımız ve anlaşılması geliştiriciler için oldukça güç olan hata mesajlarını biraz daha insancıl hale getiren bir mekanizma. Evet, bunun çok basit bir ifade olduğunu biliyorum ki, hikaye hiç de bu kadar değil ama şimdilik bu kafanızda bir resim belirmesi için yeterli sanırım.

Peki bu nasıl sağlanıyor?

İlgili gereksinimlerin, jenerik kod ile birlikte sunulması ve bu tiplerden neler beklendiğinin açık hale getirilmesi,
template argümanlara kısıt getirilmesi
Bunlardan türetilecek olan yapıların bunu kullanması,
İstenmeyen veya beklenmedik tipler ile bu tiplerin kullanımının önüne geçilmesi,
Son olarak da derleme zamanında alacağımız hata mesajlarının daha insancıl olması.

C++ 20 ile birlikte elbette bir çok hazır “concept” de geliyor olacak. Bunlara ilgili yazımda değiniyor olacağım ama burada da bir örnek vermeden geçmeyeceğim.

Şimdi elimizde C++ 20 öncesine ait aşağıdaki gibi bir template function olduğunu düşünelim:

template <typename T>
void TemplateFunction(T x) {
  // ...
}

template <typename T>

void TemplateFunction(T x) {

// ...

}

Bu hali ile bu fonksiyonu herhangi bir tip ile tanımlayarak (float, int) kullanabilirsiniz. Peki bunu sadece tam sayılar ile kullanılmasını istesek ne yapacaktık? İşte C++ 20 ile birlikte aşağıdaki tanımlamayı yapabiliyoruz ve bu sayede tam sayı dışında bir tip ile bu fonksiyon kullanılmaya kalkışılırsa, hatayı derleme zamanında alıyor olacak.

template <std::integral T>
void TemplateFunction(T x) {
  // ...
}

template <std::integral T>

void TemplateFunction(T x) {

// ...

}

Detaylara ilgili yazımda değineceğim. Şimdi diğer kabiliyete bakalım.

Ranges ve Views

ranges kütüphanesi temelde size üzerinde dolaşabileceğiniz (iteratörler ile bağlangıç ve bitiş (begin/end)) bir grup kaleme ilişkin soyutlama sağlayan mekanizmadır. Bir diğer ifade ile aslında mevcut iteratörler üzerinde bir seviye daha soyutlama getirerek, yeni fikirleri ifade etme, bunları STL algoritmaları ile kullanma ve farklı hesaplama yöntemlerini hayata geçirmenize olanak sağlamaktadırlar. Açıkçası bu kabiliyet bir örnek üzerinden incelemek sanırım daha iyi olacak.

Aşağıdaki sayılarak sıralamak için algoritmaları kullanarak aşağıdaki gibi bir yol izleyebilirsiniz:

using namespace std;
vector numbers{ 1, 3, 8, 55, 11, 807, 16, 126, 87, 34 };
sort(begin(numbers),end(numbers));

using namespace std;

vector numbers{ 1, 3, 8, 55, 11, 807, 16, 126, 87, 34 };

sort(begin(numbers),end(numbers));

ranges ile birlikte artık bunu

ranges::sort(numbers);

1	ranges::sort(numbers);

ile de yapabiliyor olacağız.

Özet olarak ranges bize ne sağlıyor?

Ham iteratörleri gizlemek ve kodu daha sade hale getirmek,
Konteynerlerın direk kullanımına izin vermek (dolaşmadan),
Range views ile birlikte, fonksiyon kompozisyonunu (function composition) kolaylaştırmak (views’a da geliyoruz).

Ranges’in asıl kuvveti view’lar ile birlikte daha görünür olmakta. Bir view bize yukarıda tanımladığımız ranges ya da başka view’lar üzerinde operasyon yapmamıza olanak sağlamakta. Bir anlamda fonksiyonel programlama yaklaşımını kazandırmakta. Yani aslında verinin kendisini sahiplenmeden, üzerinde operasyonlar yapmamıza olanak sağlamaktadır. Bu sayede yukarıda da bahsettiğim gibi | operatörü ile birlikte fonksiyonlarını birbirine bağlayabiliyoruz (“piping”).

Bu kabiliyeti de bir örnek ile şimdilik kapatalım:

#include <iostream>
#include <vector>
#include <ranges>

using namespace std;

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
    std::cout << "Original List: ";
    for (auto v: numbers)
        std::cout << v << " ";

    // Once cift sayilari aliyoruz, sonra bunlari 2 ile carpiyoruz
    auto results = numbers | std::views::filter([](int n){ return n % 2 == 0; })
                           | std::views::transform([](int n){ return n * 2; });

    std::cout << "\nFiltered and Transformed : ";
    for (auto v: results)
        std::cout << v << " ";
    return 0;
}

#include <iostream>

#include <vector>

#include <ranges>

using namespace std;

int main() {

std::vector<int> numbers = {1, 2, 3, 4, 5, 6};

std::cout << "Original List: ";

for (auto v: numbers)

std::cout << v << " ";

// Once cift sayilari aliyoruz, sonra bunlari 2 ile carpiyoruz

auto results = numbers | std::views::filter([](int n){ return n % 2 == 0; })

| std::views::transform([](int n){ return n * 2; });

std::cout << "\nFiltered and Transformed : ";

for (auto v: results)

std::cout << v << " ";

return 0;

}

Modules

Modüller, C++ için, başlık dosyalarından kurtularak, çok daha iyi bir izolasyon ve ilgili işlevlerin bir araya getirilmesi için daha modern bir yöntem sunmaktadır.

Burada hızlıca faydalarına değinerek, detayları ilgili yazıma bırakacağım:

Modüllerin bir kere derleme ihtiyacı sebebi ile, daha kısa derleme zamanı,
Başlık dosyası için tanımlanan “include guard” (#ifndef/#define)’a ihiyaç kalmaması,
Dahil edilen modüllerin sırasının önemli olmaması,
Makroların, modülü kapsamı dışına çıkmaması (modül kapsamında olması),
Fiziksel yapıdan ziyade mantıksal yapıyı açıklar. İlgili kabiliyetler isimleri ile birlikte açık olarak dışa sunulabilmektedir,
Başlık dosyaları ile kaynak kodların birbirinden ayrılmasına ihtiyaç kalmaması,
Daha iyi bir paket yönetim sistemine ön ayak olması.

Bu kabiliyete (daha doğrusu ön izlemesine) veda etmeden önce bir örneğe elbette bakıyor olacağız:

export module math;

export int add(int fir, int sec) {
     return fir + sec;
}

import math;

int main() {
    add(2000, 20);
}

export module math;

export int add(int fir, int sec) {

return fir + sec;

}

import math;

int main() {

add(2000, 20);

}

Coroutines

Coroutine’ler, çalışması durdurularak daha sonra devam ettirilebilen fonksiyonlar olarak özetlenebilir. Coroutine’ler “stack” içermezler ve durdurulduklarında, cağrılan kapsama döner ve geri çalışmaya devam ettirildiklerinde ise ki burada devam etmeleri için gereke veri çağıran bağlamda bulunan yığında tutulmadığından (“stack”), bu coroutin’ler asenkron olarak da çağrılabilmektedir. Aşağıdaki figürde de görülebileceği üzere, fonksiyon B çalışmaya devam ederken, A daha sonra devam ettirilebilir. Coroutine’lerin temel olayı aslında bu (elbette detaylar mevcut 🙂 )

Coroutine’ler kısaca içerisinde şu anahtar kelimeleri içeren fonksiyonlara olarak da tanımlanabilir: co_await, co_return, co_yield. Coroutine’ler olay tabanlı uygulamalar geliştirmek için oldukça faydalı bir araç olarak sunulmuştur. Tabi ki bu mekanizma için bir takım sınırlandırmalar da bulunmaktadır ama buna şu an değinmeyeceğim.

İtiraf etmeliyim ki, dört kabiliyet içerisinde en fazla vakit harcamamız gereken sanırım bu kabiliyet olacak, o sebeple de detaylarına bu konuya ilişkin olan yazımda inşallah bakıyor olacağız.

O zamana kadar kendinize çok iyi bakın, hepinize huzurlu ve bol kodlu günler diliyorum 🙂

Paylaşmak güzeldir.

Haftalık C++ 60 – “Big Four”

Concepts

Ranges ve Views

Modules

Coroutines

Kaynaklar

Bir cevap yazın Cevabı iptal et