Newsgroup: it.comp.lang.c++
Titolo: Ricorsione in C++

Spero di spiegarmi in maniera comprensibile. 
Supponiamo di avere i array statico di interi 
int valore[10]; 
e supponiamo che a me interessi che ogni elemento dell'array possa avere valori che vanno da 0 a 9 
Ora, per poter considerare tutte le possibili combinazioni di valori degli elementi dell'array dovrei utilizzare 10 cicli for concatenati di 10 iterazioni ognuno: 
for(int i=0;i<10;i++) 
{ 
for (int j=0;j<10;j++) 
{ 
............ 
Complichiamo ora il problema: 
Non so a priori di quanti elementi deve essere formato l'array ( mi viene detto da riga di comando), quindi bisogna realizzarlo in maniera dinamica, e fin qui ci siamo; 
non so a priori il range di valori che possono assumere gli elementi dell'array: al posto di 10 metterıı una variabile! E anche questo ıı facile. 
Ma come faccio a mettere un numero imprecisato di cicli for? 
Dopo essermi spremuto le meningi sono arrivato alla conclusione che l'unico modo ıı usare la ricorsione, ma non ne sono capace!! 
Qualcuno che mi da una manina? 
Grazie
------------------------------------------------------------------------
Questo messaggio e` stato inviato da 
http://www.inwind.it

 ............
Non è molto chiaro. Cosa intendi con considerare tutte le possibili
combinazioni dell'array? E soprattutto perchè ti serve farlo?
In altre parole, qual'è esattamente il problema?
Se devi verificare che gli elementi siano tutti nel range voluto ti
basta un solo ciclo!!
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 e supponiamo che a me interessi che ogni elemento dell'array possa avere
valori che vanno da 0 a 9
perche' int allora ?  ti basterebbero 4 bit. cioe' un char per ogni due
locazioni.
Potresti farci una bella classettina
Ciao
Gaetano.
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 avere valori che vanno da 0 a 9
se ti serve un password cracker, usa jack the ripper, se non e' questo 
lo scopo, dai uno sguardo al suo codice

 iterazioni ognuno:
[cut]
visto che programmi in C++ la cosa migliore e' utilizzare le facilitazioni 
della libreria standard; guarda questo:
#include <iostream>
#include <algorithm>
int main()
{
  const int max=4;
  char v[max] = { 'a', 'n', 't', 'o' };
  std::sort(v,v+max);
  while(std::next_permutation(v,v+max)) {
    std::copy(v, v+max, std::ostream_iterator<char>(std::cout) );
    std::cout << std::endl;
  }
}
Ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it


Ricorda lo sviluppo integrale di un sitema per il totocalcio.
Per esempio considera il caso con tre triple:
#include <iostream>
int main()
{
  int pronostico_gara[4] = { 0 }, j( 0 );
  while ( j < 3 )
  {
    for ( int j( 3 ); j--; )
      std::cout << pronostico_gara[ j ] << ' ';
    std::cout << '\n';
    for ( j=0; 2 == pronostico_gara[ j ]; ++j )
      pronostico_gara[j] = 0;
    ++pronostico_gara[j];
  }
  std::cin.get();
  return 0;
}
Spero ti possa servire.
ciao
Massimo

 Spero di spiegarmi in maniera comprensibile.
In questa maniera si risolve il tuo problema. La soluzione può anche essere 
implementata in modo NON ricorsivo. ( ma a me sembrava meno elegante ).
#include <iostream>
using namespace std;
class ricorsiva {
        int     len,max;
        int     *array;
        void    cicla( int n );
        void    fine( );
public: 
        ricorsiva( int l, int m ) :
                len(l),max(m),array(new int[l]) { }
        ~ricorsiva(  ) { delete array; }
        void itera( ){ cicla( len ); }
 
 
};
void ricorsiva::cicla( int n ){
        if( !n ){
                fine( );
                return;
        }
 
        for( int i = 0 ; i < max ; i++ ){
                array[n-1]=i;
                cicla(n-1);
        }
}
void ricorsiva::fine( ){        
        for( int i = 0 ; i < len ; i++ )
                cout << array[i];
        cout << endl;
}
int main( ){
        ricorsiva       r( 3,3 ); /* caso 3x3 */
        r.itera( );
}

Qualcuno che mi da una manina?
La ricorsione solitamente viene utilizzata nell'analizzare strutture
ad albero, e non credo che serva a molto se lo scopo é quello di
visitare gli elementi di un array, magari riposta il quesito in
maniera più chiara e ti si potrà dare una mano.
Il Ghenio
-----
These are my parting words to you:
those who give up are doomed!
-----