Newsgroup: it.comp.programmare.win32
Titolo: Applicazione MFC

Riflettevo sul semplice codice MFC 
CMyApp MyApp ;
questa istanzazione crea ed avvia l'applicazione MFC .
Tuttavia ho provato a vedere con il debugger i passi che compie
l'applicazione ma non riesco ancora a trovare il bandolo della
matassa.
Il manuale dice che bisogna ridefinire la funzione virtuale
CMyApp::InitIstance in cui si crea effettivamente la finestra
dell'applicazione .
Tuttavia non riesco a capire chi chiama questa funzione.
In teoria dovrebbe farlo l'istanzazione di MyApp ma in che modo visto
che il suo costruttore puo anche essere vuoto ?

 wrote in message
news:3q5bo1128eo19as22...@4ax.com...




E' vuoto il tuo costruttore di CMyApp... ma non quello della classe da cui
erediti la tua App (CWinApp), la quale ha il proprio costruttore, che
chiaramente viene lanciato quando viene instanziata la tua variabile MyApp
(in questo caso, essendo globale, all'atto stesso del lancio
dell'applicativo...)
Sko

 che il suo costruttore puo anche essere vuoto ?
a ogni modo ricordo anche che il tuo programma ha una WinMain implementata
dal framework MFC...
se (in VC++ 6) vuoi vedere come vanno le cose all'avvio di una
applicazione MFC fino alla chiamata a InitInstance, prova ad avviare il
debugger con F11.
ciao
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

dell'applicativo...)
Mi spieghi come fa il costruttore di una classe base a lanciare una
funzione virtuale (InitIstance)di un oggetto derivato non ancora
definito ?

debugger con F11.
Gia fatto ma si nascondono lo stesso alcuni passaggi chiave .
In ogni caso caso il mio discorso di fondo e' questo :
istanzio un oggetto : CMyApp
tutto quello che dovrebbe succedere e' che vengono eseguiti i
costruttori delle classi basi .
Qualcuno pero mi deve spiegare chi lancia la InitIstance definita in
CMyApp .

 wrote in message
news:t9hco1hei7h0ntjpf...@4ax.com...

E' il FrameWork di MFC che effettua la chiamata (La chiamata di default
VUOTA cmq si trova in APPCORE.cpp).
Se tu provi a togliere da un progetto MFC la dichiarazione della
InitInstance sia nella classe CMyApp che erediti da CWinApp (la virtual,
esatto), sia
la funzione stessa ed esegui il progetto in Debug (F11), noterai esattamente
questo, VIene lanciata una InitInstance di default... vuota !
Sko

questo, VIene lanciata una InitInstance di default... vuota !
Quello che mi chiedo io e' :
c'e' qualcosa che mi sfugge circa la programmazione agli oggetti C++
oppure MFC fa le cose di nascosto e scavalca le regole fondamentali
del linguaggio di programmazione ?
L'istruzione 
CMyApp TheApp ;
invoca solo i costruttori delle classi base e dell'oggetto TheApp .
La 
CMyApp::InitIstance 
non puo essere richiamata da nessun costruttore di classe base di
CMyApp , ergo 
se la richiama MFC 
dovrebeb scavalcare le regole fondamentali del linguaggio .

 CMyApp .
è una funzione virtuale, basta lanciarla dalla classe base che il
puntatore nella vtable ti rimanda automaticamente alla versione finale
nella tua classe CMyApp derivata.
leggiti la documentazione sulla parola chiave virtual e capirai cosa sono
le funzioni virtuali, il cui vantaggio è *precisamente* questo che tu non
capisci! ;-)


capisci! ;-)
allora fai questa prova :
class BASE {
  public :
 int a ;
 BASE (void) { Init() ; }
 virtual void Init(void) ;
 } ;
 void BASE::Init(void)
{
 // sono nella classe BASE
 a = 10;
}
class DER : public BASE {
    public :
    int b ;
    DER(void) { b=11 ; }
    void Init(void) ;
 } ;
void DER::Init(void)
{
 b=12;
}
 
DER Der ;
fai un passo passo col debugger e vedrai che il costruttore BASE non
potra mai chiamare la Init della DER anche se e' virtual e del resto
chi conosce il c++ lo capirebbe subito il perche'.

 CMyApp .
La WinMain() di MFC?



Il meccanismo usato č questo:
int WINAPI WinMain(...) //Implementazione di MFC, prova a vedere tra i
sorgenti
  {
  // ... un po' di inizializzazioni...
  CWinApp* app = AfxGetApp(); // qui si ha il puntatore all'oggetto
della tua
classe derivata da CWinApp
  app->InitInstance(); // chiamata virtuale
  // entra nel ciclo dei messaggi etc...
  }
nel costruttore di CWinApp , che viene chiamato dalla tua classe:
CWinApp :: CWinApp( ... )
  {
  // inizializzazioni varie...
  g_app = this; //g_app č una variabile globale di tipo CWinApp*
  // ...
  }
cosě facendo abbiamo registrato il puntatore alla nostra classe in un
membro
globale alla costruzione dell'oggetto CWinApp (Che avviene prima di
chiamare
WinMain in quanto oggetto globale), puntatore che viene recuperato da
AfxGetApp. Nella WinMain chiamiamo InitInstance ed il gioco č fatto.
grazie a 
Fulvio Esposito