C++ programlamada, Standart Şablon Kitaplığı'ndaki (STL) 'std::any', heterojen bir veriyi işlemek için dinamik bir yazım sunar. Geleneksel kapsayıcılardan farklı olarak 'std::any', herhangi bir türdeki değerlerin tek bir kapsayıcıda saklanmasına olanak tanır ve veri türlerinin bilinmediği veya çalışma zamanında değişiklik gösterdiği senaryolarda esnekliği artırır. Bu türden bağımsız yaklaşım, geliştiricilerin tür güvenliğini korurken daha uyarlanabilir ve ifade edici bir kod oluşturmasına olanak tanıyan genel bir programlamayı destekler. Bu incelemede 'std::any'nin özelliklerini, kullanım şekillerini ve sağlam ve esnek bir C++ kodu yazmadaki rolünü gösteren pratik örnekleri inceleyeceğiz.
Örnek 1: Std::Any'nin Temel Kullanımı
Öncelikle “std::any”nin temel kullanımını göstermek için basit bir örneği inceleyelim. Çeşitli parametre türlerini kabul edecek bir işleve ihtiyaç duyduğunuz bir senaryoyu düşünün:
İşte kod pasajı:
#include
#include
geçersiz süreçHerhangi biri ( const std::herhangi biri & değer ) {
eğer ( değer.has_value ( ) ) {
std::cout << 'Saklanan değerin türü: ' << değer türü ( ) .isim ( ) << std::endl;
eğer ( değer türü ( ) == yazım kimliği ( int ) ) {
std::cout << 'Değer: ' << std::any_cast < int > ( değer ) << std::endl;
} başka eğer ( değer türü ( ) == yazım kimliği ( çift ) ) {
std::cout << 'Değer: ' << std::any_cast < çift > ( değer ) << std::endl;
} başka eğer ( değer türü ( ) == yazım kimliği ( std::dize ) ) {
std::cout << 'Değer: ' << std::any_cast < std::dize > ( değer ) << std::endl;
} başka {
std::cout << 'Desteklenmeyen tür!' << std::endl;
}
} başka {
std::cout << 'Std::any'de depolanan değer yok.' << std::endl;
}
}
int ana ( ) {
süreçHerhangi biri ( 42 ) ;
süreçHerhangi biri ( 3.14 ) ;
süreçHerhangi biri ( std::dize ( 'Merhaba, std::herhangi biri!' ) ) ;
süreçHerhangi biri ( 4.5f ) ; // Desteklenmiyor tip
geri dönmek 0 ;
}
Bu örnekte parametre olarak “std::any” referansını alan ve içeriğini inceleyen “processAny” fonksiyonunu tanımlıyoruz. Fonksiyonun içinde ilk olarak has_value() kullanarak “std::any” değişkeninin kayıtlı bir değeri olup olmadığını kontrol ederiz. Bir değer mevcutsa, type().name() işlevini kullanarak saklanan değerin türünü belirleriz ve türüne göre karşılık gelen değeri yazdırmaya devam ederiz. Ana işlev daha sonra “processAny”in faydasını farklı türlerle çağırarak gösterir: bir tamsayı (42), bir çift (3.14) ve bir dize (“Merhaba, std::any!”). İşlev her türü uygun şekilde işler ve ilgili değerleri yazdırır. Ancak, bu örnekte desteklenmeyen bir kayan noktalı sayıyı (4.5f) işlemeye çalışırken, program, türün desteklenmediğini belirterek durumu düzgün bir şekilde ele alır.
Oluşturulan çıktı:
Bu, 'std::any'nin çeşitli veri türlerinin dinamik olarak işlenmesine nasıl olanak sağladığını ve onu C++'da genel programlama için çok yönlü bir araç haline getirdiğini gösterir.
Örnek 2: Kullanıcı Tanımlı Türlerin Saklanması
İkinci örnek, Standart Şablon Kitaplığı (STL) içindeki bu dinamik türün özel veri yapılarına nasıl sorunsuz bir şekilde uyum sağladığını araştırıyor. Kullanıcı tanımlı bir türe, yani nokta yapısına odaklanarak, 'std::any'nin bu tür yapıların örneklerini nasıl ele aldığını gösteriyoruz.
İşte kod:
#include#include
sınıf Benim Sınıfım {
halk:
Sınıfım ( tam değer ) : veri ( değer ) { }
geçersiz yazdırma verileri ( ) yapı {
std::cout << 'Sınıfımdaki veriler: ' << veri << std::endl;
}
özel:
int verileri;
} ;
int ana ( ) {
std::any anyObject = Sınıfım ( 42 ) ;
eğer ( anyObject.has_value ( ) ) {
Oto & myClassInstance = std::any_cast < Sınıfım &> ( herhangi bir nesne ) ;
myClassInstance.printData ( ) ;
} başka {
std::cout << 'Std::any'de depolanan değer yok.' << std::endl;
}
geri dönmek 0 ;
}
Bu C++ kod parçacığında, 'std::any' türünün 'MyClass' adı verilen kullanıcı tanımlı bir sınıfla kullanımını gösteren basit bir örnek oluşturuyoruz. Sınıfın içinde, bu verinin değerini görüntülemek için 'data' adı verilen özel bir üye değişkeni ve printData() adı verilen genel bir yöntem vardır. Yapıcıdaki “data” üyesine bir tamsayı değeri iletilir ve atanır.
“Main” fonksiyonunda, başlangıç değeri 42 olan bir “MyClass” nesnesini başlatıyoruz ve ardından bunu “anyObject” adlı “std::any” değişkeninde saklıyoruz. Bu, 'std::any'nin kullanıcı tanımlı sınıfların örneklerini tutma yeteneğini gösterir.
Bunu takiben has_value() yöntemini kullanarak “anyObject”in bir değere sahip olup olmadığını kontrol etmek için “if” ifadesini kullanırız. Eğer bir değer varsa “std::any_cast” kullanarak saklanan nesneyi alırız. Saklanan nesneyi 'Sınıfım' referansına dönüştürmek için 'std::any_cast' 'MyClass&' şablon argümanıyla birlikte kullanılır. Bu referans, 'myClassInstance', daha sonra printData() yöntemini çağırmak için kullanılır ve 'std::any' içinde depolanan kullanıcı tanımlı türe erişme ve bu tür üzerinde çalışma yeteneğini gösterir.
Eğer “std::any” içerisinde herhangi bir değer kayıtlı değilse bunu belirten bir mesaj yazdırırız. Bu koşullu kontrol, “std::any” değişkeninin boş olabileceği senaryoları ele almamızı sağlar.
İşte çıktı:
Örnek 3: Karışık Tip Konteyner
Programlamada 'karma tip kap', çeşitli, potansiyel olarak ilgisiz veri türlerinin öğelerini tutabilen bir veri yapısını ifade eder. Bu esneklik, veri türlerinin derleme zamanında bilinmediği veya programın yürütülmesi sırasında dinamik olarak değiştiği senaryolarla uğraşırken değerlidir. C++'da 'std::any' bu kavramı örneklendirerek farklı türlerdeki değerleri depolamak için tek bir konteynerin oluşturulmasına olanak tanır.
Çeşitli türleri barındıran bir kapsayıcı oluşturduğumuz bir senaryoyu inceleyelim:
#include#include
#include
int ana ( ) {
std::vektör < std::herhangi biri > karışık Konteyner;
mixContainer.push_back ( 42 ) ;
mixContainer.push_back ( 3.14 ) ;
mixContainer.push_back ( std::dize ( 'Merhaba' ) ) ;
mixContainer.push_back ( doğru ) ;
için ( sabit otomatik & öğe: karışık Konteyner ) {
eğer ( eleman.tipi ( ) == yazım kimliği ( int ) ) {
std::cout << 'Tamsayı: ' << std::any_cast < int > ( eleman ) << std::endl;
} başka eğer ( eleman.tipi ( ) == yazım kimliği ( çift ) ) {
std::cout << 'Çift:' << std::any_cast < çift > ( eleman ) << std::endl;
} başka eğer ( eleman.tipi ( ) == yazım kimliği ( std::dize ) ) {
std::cout << 'Sicim: ' << std::any_cast < std::dize > ( eleman ) << std::endl;
} başka eğer ( eleman.tipi ( ) == yazım kimliği ( bool ) ) {
std::cout << 'Boole: ' << std::any_cast < bool > ( eleman ) << std::endl;
} başka {
std::cout << 'Bilinmeyen tür' << std::endl;
}
}
geri dönmek 0 ;
}
Bu çizimde, C++ ve 'std::any' özelliğini kullanarak karma türde konteyner kavramını gösteriyoruz. Farklı veri türlerindeki elemanları tutacak konteynerimiz olarak hizmet vermek üzere “mixedContainer” adında “std::vector
Bir 'for' döngüsü kullanarak 'mixedContainer'ı yinelerken, her bir öğenin veri türünü dinamik olarak tanımlamak için type() işlevini kullanırız. “std::any_cast” kullanarak karşılık gelen değerleri türlerine göre çıkartıp yazdırıyoruz. Örneğin eleman “int” tipindeyse onu tamsayı olarak yazdırırız. Eğer “double” türündeyse, onu double olarak yazdırırız ve bu böyle devam eder.
İşte oluşturulan çıktı:
Örnek 4: Std::Any ile Hata İşleme
“Std::any” kullanılırken hataların ele alınması, türün desteklenip desteklenmediğini veya bir değerin depolanıp depolanmadığını kontrol etmeyi içerir. Bu örnekte desteklenmeyen türlerin nasıl ele alınacağını gösteriyoruz:
#include#include
int ana ( ) {
std::herhangi biri benimAny = 42 ;
denemek {
çift değer = std::any_cast < çift > ( benimHerhangi biri ) ;
std::cout << 'Değer: ' << değer << std::endl;
} yakalamak ( const std::bad_any_cast & Bu ) {
std::cerr << 'Hata: ' << e.ne ( ) << std::endl;
}
geri dönmek 0 ;
}
“std::any” değişkenini “myAny” tamsayı türünün 42 değeriyle başlatarak başlıyoruz. Sonraki 'try' bloğunun içinde, 'std::any_cast
Bu potansiyel hatayı zarif bir şekilde yönetmek için, özel istisna türü olan 'std::bad_any_cast'i yakalamak üzere tasarlanmış bir 'catch' bloğu ile istisna işlemeyi uyguluyoruz. Başarısız bir dönüşüm durumunda, “catch” bloğu etkinleştirilir ve hatanın niteliğini iletmek için “std::cerr” kullanarak bir hata mesajı üretiriz. Bu hata işleme stratejisi, programımızın, tür değiştirme girişiminin 'std::any' değişkeninde saklanan gerçek türle çakıştığı durumları incelikli bir şekilde ele alabilmesini sağlar.
Çözüm
Bu makalede, C++'ta farklı türdeki değerler için tanıtılan dinamik tür kapsayıcısı olan C++'daki 'std::any' uygulamalarını araştırdık. Temel kullanımdan kullanıcı tanımlı türleri ve heterojen koleksiyonları yönetmeye kadar değişen senaryoları sergileyerek, çok yönlülüğünü çeşitli örneklerle gösterdik. Derleme zamanında veri türünün bilinmediği senaryolarda pratik uygulamasını gösterdik. Ek olarak, hata işleme tekniklerini araştırdık ve desteklenmeyen türleri özel durum işleme yoluyla zarif bir şekilde yönetmenin önemini vurguladık.