Newsgroup: it.comp.lang.c++
Titolo: Da lista ad intero

 qualcuno vorrà aiutarmi ;-)
Non mi pare terribile... comunque, man
mano che inserisci gli elementi usa
un contatore per tenerne il conto globale.
Nel tuo esempio alla fine avrai "4" elementi.
quindi scorri semplicemente la lista ed usa
l'usuale metodo posizionale:
4*10^(3)+7*(10^2)+9*10^1+3
il punto di partenza te lo da il contatore;
sull'implementazione... beh, esercizio per casa!
:-)
SiMoStro

 vorrą aiutarmi ;-)
MLO@mlinux 29 $ cat foo.cxx
#include <iostream>
#include <list>
#include <numeric>
using namespace std;
int func(int oldValue, int newDigit) { return oldValue * 10 + newDigit; }
int main() {
  list<int> l;
  l.push_back(4); l.push_back(7); l.push_back(9); l.push_back(3);
  cout << accumulate(l.begin(), l.end(), 0, func) << endl;
}
MLO@mlinux 30 $ g++ -ansi -pedantic -W -Wall -o foo foo.cxx && ./foo
4793
MLO@mlinux 31 $
N.B.: attento agli overflow...
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Dept. of Physics, Univ. of Padova, Italy              ROT13: 
ybe...@cq.vasa.vg

 il punto di partenza te lo da il contatore;
Se la lista esiste gia' deve scorrerla due volte inutilmente. In
realta' il contatore non serve, basta rendersi conto che su ogni
elemento bisogna fare:
valore = valore * 10 + elemento_corrente
Ciao,
Nicola

 valore = valore * 10 + elemento_corrente
Questo č indubbiamente il metodo piů veloce.
Senza controlli "a priori" sulla lunghezza della
lista il buon vecchio overflow ci mette lo zampino
(supponi un unsigned int a 16 bit di destinazione
ed una lista di sette elementi...);
non gli ho proposto quello perché mi inc******o ad
un esame su questa cosa, non mi segarono ma mi levň
due punti :-(
da allora ho la fisima sui "controlli" nel codice che
scrivo :-O
SiMoStro

 scrivo :-O
Beh... Ma il controllo lo puoi inserire in vari punti... Potresti per
esempio mettere (prendendo l'esempio di Loreti)
int func(int oldValue, int newDigit)
{
    if (oldValue > (MAX_INT / 10))
        throw;
    return oldValue * 10 + newDigit;
}
:-)
(ha il difetto di essere una soluzione "nel mentre" e non una soluzione "a
priori"... Comunque se ci metti un bel try-catch a proteggere il tutto, in
ogni caso l'errore viene bloccato. Soluzioni a priori sono complesse, perchč
potresti avere un numero paddato con gli zeri (000000000000001000 č sempre
1000!)
--- bye

 sempre 1000!)
Se mi fosse venuto in mente di dirglielo all'epoca...
:-)
In effetti, per dirla tutta, nel "caso particolare"
la lista non poteva essere più lunga di un certo numero
di elementi (si doveva partire da sizeof(), ricavare
il massimo numero di cifre sull'intero senza segno e
scrivere le procedure per la lista e la funzione di
conversione).
La modifica da te proposta mi pare tagli la testa al
toro per molti problemi, tranne forse il caso in cui
si voglia convertire una sequenza tipo 6-5-5-3-8 su un
unsigned int a 16 bit il cui MAX_INT è 65535 (ad esempio,
ma basta cambiare il numero a seconda dell'intero di
destinazione...)
Al penultimo passo 6553 non è maggiore stretto di
65535/10=6553 dunque tenteresti di convertire un
intero superiore al massimo consentito...
ma penso che questi siano "problemi in fase di
implementazione" da considerare con un po' di verifiche
che inevitabilmente richiedano qualche analisi degli
elementi della lista.
Probabilmente siamo andati "oltre", a Tux magari bastava
l'idea di massima...
SiMoStro