Una delucidazione in C++

[misterx]

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

questo alloca degli oggetti TImage giusto?
ma ho notato che beve parecchia memoria

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

[/\/\@®¢Ø]

il primo non alloca gli oggetti. Alloca solo la memoria per i puntatori.
Poi devi fare per ogni casella
Image[i]= new TImage;

e alla fine

delete Image[i]
per ogni i prima di fare il
delete[] Image;

Si'. consuma piu' memoria perche' oltre all'oggetto ci vuole lo spazio per il puntatore. Sui nostri pc questo vuol dire 32bit in piu' per ogni oggetto che vuoi creare.

Attento che come ha fatto osservare ilsensine il campo blabla->count deve essere inizializzato ad un valo
re priam dell'inizio del programma ( ad esempio peche' e' una struttura con valore costante ).
Se il valore te lo ricavi durante l'elaborazione, ti conviene non farlo puntare a niente con

TImage ** Image = 0; // (*)

e poi inizializzarlo con la new durante l'esecuzione del programma, quando sai la dimensione effettiva.

Non puoi comunque evitare il punto (*) perche' devi dire al compilatore in che files vuoi gestire l'inizializzazione dell'array.
Spero di non averti confuso le idee

[misterx]

partendo da quanto illustarto da ilsensine

qui viene allocato un array di 100 puntatori a oggetti TImage (4 byte x pointer)
a) TImage** Image = new TImage*[100];

qui viene allocato un array di 100 oggetti TImage (188 byte per TImage, valore ottenuto da sizeof(TImage))
b) TImage* Image = new TImage[100];



caso (a)

TImage** Image = new TImage*[100];
for (int i =0; i <FileListBox1->Items->Count; i++)
{
Image[i] = new TImage(Form1);
Image[i]->Picture->LoadFromFile(FileListBox1->Items->Strings[i]);
}



caso (b)

TImage* Image = new TImage[100];
for (int i =0; i <FileListBox1->Items->Count; i++)
{
Image[i] = new TImage(Form1);
Image[i]->Picture->LoadFromFile(FileListBox1->Items->Strings[i]);
}

nel caso (b) la chiamata "Image[i] = new TImage(Form1);" non è inutile?
in quanto gli oggetti sono stati già creati all'esecuzione del programma?


quindi il caso (b) diverrebbe:


caso (b) senza il costruttore

TImage* Image = new TImage[100];
for (int i =0; i <FileListBox1->Items->Count; i++)
{
Image[i]->Picture->LoadFromFile(FileListBox1->Items->Strings[i]);
}


sicuramente avrò scritto l'ennesima cappellata.....

[ilsensine]

Invece è corretto. Ricorda che con new puoi anche invocare uno specifico costruttore; ad es. puoi cambiare questo

Image* Image = new TImage[100];

con
TImage *Image;
(...)
Image = new TImage[quellochevuoi](Form1);
(...)
delete [] Image;

Se TImage *Image la rendi globale, potrai accedervi anche da altre parti.

[misterx]

ho parlato forse troppo presto; il compilatore rifiuta questo metodo

TImage* Image = new TImage[100];

for (int k =0; k <FileListBox1->Items->Count; k++)
{
Image[k]->Picture->LoadFromFile(FileListBox1->Items->Strings[k]);
}

non si può allocare preventivamente gli oggetti.....boh....

ecco cosa si ottiene.......

Cannot find default constructor to initialize array element of type 'class'

When declaring an array of a class that has constructors, you must either explicitly initialize every element of the array, or the class must have a default constructor.
The compiler will define a default constructor for a class unless you have defined any constructors for the class.

[ilsensine]

Cannot find default constructor to initialize array element of type 'class'

Chettepoxxx
Image = new TImage[100](Form1);

[misterx]

Originariamente inviato da ilsensine
[b]
Chettepoxxx
Image = new TImage[100](Form1);

scusa se insisto ma non funziona......


già che ti ho fatto perdere la pazienza, un'ultima curiosità:

abbiamo detto che (a) e (c) sono equivalenti;

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

entrambi allocano solo dei puntatori quindi, tanto per capire, è come se io scrivessi:

per il caso (a) e (c): char *buf[100];


e per il caso (b): char buf[100][80];


abbi pazienza

[/\/\@®¢Ø]

Originariamente inviato da ilsensine
[b]
Image = new TImage[100](Form1);

Non sapevo si potesse fare cosi'.
E' possibile che non sia una notazione dello standard C++ ma una qualche estensione del compilatore che usi ?

[cionci]

Da quello che so...non è C++ standard...la new dovrebbe permettere di utilizzare esclusivamente il costruttore di default (senza parametri)...

[misterx]

Originariamente inviato da /\/\@®¢Ø
[b]

Non sapevo si potesse fare cosi'.
E' possibile che non sia una notazione dello standard C++ ma una qualche estensione del compilatore che usi ?

scusa, ma questo "Image = new TImage[100](Form1); " non me lo permette in quanto il compilatore mi dice che gli oggetti devono essere inizializzati, forse aggiungendo ulteriore codice che attualmente mi sfugge

[ilsensine]

Non so se devi usare una sintassi particolare...col g++ della gnu funziona (ovviamente devi eseguirla dentro a una funzione, e non in una eventuale dichiarazione globale di Image).

[misterx]

Originariamente inviato da ilsensine
[b]Non so se devi usare una sintassi particolare...col g++ della gnu funziona (ovviamente devi eseguirla dentro a una funzione, e non in una eventuale dichiarazione globale di Image).

non è che casualmente sai come si fa ad ottenere il valore di ritorno da:

Image1->Picture->LoadFromFile("");?

mi interesserebbe sapere in quanto alcune volte, in caso di file corrotti, viene visualizzato un errore interno.

E' possibile scansarlo per poter continuare?

[ilsensine]

Se l'errore di lettura genera una eccezione, te la cavi con un blocco try...catch

[misterx]

Originariamente inviato da ilsensine
[b]Se l'errore di lettura genera una eccezione, te la cavi con un blocco try...catch

avevo supposto una cosa del genere leggendo nella documentazione ma....

come si implementa?

ho trovato questo:

void __fastcall TForm1::ThrowException(TObject *Sender)

{
try
{
throw Exception(“VCL component”);
}
catch(const Exception &E)
{
ShowMessage(AnsiString(E.ClassName())+ E.Message);
}
}

[ilsensine]

Si implementa esattamente come nell'esempio:

try {
Image1->Picture->LoadFromFile(filename);
} catch (const Exception &E) {
// gestione delle eccezioni vcl
} catch (...) {
// gestione delle altre eccezioni (non dovrebbero accadere)
}

[misterx]

così funziona egergiamente se il rpogramma viene lanciato furi dall'ambiente di sviluppo, in pratica viene visualizzato un frame vuoto.....

try {
Image1->Picture->LoadFromFile(filename);
} catch (const Exception &E) {

}

fino a qui mi sta bene ma:
come si legge il valore o l'eccezione per potersi comportare di conseguenza?

io vorrei fare un cosa del tipo:

if(Exception !) NULL) {
printf("hai dei file corrotti");
//altro codice
}
else {
printf("i tuoi file sono tutti OK");
//altro codice
}

[cionci]

Solitamente Exception permette di recuperare i codice di eccezione...
Basta fare uno switch o una serie di if da quello...

[misterx]

trovato, la solita fretta; cattiva consigliera

try {
Image[i]->Picture->LoadFromFile(miofile);
} catch (const Exception &E) {
ShowMessage(AnsiString(E.ClassName())+ E.Message);
}

[misterx]

questa è interessante almeno x me; se ne sapete qualcosa a riguardo, dite; grazie.

try {
Image[i]->Picture->LoadFromFile(miofile);
}
catch (...) { // questo punto; cioè -> (...) <-
}

significa forse considera tutte le eccezioni?
oppure ignora tutte le eccezioni?

[ilsensine]

Vuol dire: cattura tutte le eccezioni che non sono state eventualmente catturate da altri blocchi catch. Se usato da solo ovviamente ti cattura tutte le eccezioni, ma non puoi capire di che tipo di eccezione si tratta.