Una delucidazione in C++

[misterx]

qual'è la differenza secondo voi tra queste 2 dichiarazioni?


a) TPanel** Panel = new TPanel*[100];

b) TPanel* Panel = new TPanel[100];

[ilsensine]

La prima alloca un array di 100 puntatori a oggetti TPanel, la seconda alloca un array di 100 oggetti TPanel

[misterx]

so che hai usato bcb; quindi ti chiedo:

a) TImage** Image = new TImage*[100];
b) TImage* Image = new TImage[100];

io devo allocare dinamicamente dei TImage facendo in modo che con delete[] all'uscita dell'aplicazioni venga liberata completamente la memoria.

Avevo scritto una cosa tipo:

c) TImage *Image[100];

in questo caso specifico mi hanno riferito che la chiamata a delete[] nel momento in cui desidero eliminare un elemento della matrice e deallocare la memoria è inutile in quanto vengono deallocati solo i punatori.

Ho provato le tre soluzioni (a/b/c) ma il risultato che ottengo apparentemente è il medesimo.

Sai qualcosa a tal proposito?

Grazie

[misterx]

Originariamente inviato da misterx
aggiungo questo scorcio di programma che mostra su una form delle immagini ridimensionate; una sorta di anteprima.

int x=0,y=0;
TImage *Image[100]; // qui è l'errore

for (int i =0; i <FileListBox1->Items->Count; i++)
{
x+=105;
if(x>=105*5) {x=0;y+=105;}

Image[i] = new TImage(Form1);
Image[i]->Top = 5;
Image[i]->Left = 5;
Image[i]->Stretch = true;
Image[i]->Width = 90;
Image[i]->Height = 90;
Image[i]->Parent = Form1;

Image[i]->Picture->LoadFromFile(FileListBox1->Items->Strings[i]);
}



Grazie

[/\/\@®¢Ø]

Originariamente inviato da misterx
[b]so che hai usato bcb; quindi ti chiedo:

a) TImage** Panel = new TImage*[100];

b) TImage* Panel = new TImage[100];

io devo allocare dinamicamente dei TImage facendo in modo che con delete[] all'uscita dell'aplicazioni liberi completamente la memoria.

Avevo scritto una cosa tipo:

c) TImage *Image[100];

in questo caso specifico mi hanno riferito che la chiamata a delete[] nel momento in cui desidero eliminare un elemento della matrice e deallocare la memoria è inutile in quanto dealloca solo i punatori.

Ho provato le tre soluzioni (a/b/c) ma il risultato che ottengo apparentemente è il medesimo.

Sai qualcosa a tal proposito?

Grazie

Ciao.
Nel primo caso allochi effettivamente un array di 100 puntatori. Di conseguenza devi creare poi dinamicamente gli ogggetti uno ad uno. Ad esempio con
for ( int i=0 ; i<100; i++ )
Image[i] = new TImage;
Di conseguenza quando devi eliminare il tutto devi pure fare l'opposto. Eliminare i cento puntatori col delete e poi fare il delete[] sull'array.

con b) invece viene allocato dinamicamente un array di 100 oggetti. Quando fai delete[] sull'array viene chiamato il distruttore per ognuna delle cento istanze e quindi non occorre fare altro.

ancora piu' semplice con c). L'array e' allocato staticamente e non occorre elimiarlo. Gli oggetti vengono eliminati alla chiusura del programma.

a) e' piu' scomodo pero' ha il pregio che puoi inizializzare gli oggetti con costruttori diversi da quelli di default.

[misterx]

a) TImage** Panel = new TImage*[100];
b) TImage* Panel = new TImage[100];
c) TImage *Image[100];

tra le dichiarazioni (a/c) ottengo solo una differenza di prestazioni del programma.

Ho compilato il programma usando la dichiarazione (a) e poi (b); ho eliminato tutti i delete/delete[] per capire se la memoria allocata viene deallocata automaticamente da codice aggiunto dal compilatore.

Ebbene: in entrambi i casi, la memoria viene liberata senza la necessità di richiamare alcun distruttore.

Non ho capito perchè.

[ilsensine]

ancora piu' semplice con c). L'array e' allocato staticamente e non occorre elimiarlo. Gli oggetti vengono eliminati alla chiusura del programma.

Attenzione, anche c) dichiara un array di 100 puntatori
Un array di 100 oggetti dovrebbe essere creato con
TImage Images[100];

[misterx]

marco

in tutte le mie dichiarazioni non c'è alcun bisogno di deallocare la memoria in quanto mi hanno riferito che nelle specifiche della VCL è compresa la deallocazione automatica.

Beh, si lavora meno...

Grazie ancora anche a ilsensine

Ciao

[/\/\@®¢Ø]

Originariamente inviato da ilsensine
[b]
Attenzione, anche c) dichiara un array di 100 puntatori
Un array di 100 oggetti dovrebbe essere creato con
TImage Images[100];

Ops... hai ragione

[misterx]

e per rendere l'array dinamico?
anzichè 100 elementi un numero indefinito?


int x=0,y=0;
TImage *Image[???];

for (int i =0; i <FileListBox1->Items->Count; i++)
{
x+=105;
if(x>=105*5) {x=0;y+=105;}

Image[i] = new TImage(Form1);
Image[i]->Top = 5;
Image[i]->Left = 5;
Image[i]->Stretch = true;
Image[i]->Width = 90;
Image[i]->Height = 90;
Image[i]->Parent = Form1;

Image[i]->Picture->LoadFromFile(FileListBox1->Items->Strings[i]);
}

[ilsensine]

TImage **Image = (TImage**) malloc (sizeof(TImage*)*FileListBox1->Items->Count);

(...fai quello che devi fare...)

free(Image)

Scusa per il malloc, ma ci sono rimasto affezionato

[misterx]

ottimo ilsensine; ora sono alle prese con le variabili locali/globali;

se la tua dichiarazione la metti localmente in una funzione, le altre funzioni non possono accedere agli Image dichiarati in essa.....

se sposti la tua dichiarazione nell'header, si rifiuta di compilarla.....

manca sempre 30 a fare 31.

[ilsensine]

Dichiara TImage **Image in un file c (fuori dalle funzioni), e in un header dichiari
extern TImage **Image;

[/\/\@®¢Ø]

Devi mettere la semplice dichiarazione nell'header, e poi definirla in un solo file.
Ad esempio, se voglio avere un array di questi oggetti:

nell'header:

extern TImage** Image;

in un file .cpp

TImage** Image = new TImage* [blabla->count];

[misterx]

ho già provato ma il linker mi dice che non trova le definizioni degli altri componenti....

[ilsensine]

TImage** Image = new TImage* [blabla->count];

Ehm...è un pò difficile mettere questa riga (compreso il new) fuori da una funzione

[/\/\@®¢Ø]

non vale !
mi hai anticipato ancora !
uffi !

[/\/\@®¢Ø]

porc... toppato ancora

dovrei avere un po' meno fretta nello scrivere

[ilsensine]

Ehm...è un pò difficile mettere questa riga (compreso il new) fuori da una funzione

Ariehm...ho detto una c@zz@t@
(o meglio, si può usare una new con parametro di array costante, ma non variabile ovviamente)

[/\/\@®¢Ø]

Fiuu... ogni tanto le intivo allora !
Da un certo punto di vista hai ragione comunque. In quella funzione devi fare riferimento a valori che siano gia' noti, e non sempre la cosa e' immediata ( se utilizzi costanti che stanno in altri files .cpp potrebbero non essere ancora state inizializzate ).

Forse la cosa migliore sarebbe quella di utilizzare funzione opportuna