Variadic Şablonlar

Coddy'nin C++ Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası. Ders 67 / 104.

Her türden, herhangi bir sayıda bağımsız değişken kabul eden bir işleve ihtiyacınız olursa ne yaparsınız? Geleneksel şablonlar, tam olarak kaç tür parametresine ihtiyaç duyduğunuzu belirtmenizi gerektirir. Değişken sayıda bağımsız değişken alan şablonlar, şablonların isteğe bağlı sayıda şablon bağımsız değişkeni kabul etmesine olanak tanıyarak bu sorunu çözer.

Sözdizimi, bir parametre paketi oluşturmak için ... (üç nokta) kullanır:

template <typename... Args>
void printAll(Args... args) {
    // Args bir şablon parametre paketidir
    // args bir fonksiyon parametre paketidir
}

Bağımsız değişkenleri işlemek için genellikle temel durumla birlikte özyineleme kullanırsın. Parametre paketi, hiçbiri kalmayana kadar her seferinde bir bağımsız değişkeni genişletir:

// Temel durum: argüman kalmadı
void print() {
    std::cout << std::endl;
}

// Özyinelemeli durum: ilk argümanı işle, kalanıyla özyinele
template <typename T, typename... Rest>
void print(T first, Rest... rest) {
    std::cout << first << " ";
    print(rest...);  // Kalan argümanları genişlet
}

print(1, 3.14, "hello", 'x');  // Çıktı: 1 3.14 hello x

Daha basit işlemler için açık özyineleme kullanmadan katlama ifadelerini (C++17) de kullanabilirsiniz:

template <typename... Args>
auto sum(Args... args) {
    return (args + ...);  // Fold ifadesi: tüm argümanları toplar
}

std::cout << sum(1, 2, 3, 4) << std::endl;  // Çıktı: 10

Değişken bağımsız değişkenli şablonlar, std::make_unique, std::tuple ve std::function gibi birçok standart kitaplık özelliğine güç verir. Her türden bağımsız değişken türü ve sayısının herhangi bir birleşimiyle çalışan, tür güvenli işlevler oluşturmalarını sağlar.

Görev

Kolay

Herhangi sayıda bağımsız değişken içeren iletileri işlemek için değişken sayıda parametreli şablonları kullanan esnek bir günlük kaydı sistemi oluşturalım. Değerleri birleştirebilen, bağımsız değişkenleri sayabilen ve biçimlendirilmiş çıktı yazdırabilen yardımcı programlar oluşturacaksınız: bunların tümünü parametre paketlerini kullanarak yapacaksınız.

Kodunuzu iki dosya arasında düzenleyeceksiniz:

Variadic.h: Değişken sayıda parametre alan şablon işlevlerinizi burada tanımlayın.
Tüm bağımsız değişkenlerini aralarında boşluk olacak şekilde ve ardından yeni satır yazdıran bir printAll işlevi oluşturun. Yalnızca yeni satır yazdıran bir temel durum ve ilk bağımsız değişkeni, bir boşluğu yazdırıp kalan bağımsız değişkenlerle yinelemeli olarak devam eden bir özyinelemeli durum kullanın.

İşleve geçirilen bağımsız değişkenlerin sayısını döndüren bir countArgs işlevi oluşturun. Parametre paketinin boyutunu elde etmek için sizeof... kullanın.

Tüm sayısal bağımsız değişkenleri toplayıp sonucu döndüren bir sum işlevi oluşturun. + işleciyle birlikte bir katlama ifadesi kullanın.

Tüm sayısal bağımsız değişkenleri çarpıp sonucu döndüren bir product işlevi oluşturun. * işleciyle birlikte bir katlama ifadesi kullanın.
main.cpp: Dört girdi okuyun (her biri ayrı bir satırda):
1. Bir tamsayı
2. Bir double
3. Bir dize
4. Bir karakter
Değişken sayıda parametreli şablonlarınızı şu şekilde gösterin:
1. Dört girdinin tümüyle printAll işlevini çağırın ve sonucu yazdırın
2. countArgs işlevini tamsayı, double ve karakterle çağırırken bağımsız değişkenlerin sayısını yazdırın: Argument count: <count>
3. Tamsayıyı, double'ı ve 10 ile 5 değerlerini toplayın, ardından şunu yazdırın: Sum: <result>
4. Tamsayı ile 2 ve 3 değerlerini çarpın, ardından şunu yazdırın: Product: <result>
5. printAll işlevini yalnızca dizeyle (tek bağımsız değişken) çağırın
6. printAll işlevini bağımsız değişken olmadan çağırın (yalnızca yeni satır yazdırmalıdır)

Örneğin girdiler 5, 2.5, Hello ve X olduğunda:

5 2.5 Hello X 
Argument count: 3
Sum: 22.5
Product: 30
Hello

printAll işlevinin dört bağımsız değişkenden sıfıra kadar, farklı türlerdeki herhangi bir sayıda bağımsız değişkeni nasıl işlediğine dikkat edin. sum ve product işlevleri, tüm değerleri açık bir özyineleme olmadan zarif bir şekilde birleştirmek için katlama ifadelerini kullanır. countArgs işleviniz, sizeof... ifadesinin paket boyutunu derleme zamanında nasıl verdiğini gösterir.

Kendin dene

#include <iostream>
#include <string>
#include "Variadic.h"

using namespace std;

int main() {
    // Girdileri oku
    int intVal;
    double doubleVal;
    string strVal;
    char charVal;
    
    cin >> intVal;
    cin >> doubleVal;
    cin >> strVal;
    cin >> charVal;
    
    // TODO: printAll'ı dört girdiyle çağır
    
    // TODO: Print argument count using countArgs with intVal, doubleVal, and charVal
    // Format: "Argument count: <count>"
    
    // TODO: intVal, doubleVal, 10 ve 5'in toplamını hesapla ve yazdır
    // Biçim: "Sum: <result>"
    
    // TODO: intVal, 2 ve 3'ün çarpımını hesapla ve yazdır
    // Biçim: "Product: <result>"
    
    // TODO: printAll'ı sadece string ile çağır
    
    // TODO: printAll'ı argümansız çağır
    
    return 0;
}