Newsgroup: it.comp.lang.c++
Titolo: Creare un array di puntatori dinamico

Salve a tutti, ho un problema un po' particolare. Vorrei creare con
l'operatore new un array di puntatori a float in questo modo:
float *p = float * [SIZE];
ma non funziona.
Invece questo funziona:
float *p[SIZE];
 / / alloco gli elementi uno a uno
for(int i=0;i<SIZE;i++)
 p[i]=new float;
Ora questo metodo funziona perfettamente, ma non esiste un metodo per farlo
direttamente con l'operatore new in una sola volta senza fare un ciclo for?
Grazie per l'aiuto.

  p[i]=new float;
probabilmente avrai le tue ragioni, ma ti espongo comunque un 
dubbio che mi sorge.
Risparmi memoria ? Direi di no, in quanto allochi sia l'array di 
puntatori sia tutti gli elementi, sparsi, ma cmq occupando molta 
memoria in più.
Risparmi in velocità ? No, in quanto fai un sacco di operazioni 
singole di allocazione dinamica (lente).
Infine, dato che sizeof (float) = sizeof (float *) su molte 
macchine (sono entrambi dati a 4 byte), direi che anche nel 
passaggio di parametri non ci sono vantaggi a passare per valore 
o per puntatore.
Le matrici sparse come quella che vuoi fare sono invece 
efficienti e più veloci quando si riferiscono a strutture dati 
pesantucce, che devono essere passate come argomenti agilmente 
(via indirizzo) e possibilmente rendendo possibile 
creare/distruggere singoli elementi senza riallocare l'intero array.
Se vuoi soltanto creare un array monolitico, di tipi leggeri, 
sullo heap, bastava un'operazione con operato new []
float * ptrFloatArray = new float [SIZE];
la deallocazione deve essere fatta come
delete [] ptrFloatArray;
senza omettere le parentesi quadre vuote (se no invochi il 
"plain" operator delete, che è preposto a tipi non array)
ptrFloatArray è un puntatore ad un array di float (ossia ci sono 
già gli spazi per gli elementi veri e propri di dati, non solo 
puntatori a essi).
Questo costrutto riduce a una le operazioni di new/delete, 
spreca poca memoria (over-space di controllo fisso, a ogni 
operazione di heap), ma NON ti consente il controllo su elementi 
isolati, cioè la matrice non è sparsa.
Se per qualche ragione ti serve sparsa per forza, allora devi fare
float * * ptrptrFloatArray = new (float *) [SIZE];
for (int J = 0; J < SIZE; J++)
     ptrptrFloatArray [J] = new float;
le delete annidate al contrario, PRIMA distruggi con "plain" 
delete gli elementi (massima efficienza se li distrggi a 
ritroso, dall'ultimo creato al primo, almeno così era con 
vecchie implementazioni lifo) POI distruggi con operator delete 
[] (x array) il puntatore a puntatori ptrptrFloatArray;
ciao
Soviet_Mario


 probabilmente avrai le tue ragioni
Si, esercizio per l'esame, puramente accademico, ovvero inutile.
Purtroppo all'esame chiedono quel tipo di cose. 

 Scusa, errore di distrazione, volevo dire float *p = new float * [SIZE];
Altro errore.
Probabilmente intendevi:
float * * p = new float * [SIZE];
Infatti, in generale, "new T" rende un puntatore a T, e in particolare 
"new float *" rende un puntatore a "float *", cioe' un oggetto di tipo 
"float * *".
-- 
     Carlo Milanesi
 
http://digilander.libero.it/carlmila

CUT
Mea culpa
---------------------------------------------------
Fiat Tipo 1.1 dgt Proud Driver
Il mio blog   
http://iltipoconlatipo.blogspot.com/