Allocazione c++

[leomagic]

devo creare un vettore di tipo double di n elementi.
n = calcolo degli anni che occorrerà x raggiungere un certo valore da uno inziale con l'interessi del 3.5%.
Come posso scrivere questa funzione di allocazione?

[alderighi]

Leo ma che ti metti a fare, se ti vede il Calugi o la Lami, comunque interessa anche a me, anche se il prog è quasi terminato vorrei sapere come si alloca di volta in volta dinamicamente la memoria dentro un ciclo.
grazie
fate qualche esempio

[verloc]

Scusate ma voi,programmate senza uno straccio di guida?
Diamine queste sono le cose fondamentali.

si fa o con l'operatore new oppure con i vector della stl

Dovete imparare a cercare prima sulla guida altrimenti perdete un sacco di tempo.
Adesso però ve la procurate guida eh?

(intendo per guida un file help che descrive tutte le funzioni,non un tutorial)

[cionci]

Mi sa che non usano la standard C++ library...altrimenti non l'avrebbetr chiesto...quindi niente vector...

Con il C++ c'è l'oepratore new che alloca la memoria...
Per aumentare le dimensioni via via che va avanti il programma in C++ non c'è una istruzione precisa come in C (in C c'è realloc)...ma si deve allocare un nuovo vettore più grande del precedente e copiarci dentro i nuovi risultati...
In teoria dovresti farlo all'inserimento di ogni nuovo elemento...ma per diminuire le operazioni di copia che sono solitamente lunghe si fa un preallocazione di N elementi...

Ad esempio questa può essere una classe che esegue queste operazioni... Non so a che punto siete in C++ quindi non uso i template (per poter generalizzare il tipo degli elementi del vettore)...

class vettore_double {
   double *vett;
   int len;
   int maxlen;
   int prealloc;
public:
   vettore_double():prealloc(16);
   vettore_double(vettore_double &vd);
   void set_prealloc(int n);
   int get_length();
   double &operator[](int idx);
   ~vettore_double();
};

vettore_double::vettore_double()
{
    vett = new[maxlen = prealloc];
    len = 0;
}

vettore_double::vettore_double(vettore_double &vd)
{
    prealloc = vd.prealloc;
    len = vd.len;
    maxlen = vd.maxlen;
    vett = new[maxlen];
    for(int i=0; i<len; ++i)
        vett[i] = vd.vett[i];
}

double &vettore_double::operator[](int idx)
{
    if(idx > (maxlen-1))
    {
         double *vett2 = vett;
         maxlen = prealloc * (idx / prealloc + 1);
         vett = new double[maxlen];
         for(int i=0; i<len; ++i)
              vett[i] = vett2[i];
    }
    
    if((len-1) < idx)
        len = idx+1;
 
    return vett[idx];
}


void vettore_double::set_prealloc(int n)
{
     prealloc = n;
}

int vettore_double::get_length()
{
    return len;
}

[leomagic]

o grande alde,seeeee la lami..o dio bono su un programmino mi funziona il new su quello dell'esercitazione nn va..quindi ho chiesto consigli!

Originariamente inviato da alderighi
Leo ma che ti metti a fare, se ti vede il Calugi o la Lami, comunque interessa anche a me, anche se il prog è quasi terminato vorrei sapere come si alloca di volta in volta dinamicamente la memoria dentro un ciclo.
grazie
fate qualche esempio

[leomagic]

Originariamente inviato da cionci
Mi sa che non usano la standard C++ library...altrimenti non l'avrebbetr chiesto...quindi niente vector...

Con il C++ c'è l'oepratore new che alloca la memoria...
Per aumentare le dimensioni via via che va avanti il programma in C++ non c'è una istruzione precisa come in C (in C c'è realloc)...ma si deve allocare un nuovo vettore più grande del precedente e copiarci dentro i nuovi risultati...
In teoria dovresti farlo all'inserimento di ogni nuovo elemento...ma per diminuire le operazioni di copia che sono solitamente lunghe si fa un preallocazione di N elementi...

Ad esempio questa può essere una classe che esegue queste operazioni... Non so a che punto siete in C++ quindi non uso i template (per poter generalizzare il tipo degli elementi del vettore)...

class vettore_double {
   double *vett;
   int len;
   int maxlen;
   int prealloc;
public:
   vettore_double():prealloc(16);
   vettore_double(vettore_double &vd);
   void set_prealloc(int n);
   int get_length();
   double &operator[](int idx);
   ~vettore_double();
};

vettore_double::vettore_double()
{
    vett = new[maxlen = prealloc];
    len = 0;
}

vettore_double::vettore_double(vettore_double &vd)
{
    prealloc = vd.prealloc;
    len = vd.len;
    maxlen = vd.maxlen;
    vett = new[maxlen];
    for(int i=0; i<len; ++i)
        vett[i] = vd.vett[i];
}

double &vettore_double::operator[](int idx)
{
    if(idx > (maxlen-1))
    {
         double *vett2 = vett;
         maxlen = prealloc * (idx / prealloc + 1);
         vett = new double[maxlen];
         for(int i=0; i<len; ++i)
              vett[i] = vett2[i];
    }
    
    if((len-1) < idx)
        len = idx+1;
 
    return vett[idx];
}


void vettore_double::set_prealloc(int n)
{
     prealloc = n;
}

int vettore_double::get_length()
{
    return len;
}

ci sono troppe cose che nn conosco in questo frammento di codice..

[leomagic]

io credevo che fosse una funzione semplice del tipo..
mi faccio passare gli anni che sarebbero quante celle deve contenere il vettore.
creo un puntatore *p[3] x esempio..
poi faccio p = new(int*anni_passati)
la logica è questa..xò nn va..!!

[cionci]

Tra l'altro avevo sbagliato il codice per l'allocazione Che testa...

Comunque la new si usa così:

int *p = new int[numero di anni];

[leomagic]

faccio qualche prova e poi ti faccio sapere ok?

[leomagic]

alde te copiami il programma e ti uccido,ovvia l'idea di usare la new w nn la malloc l'ho avuta io e se il calugi mi dice che l'ho fatto uguale a te ti uccido!!

[leomagic]

cosa c'è che nn va?

#include <iostream.h>
#include <conio.h>
#include <fstream.h>
#include <string.h>
#include <stdio.h>

void main()
{
	int *p;
   int dim,i,n;
   cout << "dimmi dimensione vettore";
   cin >> dim;
   p = new int[dim];
   for(i=0;i<dim;i++)
   {
   	cout << "\ndimmi numero";
      cin >> n;
      *p[i]=n;
   }
    for(i=0;i<dim;i++)
   {
   	cout << *p[i];
   }
}

[cionci]

Questo: *p[i]

p[i] e quivale già a fare *(p+i)...

Comunque io avevo capito che ti serviva ridimensionare un vettore allocato con new... Se ti serve una allocazione semplice a lora va bene come hia fatto te...

p a quel punto lo puoi trattare, quasi, come un normale vettore...

[leomagic]

perfetto ora funziona..ho solo qualche piccolo problema non con il codice ma con il programma stesso..

[cionci]

Ah...mi raccomando..quando non ti serve più devi fare la delete...

delete[] p;

[leomagic]

ok grazie.
Ecco il nuovo problema.
Il vettore dovrà prendere la dimensione di quanti anni occorreranno x raggiungere un certo capitale da uno inziale con un tot di interessi annui.
Gli anni che occorrono verrano calcolati tramite una funzione ricorsiva..quindi io dovrei tutte le volte riallocare il puntatore e ricopiarci i dati dentro?
all'interno del vettore puntatore dovranno finirci i valori intermedi raggiunti anno anno dal capitale iniziale..

[cionci]

De allocarne uno nuovo, cancellare quello vecchio e ricopiare i valori in quello nuovo...

[alderighi]

Non ti proccupare leo mi sa che lascio il file temporaneo, almeno che l'Orsi non allochi dinamicamente la memoria, e allora sarei io l'unico bischero che non lo fa (visto che l'Orsi passa il programma a mezza classe).
Grande cionci ma sei un programmatore o un insegnante?
PS=noi usiamo il vecchio c/c++ della borland in modalità ms-dos

[cionci]

Il file che contiene i valori è una soluzione buona per questo tipo di problemi...

Altrimenti usa questa funzione per reallocare:

#include <string.h> 

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

//esempi di utilizzo
//prima allocazione
vett = realloca(NULL, 0, 10); //alloca un vettore di 10 elementi
//modifica della diemensione
vett = realloca(vett, 10, 20); //modifica la dimensione a 20 e copia i valori
//deallocazione
vett = realloca(vett, 20, 0); //dealloca vett e ritorna NULL

A meno di errori dovrebbe andare bene... Vale sempre il discorso di fare l'allocazione a blocchi (ad esempio 10 a 10)... Quando hai finito lo spazio a disposizione allochi un altro blocco...

Originariamente inviato da alderighi
Grande cionci ma sei un programmatore o un insegnante?

Programatore...

Originariamente inviato da alderighi
PS=noi usiamo il vecchio c/c++ della borland in modalità ms-dos

Male...oltre a essere per DOS (non crea eseguibili a 32 bit) è anche uno dei copilatori fra quelli che conosco che rispetta meno los tandard sia del C che del C++...

[leomagic]

mi sembra un pò troppo complicato x i nostri livelli,eppure deve esistere un modo + semplice..
Io devo solo allocare un vettore d n elementi!
la cosa difficile che mi resta a me è che quel n viene calcolato da una funzione ricorsiva..

[cionci]

Allora devi o no modificare dinamicamente la dimensione del vettore ? Oppure la dimensione la conosci prima di allocarlo ?

Se la conosci prima di allocarlo:

n = calcola_n();

vett = new int[n];

e lo allochi...