Newsgroup: it.comp.lang.c++
Titolo: Overload ed inclusione multipla:HELP!(lunghetto)

Ciao a tutti,
spero che qualcuno di voi riesca a comprendermi, la situazione č
piuttosto confusa ed io spero di essere sufficentemente chiaro, mi
aiuterņ con un esempio.
Progetto in C++, compilatore Visual C++ 6.0.
Ho scritto alcune classi, ognuna con il suo bel file XXX.cpp e il
relativo file di include XXX .h.
Ognuna di qeste classi include inoltre alcune definizioni comuni in un
file IncludeComune.h.
In una di queste classi, ad es. nel file dummy.cpp devo fare l'overload
di una funzione definita in IncludeComune.h, ho pensato che il metodo
migliore fosse farne la dichiarazione in dummy.h e la relativa
implementazione in dummy.cpp. Per ora tutto ok, i problemi sorgono
quando devo utilizzare la classe definita in
dummy.h in un successivo file, quello contenente il main, chiamiamolo
principale.cpp.
Esempio:
//IncludeComune.h
{
    //...
    definizioni comuni di tipi e classi tra cui classa::foo();
}
//Dummy.h
{
    #include IncludeComune.h
    //...
   dichiarazione di overload di classA::foo();
}
//Dummy.cpp
{
    //...
    definizione dell'overload di classA::foo();
}
//Dummy2.cpp
{
    #include IncludeComune.h
    //...
}
//Principale.h
    /*Utilizza tutte le classi definite nei file precedenti*/
{
    #include IncludeComune.h
    #include Dummy1.h
    #include Dummy2.h
    //...
    utilizzo di classi ed oggetti definiti nei file precedenti
}
Chiaramente il compilatore mi dą errore quando cerco di instanziare un
oggetto definito in Dumm1.cpp in Principale.cpp, come posso fare per
utilizzare oggetti della classe definita in Dummy1 in altri file in cui
ho contemporaneamente anche l'inclusione di IncludeComune.h?
In sintesi, come fare per rendere l'overload di un metodo di una classe
comune a piu' file senza ottenere errori di linkaggio tipo "...alredy
defined in file IncludeComune.h." oppure "...foo is not a member of
..."?
Ho provato a mettere l'overload in altri file, con #ifndef ..., con
#include vari, etc ma niente da fare.
Spero di essere stato il meno confuso e piu' conciso possibile, confido
nel vostro aiuto.
Sono disposto ad inviare i file per chi ne faccia richiesta, risposte
anche in e-mail.
Gianluca

 ..."?
Una classe viene definita (la _definizione_ di una classe e` simile
a quella che per altre cose chiamiamo _dichiarazione_) *UNA* volta,
"in *UN* sol colpo".  E` una pessima idea quella di spezzare questa
singola definizione fra moleplici file.
Una classe deve avere COESIONE.  Se la spezzi, non e` coesa.  Indice
inconfondibile di progetto mal fatto.  Riprogettare, facendo dei
vari overload di interesse funzioni separate dalla classe (vedi ad
es. i vari operator<< che hanno un ostream& come operando sinistro:
*NON* sono, OVVIAMENTE, metodi della classe ostream, che se no
sarebbe impossibilmente non-coesa, bensi` funzioni separate).
Alex

Alex Martelli wrote:
Ciao Alex, e grazie per l'interesse.
Come sospettavo mi sono spiegato male, NON ho spezzato la definizione
dialcuna classe, ho semplicemente riunito in un file alcune inclusioni
comuni, le utilizzo per ogni altro file del progetto.
In uno di questi faccio un overload di un metodo di una classe definita
precedentemente , poi quando cerco di riutilizzare questa classe (col
relativo overload) mi si incXXXa il compilatore.
Chiedevo come faccio a riutilizzare la classe (con l'overload) anche in un
altro file.
Saluti
Gianluca

 relativo overload) mi si incXXXa il compilatore.
Tutti i metodi di una classe, compresi eventuali overload,
sono parte della classe stessa.  Non e` dunque ammesso
dichiarare "un overload di un metodo" al di fuori della
class definition.
Forse continuo a non capire cio` che stai dicendo, ma
l'idea che da` e` qualcosa del tipo:
filecomune.h
    class a {
    public:
        void pippo(int);
    };
altrofile.h
    void a::pippo(double);    // illegale!
Puoi esemplificare a questo livello, proprio tre righe,
cosa esattamente stai invece facendo?
Alex

Ciao ancora,
sarà la stanchezza (10 ore di programmazione!) , ma credo di aver scritto
overload al posto di override, cmq dovrebbe essere cosi':
filecomune.h
    #define...
    #typedef...
    #include tree.h (contiene la def. della classe tree)
    ...
altrofile.h
    #include filecomune.h
    void tree::pippo()// override di funzione;
    class b {
        //usa la funzione tree::pippo();
    };
    ...
altrofile.cpp
    void tree::pippo(){
        //definisco la funzione pippo
    }
    ...
principale.cpp
    #include filecomune.h
    #include altrofile.h
    tree oggetto di classetree;
    b oggettodiclasseb(); // errato, il compilatore non "vede" tree::pippo()
    //...
     //qui la funzione tree::pippo di altrofile.h non è definita, se sposto
la sua def. in filecomune.h è lo stesso,
    //quindi quando cerco di usare b ottengo gli errori elencati nel 1° post
Come posso fare perche' tree::pippo() definita  in altrofile.h sia visibile
anche in principale.cpp, o meglio, che sia visibile anche in altri file
l'override della funzione tree::pippo(?!?) di altrofile.h?
Ora spero di essere stato più chiaro...;-(((((
Gianluca

     void tree::pippo()// override di funzione;
Non si puo` fare.  La tree:pippo *DEVE* essere dichiarata
come parte della definizione della class tree.  In altri
termini, entro "class tree {" e il relativo "}" DEVE
trovarsi "void pippo();".  E` appunto quel che dicevo
sin dal primo post: la classe dev'essere coesa, tutte
le dichiarazioni dei suoi metodi entro la class definition.
Alex

 Alex
Ciao,
il problema è che quella maled***a funzione non l'ho scritta io, ma utilizzo
delle librerie in cui quella funzione non è implementata e per i miei scopi è
assolutamante necessaria, non ho nemmeno i sorgenti ma solo i file lib.
Allora pensavo di provare in un altra maniera: posso scrivere una classe che
esetende quella esistente a cui aggiungerò il metodo che ora implemento come
override.
Suggerimenti al riguardo? A questo proposito, devo riscrivermi tutti i metodi
della classe "base" o basta che io ci aggiunga i nuovi metodi? Come faccio a
chiamare i metodi della classse base senza riscriverli tutti?
Forse esagero con le domande, ma confido nella gentilezza che avete dimostrato
finora (specialmente Alex!), ho dei tempi moooolto ristretti.
Gianluca

 finora (specialmente Alex!), ho dei tempi moooolto ristretti.
Da cui le mie risposte insolitamente concise.
Alex

Suggerimenti al riguardo?
Puoi provare ad estendere la classe con l'ereditarieta`...
Paolo