C ++ 'da tuple kullanımı neden daha yaygın değil?

Neden hiç kimse C ++ 'da, Boost Tuple Kitaplığı veya TR1 için standart kitaplık kullanmıyor gibi görünüyor ? Çok fazla C ++ kodu okudum ve çok nadiren tuple kullanımını görüyorum, ancak çoğu zaman tupleların birçok sorunu çözebileceği birçok yer görüyorum (genellikle işlevlerden birden çok değer döndürür).

Tuples, bunun gibi her türlü harika şeyi yapmanıza izin verir:

tie(a,b) = make_tuple(b,a); //swap a and b

Bu kesinlikle bundan daha iyi:

temp=a;
a=b;
b=temp;

Tabii ki bunu her zaman yapabilirsiniz:

swap(a,b);

Peki ya üç değeri döndürmek isterseniz? Bunu tuple ile yapabilirsiniz:

tie(a,b,c) = make_tuple(b,c,a);

Tuples ayrıca, bir işlevden birden çok değişkeni döndürmeyi çok daha kolaylaştırır, bu muhtemelen değerleri değiştirmekten çok daha yaygın bir durumdur. Değerleri döndürmek için referans kullanmak kesinlikle çok şık değil.

Tuple'ların benim düşünmediğim büyük dezavantajları var mı? Değilse, neden nadiren kullanılıyorlar? Daha yavaşlar mı? Yoksa sadece insanlar onlara alışkın değil mi? Tuple kullanmak iyi bir fikir mi?

Çünkü henüz standart değil. Standart olmayan herhangi bir şeyin çok daha büyük bir engeli vardır. Boost Parçaları, programcılar onlara haykırdığı için popüler hale geldi. (hash_map akla gelir). Ancak tuple kullanışlı olsa da, insanların ondan rahatsız olacağı kadar büyük ve net bir kazanç değil.

Alaycı bir cevap, birçok kişinin C ++ 'da programladığı, ancak daha yüksek seviye işlevselliği anlamadığı ve / veya kullanmadığıdır. Bazen bunun nedeni onlara izin verilmemesidir, ancak çoğu sadece denemiyor (hatta anlamıyor).

Takviye içermeyen bir örnek olarak: içinde bulunan işlevleri kaç kişi kullanıyor <algorithm>?

Başka bir deyişle, birçok C ++ programcısı, C ++ derleyicilerini kullanan C programcılarıdır ve belki std::vectorve std::list. Kullanımının boost::tupledaha yaygın olmamasının bir nedeni budur .

C ++ tuple sözdizimi çoğu insanın istediğinden biraz daha ayrıntılı olabilir.

Düşünmek:

typedef boost::tuple<MyClass1,MyClass2,MyClass3> MyTuple;

Öyleyse, tuple'ları kapsamlı bir şekilde kullanmak istiyorsanız, ya her yerde tuple typedef'leri alırsınız ya da her yerde can sıkıcı derecede uzun tip isimler alırsınız. Demetleri severim. Gerektiğinde kullanıyorum. Ancak, genellikle bir N-öğe dizini gibi birkaç durumla veya aralık yineleyici çiftlerini bağlamak için çoklu haritalar kullanıldığında sınırlıdır. Ve genellikle çok sınırlı bir kapsamdadır.

Haskell veya Python gibi bir şeye kıyasla hepsi çok çirkin ve huysuz görünüyor. C ++ 0x buraya geldiğinde ve 'auto' anahtar kelimesini aldığımızda, çok daha çekici görünmeye başlayacak.

Tuple'ların kullanışlılığı, bunları bildirmek, paketlemek ve paketten çıkarmak için gereken tuş vuruşlarının sayısı ile ters orantılıdır.

Benim için bu alışkanlık, eller aşağı: Tuples benim için yeni problemleri çözmüyor, sadece birkaçını zaten halledebilirim. Değerleri değiş tokuş etmek hala eski usulden daha kolay geliyor - ve daha da önemlisi, nasıl "daha iyi" değiştirileceğini gerçekten düşünmüyorum. Olduğu gibi yeterince iyi.

Kişisel olarak, tupleların birden çok değeri döndürmek için harika bir çözüm olduğunu düşünmüyorum - kulağa structs için bir iş gibi geliyor .

Peki ya üç değeri döndürmek isterseniz?

swap(a,b);
swap(b,c);  // I knew those permutation theory lectures would come in handy.

Tamam, 4 vb. Değerlerde, sonunda n-tuple n-1 takaslardan daha az kod olur. Ve varsayılan takas ile bu, üç döngülü bir şablonu kendiniz uyguladıysanız sahip olacağınız 4 yerine 6 atama yapar, ancak derleyicinin bunu basit türler için çözeceğini umuyorum.

Takas işlemlerinin hantal veya uygunsuz olduğu senaryolar üretebilirsiniz, örneğin:

tie(a,b,c) = make_tuple(b*c,a*c,a*b);

paketini açmak biraz garip.

Mesele şu ki, tupleların iyi olduğu en yaygın durumlarla başa çıkmanın bilinen yolları vardır ve bu nedenle tuple'ları almak için büyük bir aciliyet yoktur. Hiçbir şey değilse, bundan emin değilim:

tie(a,b,c) = make_tuple(b,c,a);

6 kopya yapmaz, bu da bazı türler için tamamen uygunsuz hale getirir (koleksiyonlar en bariz olanıdır). Bunun öyle olmadığını söyleyerek demetlerin "büyük" türler için iyi bir fikir olduğuna beni ikna etmekten çekinmeyin :-)

Birden çok değer döndürmek için, değerler uyumsuz türdeyse, demetler mükemmeldir, ancak arayanın bunları yanlış sırada alması mümkünse, bazı kişiler bunlardan hoşlanmaz. Bazı insanlar birden fazla dönüş değerini hiç sevmez ve onları daha kolay hale getirerek kullanımlarını teşvik etmek istemezler. Bazı insanlar sadece giriş ve çıkış parametreleri için adlandırılmış yapıları tercih ederler ve muhtemelen bir beyzbol sopası ile tuple kullanmaya ikna edilemezler. Zevk için hesap yok.

Pek çok kişinin işaret ettiği gibi, tuplelar diğer özellikler kadar kullanışlı değildir.

1. Takas etme ve döndürme hileleri sadece hiledir. Onları daha önce görmemiş olanlar için tamamen kafa karıştırıcıdırlar ve hemen hemen herkes olduğu için, bu hileler sadece kötü yazılım mühendisliği uygulamalarıdır.

2. Tuples kullanarak birden çok değer döndürmek, kendi kendini belgelemekten çok daha az alternatiftir - adlandırılmış türleri döndürmek veya adlandırılmış referansları kullanmak. Bu kendini belgeleme olmadan, eğer karşılıklı olarak dönüştürülebilirlerse ve daha akıllıca değilse, döndürülen değerlerin sırasını karıştırmak kolaydır.

Herkes boost kullanamaz ve TR1 henüz yaygın olarak kullanılamaz.

Gömülü sistemlerde C ++ kullanırken, Boost kitaplıklarını çekmek karmaşıklaşır. Birbirleriyle çiftleşirler, böylece kitaplık boyutu büyür. Veri yapılarını döndürürsünüz veya tuple yerine parametre geçişini kullanırsınız. Python'da tuplelar döndürüldüğünde, veri yapısı döndürülen değerlerin sırası ve türündedir, açık değildir.

Onları nadiren görürsünüz çünkü iyi tasarlanmış kod genellikle onlara ihtiyaç duymaz - vahşi ortamda anonim bir yapı kullanmanın adlandırılmış bir yapıdan daha üstün olduğu pek çok durumda yoktur. Bir demetin temsil ettiği her şey anonim bir yapı olduğundan, çoğu durumda çoğu kodlayıcı sadece gerçek olanı kullanır.

Bir demet dönüşünün anlamlı olabileceği bir "f" fonksiyonumuz olduğunu varsayalım. Genel bir kural olarak, bu tür işlevler genellikle başarısız olabilecek kadar karmaşıktır.

"F" CAN başarısız olursa, bir durum geri dönüşüne ihtiyacınız vardır - sonuçta, arayanların arızayı tespit etmek için her parametreyi incelemek zorunda kalmasını istemezsiniz. "f" muhtemelen kalıba uyuyor:

struct ReturnInts ( int y,z; }
bool f(int x, ReturnInts& vals);

int x = 0;
ReturnInts vals;
if(!f(x, vals)) {
    ..report error..
    ..error handling/return...
}

Bu hoş değil ama alternatifin ne kadar çirkin olduğuna bakın. Yine de bir durum değerine ihtiyacım olduğunu, ancak kodun artık okunabilir olmadığını ve daha kısa olmadığını unutmayın. Tuple ile 1 kopya maliyetine maruz kaldığım için muhtemelen daha yavaştır.

std::tuple<int, int, bool> f(int x);
int x = 0;
std::tuple<int, int, bool> result = f(x); // or "auto result = f(x)"
if(!result.get<2>()) {
    ... report error, error handling ...
}

Bir başka önemli dezavantajı burada gizli - "ReturnInts" ile "f" nin ARAYÜZÜNÜ DEĞİŞTİRMEDEN "ReturnInts" i değiştirerek "f" nin dönüşünü değiştirebilirim. Tuple çözümü bu kritik özelliği sunmuyor, bu da onu herhangi bir kütüphane kodu için daha düşük cevap yapıyor.

Kesinlikle tuples yararlı olabilir, ancak belirtildiği gibi, onları gerçekten kullanmadan önce atlamanız gereken bir miktar ek yük ve bir veya iki engel vardır.

Programınız sürekli olarak birden çok değer döndürmeniz veya birkaç değeri takas etmeniz gereken yerleri bulursa, tuple rotasına gitmeye değer olabilir, ancak bazen işleri klasik yoldan yapmak daha kolaydır.

Genel olarak konuşursak, herkesin Boost'u zaten kurulu değil ve kesinlikle onu indirme ve dahil dizinlerimi sadece tuple tesisleri için onunla çalışacak şekilde yapılandırma zahmetine girmem. Zaten Boost'u kullananların, programlarında Boost kullanmayanlara göre tuple kullanımları bulma olasılıklarının daha yüksek olduğunu ve diğer dillerden gelen göçmenlerin (Python akla geliyor) demetlerin eksikliğinden daha fazla üzüldüğünü göreceksiniz. C ++ 'da tuple desteği ekleme yöntemlerini keşfetmekten çok.

Bir veri deposu std::tuplehem a hem de structdizinin en kötü özelliklerine sahip olduğundan ; tüm erişim n'inci konuma dayalıdır, ancak tuplebir fordöngü kullanarak yineleme yapılamaz .

Yani eğer içindeki elemanlar tuplekavramsal olarak bir dizi ise, bir dizi kullanacağım ve elemanlar kavramsal olarak bir dizi değilse, bir yapı (elemanları adlandırılmış olan) daha sürdürülebilirdir. ( a.lastnamedaha açıklayıcıdır std::get<1>(a)).

Bu, OP tarafından belirtilen dönüşümü tuple'lar için geçerli tek kullanım alanı olarak bırakır.

Birçoğunun Boost.Tuple yerine Boost.Any ve Boost.Variant'ı (biraz mühendislik ile) kullandığını hissediyorum.