Perché l'uso delle tuple in C ++ non è più comune?

Perché nessuno sembra usare le tuple in C ++, la libreria Boost Tuple o la libreria standard per TR1? Ho letto molto codice C ++ e molto raramente vedo l'uso delle tuple, ma vedo spesso molti posti in cui le tuple risolvono molti problemi (di solito restituiscono più valori dalle funzioni).

Le tuple ti consentono di fare tutti i tipi di cose interessanti come questa:

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

Questo è sicuramente meglio di questo:

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

Ovviamente potresti sempre farlo:

swap(a,b);

Ma cosa succede se si desidera ruotare tre valori? Puoi farlo con le tuple:

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

Le tuple rendono anche molto più semplice restituire più variabili da una funzione, che è probabilmente un caso molto più comune dello scambio di valori. L'utilizzo di riferimenti per restituire valori non è certamente molto elegante.

Ci sono grossi svantaggi per le tuple a cui non sto pensando? In caso contrario, perché vengono usati raramente? Sono più lenti? O è solo che le persone non sono abituate a loro? È una buona idea usare le tuple?

Perché non è ancora standard. Qualsiasi cosa non standard ha un ostacolo molto più elevato. Pezzi di Boost sono diventati popolari perché i programmatori chiedevano a gran voce per loro. (hash_map balza in mente). Ma mentre la tupla è utile, non è una vittoria così schiacciante e chiara che la gente si preoccupi di ciò.

Una risposta cinica è che molte persone programmano in C ++, ma non comprendono e / o utilizzano le funzionalità di livello superiore. A volte è perché non sono ammessi, ma molti semplicemente non ci provano (o addirittura non capiscono).

Come esempio non boost: quante persone usano la funzionalità presente in <algorithm> ?

In altre parole, molti programmatori C ++ sono semplicemente programmatori C che usano compilatori C ++ e forse std::vectore std::list. Questo è uno dei motivi per cui l'uso di boost::tuplenon è più comune.

La sintassi della tupla C ++ può essere un po 'più dettagliata di quanto la maggior parte delle persone vorrebbe.

Tener conto di:

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

Quindi, se si desidera fare un ampio uso delle tuple, si ottengono typedef di tuple ovunque o si ottengono nomi di tipi fastidiosamente lunghi ovunque. Mi piacciono le tuple. Li uso quando necessario. Ma di solito è limitato a un paio di situazioni, come un indice N-element o quando si usano le multimap per legare le coppie di iteratori di intervallo. Ed è di solito in un ambito molto limitato.

È tutto molto brutto e burrascoso rispetto a qualcosa come Haskell o Python. Quando C ++ 0x arriva e otteniamo la parola chiave "auto", le tuple inizieranno a sembrare molto più attraenti.

L'utilità delle tuple è inversamente proporzionale al numero di sequenze di tasti richieste per dichiararle, comprimerle e decomprimerle.

Per me è un'abitudine, senza dubbio: le tuple non risolvono alcun nuovo problema per me, solo alcune sono già in grado di gestire. Lo scambio di valori è ancora più semplice alla vecchia maniera - e, cosa più importante, non penso davvero a come scambiare "meglio". È abbastanza buono così com'è.

Personalmente, non credo che le tuple siano un'ottima soluzione per restituire più valori - sembra un lavoro per structs.

Ma cosa succede se si desidera ruotare tre valori?

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

OK, quindi con 4 valori ecc., Alla fine la n-tupla diventa meno codice degli n-1 swap. E con lo scambio di default questo fa 6 compiti invece dei 4 che avresti se implementassi tu stesso un modello a tre cicli, anche se spero che il compilatore lo risolva per tipi semplici.

Puoi creare scenari in cui gli swap sono ingombranti o inappropriati, ad esempio:

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

è un po 'scomodo da decomprimere.

Il punto è, tuttavia, che ci sono modi noti di affrontare le situazioni più comuni per le quali le tuple sono utili, e quindi nessuna grande urgenza di affrontare le tuple. Se non altro, non sono sicuro che:

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

non esegue 6 copie, il che lo rende del tutto inadatto per alcuni tipi (le raccolte sono le più ovvie). Sentiti libero di convincermi che le tuple sono una buona idea per i tipi "grandi", dicendo che non è così :-)

Per restituire più valori, le tuple sono perfette se i valori sono di tipo incompatibile, ma ad alcune persone non piacciono se è possibile che il chiamante li porti nell'ordine sbagliato. Ad alcune persone non piacciono affatto i valori di ritorno multipli e non vogliono incoraggiarne l'uso rendendoli più facili. Alcune persone preferiscono semplicemente strutture nominate per i parametri di entrata e uscita e probabilmente non potrebbero essere persuase con una mazza da baseball per usare le tuple. Nessuna considerazione per il gusto.

Come molte persone hanno sottolineato, le tuple non sono così utili come altre funzionalità.

1. Gli espedienti di scambio e rotazione sono solo espedienti. Sono assolutamente confusi per coloro che non li hanno mai visti prima, e poiché sono praticamente tutti, questi espedienti sono solo una cattiva pratica di ingegneria del software.

2. Restituire più valori usando le tuple è molto meno auto-documentante delle alternative: restituire tipi nominati o usare riferimenti nominati. Senza questa auto-documentazione, è facile confondere l'ordine dei valori restituiti, se sono reciprocamente convertibili e non essere più saggi.

Non tutti possono usare boost e TR1 non è ancora ampiamente disponibile.

Quando si utilizza C ++ su sistemi embedded, l'estrazione delle librerie Boost diventa complessa. Si accoppiano l'un l'altro, quindi la dimensione della libreria aumenta. Restituisci strutture di dati o usi il passaggio di parametri anziché le tuple. Quando si restituiscono tuple in Python, la struttura dei dati è nell'ordine e il tipo dei valori restituiti è semplicemente non esplicito.

Raramente li vedi perché il codice ben progettato di solito non ne ha bisogno, non ci sono molti casi in natura in cui l'uso di una struttura anonima è superiore all'utilizzo di uno con nome. Poiché tutto ciò che una tupla rappresenta in realtà è una struttura anonima, la maggior parte dei programmatori nella maggior parte delle situazioni si adatta semplicemente alla cosa reale.

Supponiamo che abbiamo una funzione "f" in cui un ritorno di tupla potrebbe avere senso. Come regola generale, tali funzioni sono di solito abbastanza complicate da poter fallire.

Se "f" PU fail fallire, hai bisogno di un ritorno di stato - dopotutto, non vuoi che i chiamanti debbano ispezionare ogni parametro per rilevare un errore. "f" probabilmente si adatta al modello:

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...
}

Non è carino, ma guarda quanto brutta è l'alternativa. Nota che ho ancora bisogno di un valore di stato, ma il codice non è più leggibile e non più breve. Probabilmente è anche più lento, poiché incorre nel costo di 1 copia con la tupla.

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 ...
}

Un altro svantaggio significativo è nascosto qui: con "ReturnInts" posso aggiungere il ritorno dell'alter "f" modificando "ReturnInts" SENZA ALTERARE L'INTERFACCIA "f". La soluzione tupla non offre quella caratteristica critica, che la rende la risposta inferiore per qualsiasi codice di libreria.

Sicuramente le tuple possono essere utili, ma come detto c'è un po 'di sovraccarico e un paio di ostacoli che devi saltare prima di poterli usare davvero.

Se il tuo programma trova costantemente luoghi in cui devi restituire più valori o scambiare più valori, potrebbe valerne la pena percorrere la strada delle tuple, ma a volte è più semplice fare le cose nel modo classico.

In generale, non tutti hanno già installato Boost, e di certo non passerei la seccatura di scaricarlo e configurare le mie directory include per lavorarci solo per le sue strutture di tupla. Penso che scoprirai che le persone che già utilizzano Boost hanno maggiori probabilità di trovare usi tupla nei loro programmi rispetto agli utenti non Boost e che i migranti da altre lingue (viene in mente Python) hanno maggiori probabilità di essere semplicemente arrabbiati per la mancanza di tuple in C ++ piuttosto che esplorare i metodi per aggiungere il supporto tupla.

Poiché un archivio di dati std::tuplepresenta le peggiori caratteristiche di a structe di un array; tutti gli accessi sono basati sull'ennesima posizione ma non si può iterare tupleusando afor ciclo.

Quindi, se gli elementi in tuplesono concettualmente una matrice, userò una matrice e se gli elementi non sono concettualmente una matrice, una struttura (che ha denominato elementi) è più mantenibile. ( a.lastnameè più esplicativo di std::get<1>(a)).

Questo lascia la trasformazione menzionata dall'OP come unica base utilizzabile per le tuple.

Ho la sensazione che molti usano Boost.Any e Boost.Variant (con un po 'di ingegneria) invece di Boost.Tuple.