Newsgroup: it.comp.lang.c++
Titolo: conversione di base

Salve a tutti, stavo provando a scrivere un programma per convertire
un numero dalla base 10 ad un altra (per ora minore di 10) so già
delle funzioni di libreria per fare questo in una sola riga, ma volevo
esercitarmi un po' con le funzioni. Il programma compila, ma appena
gli passo i valori va in errore e si chiude. Incollo qui il codice,
sperando di ricevere l'aiuto di qualcuno, grazie a tutti.
#include <iostream>
#include <stdlib.h>
using namespace std;
int maxleng=10;
int v[10];
int b;
int d=10;
int pow (const int &c, const int &d);
void conversione_base (int &a, int &c); 
int divisione_intera (int a, int b);
int main(int argc, char *argv[])
{
int maxleng=10;
int v[maxleng];
int a,c;
cout<<"inserire il numero in formato decimale";
cin>>a;
cout<<"inserire la base desiderata";
cin>>c;
conversione_base (a,c);
 
  system("PAUSE");	
  return 0;
}
/********************END MAIN***********************************/
void conversione_base (int &a, int &c)
        {
        b=pow(c,d);
        int x;
        for (d=maxleng;d>0;d--)
                {v[d]=divisione_intera (a,b);}
 
 
        }
 
 
/****************POW********************************/ 
int pow (const int &c, const int &d)
        {int ind;
        int pt=c;
        for (ind=d;ind>1;ind--) 
 
                {
                pt=pt*c;}
        return pt;        
        }
/**************END POW***************************/ 
//***************divisione intera********************
int divisione_intera (int a, int b)
{/* q è il risultato della divisione intera, r è il resto,
 a è il dividendo, b il divisore*/ 
  int quoto,r;
  r=a%b;
  quoto=a/b;
  a=r;
  return quoto;
}
//**********fine divisione intera******************
//il programma è piuttosto prolisso, ho preferito scrivere tutto a
//mano per poter esercitarmi con le funzioni.
--
KM
from Agent

 }
Fammi capire... quello che fa questa funzione e' _esattamente_ 
l'operatore '/'. Punto e basta. Tant'e' che il resto lo assegni ad una 
variabile locale, e quindi viene perso il tutto. Utilita'...? Forse 
volevi fare:
int divisione_intera(int& a, int b)
{
   int res = a/b;
   a %= b;
   return res;
}
Ma nel contesto del tuo programma, non ne vedo comunque l'utilita'!
-- 
Mat/tia Belletti             - Graduate student @ 
cs.unibo.it
ICQ: 33292311                - email: 
mbel...@cs.unibo.it
IRC: RedGlow                 - site(s): 
http://mbellett.web.cs.unibo.it/
Red...@jabber.linux.it/Gaim
 - Linux user 299762 @ machine 213003

 int main(void)
Questo è ovviamente corretto, ma dato che è C++ e non C è molto meglio
(per una questione "stilistica", non sintattica) scrivere int main().
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.

di coding molto piu' utilizzato (e quindi comprensibile).
quindi for (ind=-d;ind<-1;ind++) ?
Grazie mille per la risposta, terro' presente la leggibilità la
prossima volta che posto del codice, questo effettivamente era
incomprensibile.
Ciao.
--
KM
from Agent

l'errore e' qui. Pensaci e capirai al motivo...
gią č vero... me ne sono accorto solo adesso, avrei dovuto far andare
il vettore da maxleng-1 a 0 e non da maxleng a 1... (anche se magari
come hai fatto notare se lo avessi fatto da 1 a maxleng me ne sarei
accorto...)
grazie ancora.
--
KM
from Agent

 qui non ho capito... come avrei dovuto scrivere?
Lo standard C++ (a differenza di C99 e come i 'vecchi' C) vuole che la
dimensione di un array sia una grandezza nota a tempo di compilazione.
Nel tuo codice se tu avessi avuto istruzioni intermedie fra 
int maxleng=10;
 .
 .
 .
int v[maxleng];
maxleng avrebbe anche potuto cambiare: questo perchè non è un valore
noto a tempo di compilazione. 10 lo è, ma nulla ci garantisce che
maxleng rimanga 10.
Se tu invece avessi usato 
const int maxleng = 10;
il compilatore avrebbe impedito le modifiche.
Il gcc però ha come estensione la feature del C99 che permette di avere
array di dimensione nota solo a runtime.
Se avessi compilato usando come flag -pedantic, il compilatore avrebbe
(giustamente) pianto.
-- 
RiK0
Non credo negli schemi non vincenti.