Newsgroup: it.comp.programmare.win32
Titolo: [C++ no MFC] Classe comune ?!?

Scusate l'argomento che forse è un po' OT, ma il NG dedicato a C++ che
seguivo era molto rigido (mi uccide se sente parlare di DLL).
Io vorrei creare x DLL che esportano ognuna una classe, queste classi sono
simili in quanto hanno stessi metodi ma che elaborano in modo differente.
Ora, da programma vorrei poter scegliere in modo dinamico quale dll
utilizzare, creare un nuovo oggetto dalla classe esportata e usarlo
liberamente (in casi particolari potrei avere 2 oggetti creati da due dll
diverse).
Facendo alcune prove, con un codice simile a quello sotto, si riesce a fare
quello che voglio, ma non essendo esperto di C++ non so se è la soluzione
ottimale/corretta.
class Cc
    {
    virtual void Fun (void) {};
    }
class Ca : public Cc
    {
    void Fun (void) { MessageBox (NULL;"Dlla",NULL,MB_OK); }
    }
class Cb : public Cc
    {
    void Fun (void) { MessageBox (NULL;"Dllb",NULL,MB_OK); }
    }
void main ( void )
    {
    Cc Cprova;
    Cprova = (Cprova *)new Ca;
    Cprova->Fun ();
    delete Cprova;
    Cprova = (Cprova *)new Cb;
    Cprova->Fun ();
    delete Cprova;
    }
Grazie a tutti
Giuliano

 wrote in message
news:OoXP9.63293$TC5.2...@twister1.libero.it...

Prima considerazione:
nella classe base Cc manca il distruttore virtuale virtual ~Cc();
Senza di questo, al momento delle delete Cprova nel main, avrai dei guai a
run time.
Seconda considerazione:
i cast che fai al momento delle new non sono inutili?
Maurus

 ha scritto nel messaggio
news:auph5a$94ioa$1...@ID-125555.news.dfncis.de...
|
| Prima considerazione:
| nella classe base Cc manca il distruttore virtuale virtual ~Cc();
| Senza di questo, al momento delle delete Cprova nel main, avrai dei guai a
| run time.
|
Hai ragione, manca il distruttore, ma non ho problemi nel main. (tieni conto
che sono comunque esempi)
|
| Seconda considerazione:
| i cast che fai al momento delle new non sono inutili?
|
No, perchè se non li metto il compilatore mi segnala che non può convertire
ta Ca* a Cc*.
Ma come logica la realizzazione è corretta (avere Ca derivata da Cc ed usare
Cc come classe nel prg) ?
Giuliano

 Giuliano
Cosa vedo?
void main ( void )
    {
    Cc Cprova;  // Cc *Cprova e non Cc Cprova!!!! (vedi piů avanti)
    Cprova = (Cprova *)new Ca;
//se usi la new ti viene restituito un puntature alla classe allocata
//quindi Cprova DEVE essere un puntatore ad una classe e
// NON una istanza della classe stessa!



Come giustamente ti ha corretto Luca Marrone c'era un errore nel dichiarare
un'istanza al posto di un puntatore per la new.
Inoltre c'erano diverse cose che non andavano, fra le quali la mancanza di
un distruttore VIRTUALE (non un semplice distruttore) nella classe base, che
e' importante da fare nel caso di ereditarieta' come nel tuo esempio.
Eccoti il tuo esempio riveduto e corretto mettendo delle stampe:
#include <iostream>
class Cc
{
public:
 virtual ~Cc() {} // importante che sia virtual!!!
 virtual void Fun (void) {}
};
class Ca : public Cc
{
public:
 ~Ca() {}
private:
    void Fun (void) {std::cout << "Io sono Ca::Fun" << std::endl;}
};
class Cb : public Cc
{
public:
 ~Cb() {}
private:
    void Fun (void) {std::cout << "Io sono Cb::Fun" << std::endl;}
};
// il main restituisce int e non e' void nello standard
int main ()
{
    Cc *Cprova;
    Cprova = new Ca;
    Cprova->Fun ();
    delete Cprova;
    Cprova = new Cb;
    Cprova->Fun ();
    delete Cprova;
 system("PAUSE");
    return 0;
}
Ed eccoti l'output:
Io sono Ca::Fun
Io sono Cb::Fun
Press any key to continue . . .
Spero che sia tutto chiaro
Maurus

 ha scritto nel messaggio
news:aurps2$vv0$1...@newsreader.mailgate.org...
| void main ( void )
|     {
|     Cc Cprova;  // Cc *Cprova e non Cc Cprova!!!! (vedi più avanti)
|
|     Cprova = (Cprova *)new Ca;
| //se usi la new ti viene restituito un puntature alla classe allocata
| //quindi Cprova DEVE essere un puntatore ad una classe e
| // NON una istanza della classe stessa!
|
|     Cprova->Fun ();
|     delete Cprova;
|
|     Cprova = (Cprova *)new Cb;
|     Cprova->Fun ();
|     delete Cprova;
|     }
|
Ok grazie per l'aiuto, mi sono reso conto che ho fatto più errori nella
trasposizione del codice di esempio che nella logica che volevo utilizzare.

 ha scritto nel messaggio
news:OoXP9.63293$TC5.2...@twister1.libero.it...
|
| Scusate l'argomento che forse è un po' OT, ma il NG dedicato a C++ che
| seguivo era molto rigido (mi uccide se sente parlare di DLL).
|
| Io vorrei creare x DLL che esportano ognuna una classe, queste classi sono
| simili in quanto hanno stessi metodi ma che elaborano in modo differente.
| Ora, da programma vorrei poter scegliere in modo dinamico quale dll
| utilizzare, creare un nuovo oggetto dalla classe esportata e usarlo
| liberamente (in casi particolari potrei avere 2 oggetti creati da due dll
| diverse).
|
Ho iniziato a leggere qualcosa su COM, mi sembra che sia possibile gestire
il tutto tramite esso (una DLL che esporta un'interfaccia anziche le varie
funzioni), cosi facendo la mia dll dovrebbe essere utilizzabile senza
problemi da vari compilatori e/o linguaggi.
Un dubbio però mi sorge, prendete per esempio un gestore di database dove io
posso avere alcune funzioni tipo ReadRecord, WriteRecord. Ogni tipo di DB
usa questi metodi per leggere/scrivere nel proprio formato. Ora non mi è
chiaro se posso tramite COM gestire il tutto tramite una singolo IID oppure
ogni formato deve avere il suo IID oppure .......
Questo discorso (COM al posto della semplice DLL) è corretto ho sono
completamente fuori strada ?
Giocando un attimo sono riuscito a crearmi il mio bel server COM (anche se
non serve però mi ha chiarito alcune cose su COM), ho definito la mia
interfaccia (da es. con metodi ReadRecord e WriteRecord), ma ora ?!?!?!? in
xx::CreateInstance cosa devo fare per gestire i vari formati ?
Scusate le domande forse un po' banali ma la programmazione sotto windows
non mi è cosi familiare come vorrei.
Grazie a tutti
Giuliano