Allocazione c++

[leomagic]

ricapitoliamo da capo:

int anni(double iniziale,double finale,int i,double v2[])
{
   if (iniziale >= finale)  								//condizione x l'uscita dalla ricorsione
     return 0;
   iniziale = iniziale + iniziale * 0.035 * 0.875; //calcolo del guadagno
   iniziale=app(iniziale);                         //approssimazione del numero
   v2[i]=iniziale;
   return 1 + anni(iniziale,finale,i+1,v2);        //ricorsione
}

questo è il codice che calcola l'aumentare del capitale anno in anno.
X fare un grafico di come aumenta il capitale avevo pensato di mettere ogni valore calcolato da questa funzione in un vettore di n elementi quanti sono gli anni che occorreranno x far raggiungere il capitale finale dato da tastiera da un capitale inziale dato da tastiera.
Quel v2 è un vettore dichiarato di 100 elementi,x ottimizzare lo spazio usato in memoria avevo pensato di allocarlo dinamicamente..
Saprò esattamente quanto dovrà essere grande il vettore,ma solo alla fine della funzione,allorche avrò perso tutti i valori intermedi..
Se la rieseguò il programma perderà la sua ottimizzazione..
un pò più chiaro?

[cionci]

Appunto allora come dicevo io devi allocare continuamente nuova Ram...

int anni(double iniziale,double finale,int i,double &*v2, int &v2_dim)
{
   if (iniziale >= finale)  								//condizione x l'uscita dalla ricorsione
     return 0;
   iniziale = iniziale + iniziale * 0.035 * 0.875; //calcolo del guadagno
   iniziale=app(iniziale);                         //approssimazione del numero
   if(i>=v2_dim)
   {
      v2 = realloca(v2, v2_dim, v2_dim+10);
      v2_dim += 10;
   }
   v2[i]=iniziale;
   return 1 + anni(iniziale,finale,i+1,v2,v2_dim);        //ricorsione
}

Per richiamarlo fai così:

int *vett = NULL, vett_dim = 0;
int n = anni(iniziale,finale,0,vett,vett_dim);

In vett ti ritrovi il tuo vettore...con n elementi occupati, ma di dimensione vett_dim...

[leomagic]

non è sbagliato quel passaggio di paremetri formali con &* insieme?
cosa vuol dire quel realloca?

[cionci]

Sì...ho sbagliato a scrivere...è *&v2...

Passa un puntatore per riferimento...

[leomagic]

ma passare un puntatore per riferimento nn equivale a dire modificare il suo indirizzo?
quindi bastarebbe passare v2 no?
cosa vuol dire v2 = realloca(v2, v2_dim, v2_dim+10);
?

[cionci]

realloca è la funzione che avevo scritto nella pagina precedente...e aumenta (o diminuisce) la dimensione del vettore...

Il passaggio per riferimento del puntatore del vettore serve proprio perchè "realloca" cambia la posizione di allocazione del vettore e questa posizione torna modificata al chiamante...

[leomagic]

sinceramente.....mi sono troppo perso..cavolina..

[cionci]

int *realloca(int *src, int dim_src, int new_dim)
{
   if(new_dim < 0 && dim_src < 0) //controllo se i parametri sono buoni
      return NULL;
   int *dst = NULL;
   if(new_dim > 0)
      dst = new int[new_dim];
   if(src != NULL && dim_src > 0 && new_dim > 0)
      memcpy(dst, src, sizeof(double)*(dim_src > new_dim)?new_dim:dim_src);
   if(dim_src > 0)
      delete[] src;
   return dst;
}

int anni(double iniziale,double finale,int i,double &*v2, int &v2_dim)
{
   if (iniziale >= finale)  //condizione x l'uscita dalla ricorsione
     return 0;
   iniziale = iniziale + iniziale * 0.035 * 0.875; //calcolo del guadagno
   iniziale=app(iniziale);  //approssimazione del numero
   if(i>=v2_dim)
   {
      v2 = realloca(v2, v2_dim, v2_dim+10);
      v2_dim += 10;
   }
   v2[i]=iniziale;
   return 1 + anni(iniziale,finale,i+1,v2,v2_dim);        //ricorsione
}

int main()
{
   
   int *vett = NULL, vett_dim = 0; 
   int n = anni(10000,20000,0,vett,vett_dim); 
   /* ..... */
   return 0;
}

Spiegami cosa non ti torna...

PS: il codice non l'ho compilato...

[leomagic]

la funzione memcpy nn l'ho mai usata..come funziona?

[cionci]

Copia da src a dst una quantità di byte specificata dal terzo parametro...

Il terzo parametro l'ho settato come sizeof(double)*(dim_src > new_dim)?new_dim:dim_src

L'operatore condizione?statement1:statement2 è l'unico operatore ternario (a 3 operandi) presente in C e C++...

Se condizione è vera allora viene eseguito statement1, se condizione è falsa allora viene eseguito statement2...

In pratica il terzo parametro diventa la dimensione in byte dei duble moltiplicato per il minimo fra dim_src e new_dim...

In questo modo supporto sia l'aumento che la diminuzione dello spazio allocato...

[leomagic]

adesso ci sono,ma non cè una cosa + semplice della funzione realloca?
perchè noi a scuola nn l'abbiamo ancora fatta la funzione memcopy e le altre cose..
una cosa anche + macchinosa:
praticamente dovrei creare un puntatore = null,passarlo come parametro, dichiarare dentro la funzione un'altro puntatore di appoggio e lavorare su questi due copiandoli a vicenda?

[cionci]

Sì... Se non vuoi usare memcpy allora puoi sempre usare un for...

int *tmp = src; //così ti eviti anche di fare lo scambio fra src e tmp
src = new int[new_dim];
for(int i=0; i<sizeof(double)*(dim_src > new_dim)?new_dim:dim_src; ++i)
&nbsp;&nbsp;&nbsp;src[i] = tmp[i];

Ora in src hai il nuovo vettore...
Come vedi non è più semplice...
Tutti i vari if nella funzione realloca cercano di trattare ogni condizione che si può presentare alla funzione...

Passando new_dim == 0 si dealloca src e si emtte a NULL dst...
Passando src == NULL si fa la prima allocazione senza deallocare src (che genererebbe un errore)...
Se uno fra new_dim e dim_src sono < 0 allora non fa niente e ritorna NULL...

[cionci]

Te la riscrivo un po' più facile da leggere, visto che ho raggruppato i vari if in modo da evitare di ripetere le istruzioni...
Mi sono accorto che c'era un errore... Sulla prima condizione ci voleva un OR...

int *realloca(int *src, int dim_src, int new_dim)
{
   int *dst  = NULL;

   if(src != NULL && dim_src > 0 && new_dim > 0)
   {
      dst = new int[new_dim];
      memcpy(dst, src, sizeof(double)*(dim_src > new_dim)?new_dim:dim_src);
      delete[] src;
   }

   if(src == NULL &&  new_dim > 0) //prima allocazione
      dst = new int[new_dim];

   if(src != NULL && dim_src > 0 && new_dim == 0) //deallocazione
      delete[] src;

   return dst;
}

Dopo tutto è molto più leggibile così...

[leomagic]

int *realloca(int *src, int dim_src, int new_dim)
{
   int *dst  = NULL;

   if(src != NULL && dim_src > 0 && new_dim > 0)
   {
      dst = new int[new_dim];
      memcpy(dst, src, sizeof(double)*(dim_src > new_dim)?new_dim:dim_src);
      delete[] src;
   }

   if(src == NULL &&  new_dim > 0) //prima allocazione
      dst = new int[new_dim];

   if(src != NULL && dim_src > 0 && new_dim == 0) //deallocazione
      delete[] src;

   return dst;
}

int anni(double iniziale,double finale,int i,double &*v2, int &v2_dim)
{
   if (iniziale >= finale)  //condizione x l'uscita dalla ricorsione
     return 0;
   iniziale = iniziale + iniziale * 0.035 * 0.875; //calcolo del guadagno
   iniziale=app(iniziale);  //approssimazione del numero
   if(i>=v2_dim)
   {
      v2 = realloca(v2, v2_dim, v2_dim+10);
      v2_dim += 10;
   }
   v2[i]=iniziale;
   return 1 + anni(iniziale,finale,i+1,v2,v2_dim);        //ricorsione
}

int main()
{
   
   int *vett = NULL, vett_dim = 0; 
   int n = anni(10000,20000,0,vett,vett_dim); 
   /* ..... */
   return 0;
}

mi da diversi problemi sui passaggi di paramtri,cosa cè che nn va?

[cionci]

Avevo mescolato un po' di int e un po' di double:

#include <iostream.h>
#include <string.h>

double *realloca(double *src, int dim_src, int new_dim)
{
   double *dst = NULL;

   if(src != NULL && dim_src > 0 && new_dim > 0)
   {
      dst = new double[new_dim];
      memcpy(dst, src, sizeof(double)*(dim_src > new_dim)?new_dim:dim_src);
      delete[] src;
   }

   if(src == NULL &&  new_dim > 0) //prima allocazione
      dst = new double[new_dim];

   if(src != NULL && dim_src > 0 && new_dim == 0) //deallocazione
      delete[] src;

   return dst;
}

int anni(double iniziale,double finale,int i,double * &v2, int &v2_dim)
{
   if (iniziale >= finale)  //condizione x l'uscita dalla ricorsione
     return 0;
   iniziale = iniziale + iniziale * 0.035 * 0.875; //calcolo del guadagno
   //iniziale=app(iniziale);  //approssimazione del numero
   if(i>=v2_dim)
   {
      v2 = realloca(v2, v2_dim, v2_dim+10);
      v2_dim += 10;
   }
   v2[i]=iniziale;
   return 1 + anni(iniziale,finale,i+1,v2,v2_dim);        //ricorsione
}

int main()
{
   
   double *vett = NULL;
   int vett_dim = 0; 
   int n = anni(10000,20000,0,vett,vett_dim); 
   
   for(int i=0; i<n; ++i)
	cout << i << " " << vett[i] << endl;
   
   delete[] vett;
   return 0;
}

[leomagic]

ciao,ti faccio davvero i miei complimenti x le tue conoscienze..
tutta via....è sorto un problema con la funzione che hai scritto tu.
Stamani a scuola l'ho inglobata nel programma perfettamente e solo la prima volta che fa l'allocazione mi compaiono degli 0 nel vettori incogniti..mentre la seconda volta funziona perfettamente..
gli 0 non sono tanti spazi che mi servono..
tutta via il prof mi ha dato una idea nuova, te la descrivo:
inzializzare una struttura dove al suo interno ci sarà un double che conterrà il dato che mi serve,ed un puntatore alla stuttura stessa che sarà la testa del puntatore che conterrà tutti i valori.
L'idea era di concatenare tutti i valori,passare per parametro il puntatore a struttura e cambiare la testa di volta in volta,che ne dici?
mi sembra molto più semplice del tuo e oltretutto nn dovrò utilizzare un vettore puntatore di appoggio per copiarci i valori.
A voce è facile a dirlo,purtroppo la lezione era finita..e in 5 minuti mi ha spiegato una pagina che mi sono portato a casa,magari ci lavorò un pò su e poi ti faccio sapere..cmq ti scrivo il codice di tutto il programma che ho fatto stamani:

double *realloca(double *src,int dim_src,int new_dim)
{
   double *dst=NULL;
   src=NULL;
   if(src!=NULL && dim_src>0 && new_dim>0)
   {
      dst = new double[new_dim];
      memcpy(dst,src,sizeof(double)*(dim_src>new_dim)?new_dim:dim_src);
      delete[] src;
   }
   if(src==NULL &&  new_dim>0) //prima allocazione
      dst=new double[new_dim];
   if(src!=NULL && dim_src>0 && new_dim==0) //deallocazione
      delete[] src;
   return dst;
}

float app(float num)     			  //Funzione che approssimerà alla seconda cifra
{                                  //decimale.Tutto ciò perchè l'euro ha solo
  	int n;                          //due cifre decimali
   float a;                        //esempio di app di un numero
   num=num*100;                    //677.447  677.111
   num+=0.5;                       //677.947  677.151
   n=num;                          //678      677
   a=n;                            //678.000  677.000
   return a/100;                   //6.78     6.77
}

int anni(double iniziale,double finale,int i,double *&v2,int &v2_dim)
{
   if (iniziale >= finale)  								//condizione x l'uscita dalla ricorsione
     return 0;
   iniziale = iniziale + iniziale * 0.035 * 0.875; //calcolo del guadagno
   iniziale=app(iniziale);                         //approssimazione del numero
   if(i>=v2_dim)
   {
      v2=realloca(v2,v2_dim,v2_dim+10);
      v2_dim=v2_dim+10;
   }
   v2[i]=iniziale;
   return 1 + anni(iniziale,finale,i+1,v2,v2_dim);        //ricorsione
}

double cap_finale(double iniziale,int anni,int i,double *&v,int &v_dim)
{
   if (anni <= 0)           //condizione x l'uscita dalla ricorsione
   	return iniziale;
   iniziale = iniziale + iniziale * 0.035 * 0.875; 	//calcolo del guadagno
   iniziale=app(iniziale);   									//approssimazione del numero
   if(i>=v_dim)
   {
      v=realloca(v,v_dim,v_dim+10);
      v_dim=v_dim+10;
   }
   v[i]=iniziale;
   return cap_finale(iniziale,anni-1,i+1,v,v_dim); //ricorsione che ritorna il capitale aumentato e gli l'anno - 1
}															//quando gli anni saranno uguali a 0 la funzione terminerà

char menu()     //Output delle possibili scelte
{
   clrscr();
	cout << "Fai la tua scelta : " << endl;
   cout << "1.Inserisci dato da tastiera per capitale in anni" << endl;
   cout << "2.Inserisci dato da tastiera per anni in capitale" << endl;
   cout << "3.Leggi dato da file" << endl;
   cout << "4.Uscita" << endl;
   return getch();
}

void scrivi_file(int anni,float cap,float n)
{
   fstream uscite;
   uscite.open("uscite.txt",ios::app);
   uscite << "per raggiungere " << n << " euro da " << cap << " euro occorrono " << anni << " anni" << endl;
   uscite.close();
}

void scrivi_file2(float capitale,int anni,float ini)
{
   fstream uscite;
   uscite.open("uscite.txt",ios::app);
   uscite << "il capitale che raggiungerai dopo " << anni << " anno partendo da " << ini << " euro sara' "<< capitale << endl;
   uscite.close();
   }

void file(double *&v,double *&v2)
{
	fstream informazioni;
   fstream uscite;
   int cod;
   float cap_ini,n,anni_maturazione;
   double cap_fin;
   char nome[20];
   clrscr;
   fflush(stdin);
   cout << "dimmi nome file da aprire ";
   cin.getline(nome,20);
   informazioni.open(nome,ios::in);
   uscite.open("uscite.txt",ios::out);
   uscite.close();
   if(!informazioni)
   {
   	cout << "file inesistente";
      getch();
   }
   else
      {
   		while(informazioni >> cod >> cap_ini >> n)
         {
         	if(cod==1)
         	{
           		cout << "attenzione,sta per essere calcolato gli anni che occoreranno";
            	cout << " per raggiungere " << n;
            	cout << " da un capitale di " << cap_ini << endl;
            	cout << "Premere un tasto per continuare";
            	getch();
           		anni_maturazione=anni(cap_ini,n,0,v2,0);
            	cout << "\nGli anni sono : " << anni_maturazione << endl;
            	scrivi_file(anni_maturazione,cap_ini,n);
            }
         	if(cod==2)
         	{
            	cout << "attenzione,sta per essere calcolato il capitale che ";
          		cout << " raggiungerai dopo  " << n;
           		cout << " partendo da un capitale di " << cap_ini << endl;
           		cout << "Premere un tasto per continuare";
            	getch();
         		cap_fin=cap_finale(cap_ini,n,0,v,0);
            	cout << "\nil capitale e' " << cap_fin << endl;
               scrivi_file2(cap_fin,n,cap_ini);
            }
         }
      }
   informazioni.close();
}

void main ()
{
   double *vett2=NULL,*vett=NULL;
   int vett2_dim=0,vett_dim=0;
   int n,j,a,i;
   float iniziale,finale;
   char sc;
   	do
      {
      	sc=menu();
     		switch (sc)
   		{
   			case '1':
     	 			clrscr;
   				cout << "Dimmi capitale inziale ";
	   			cin >> iniziale;
  	 				cout << "Dimmi capitale da raggiungere ";
   				cin >> finale;
               a=anni(iniziale,finale,0,vett2,vett2_dim);
   			 	cout << "Gli anni sono " << a << endl << endl;
             for(j=0;j<a+5;j++)               // stampa vettore dati temporanei
   	  	  	cout << vett2[j] << endl;
               getch();
      			break;
  		      case '2':
    	  			clrscr;
               cout << "Dimmi capitale inziale ";
   				cin >> iniziale;
      	 	   cout << "In quanti anni?";
        			cin >> n;
        	      cout << "Il capitale maturato e' " << cap_finale(iniziale,n,0,vett,vett_dim) << endl << endl;
             for(j=0;j<n+5;j++)     //           stampa vettore dati temporanei
   	cout << vett[j] << endl;
               getch();
               break;
               case '3':
               clrscr;
               file(vett,vett2);
               break;
     		 }
      }
      while(sc!='4');
      delete[] vett,vett2;
}

mi sbaglia tutta l'indentazione..

[leomagic]

per la scrittura del record avevo pensato ad una cosa così,può andare?

typedef struct
   {
     double valore;
     testa *pt;
   }testa;

[alderighi]

leo leo e se te lo rubassi??
non ti preoccupare non te lo rubo, a me funzia da dio con il file temporaneo (oddio non esageriamo, diciamo che gira discretamente facciamo le corna), il prof ti vuole far fare la struttura ad albero che è semplice ma difficile allo stesso tempo
Buon divertimento

[leomagic]

alde mi dai una mano?
io nn so come cavolo far richiamare quella struttura dentro un'altra..nn cè modo mi da sempre errore..
porco cagniuzzo..
il prof mi ha complicato d + la vita..mi sa che ci prova gusto..

[alderighi]

dammi il pezzo di codice che ti da errore e solo quello
PS=
calugi=non chiedergli nulla, ti complica la vita non risolvendoti il problema ma creandoti altri dubbi
lami=se sa risolvere il problema è disposta ad aiutarti e non si arrende facilmente