Uso di file di origine MFC
La libreria Microsoft Foundation Class (MFC) fornisce il codice sorgente completo. I file di intestazione (.h) si trovano nella directory \atlmfc\include . I file di implementazione (con estensione cpp) si trovano nella directory \atlmfc\src\mfc .
Questo articolo illustra le convenzioni usate da MFC per commentare le varie parti di ogni classe, cosa significano questi commenti e cosa ci si aspetta di trovare in ogni sezione. Le procedure guidate di Visual Studio usano convenzioni simili per le classi create automaticamente e probabilmente queste convenzioni sono utili per il proprio codice.
Si potrebbe avere familiarità con le publicparole chiave , protectede private C++. Nei file di intestazione MFC si noterà che ogni classe può avere diverse di esse. Ad esempio, le variabili e le funzioni membro pubblico potrebbero trovarsi in più di una public parola chiave. Poiché MFC separa le variabili membro e le funzioni in base al loro uso, non in base al tipo di accesso consentito. MFC usa private con moderazione. Anche gli elementi considerati dettagli di implementazione sono spesso protectede molte volte sono public. Sebbene l'accesso ai dettagli di implementazione sia sconsigliato, MFC affida la decisione allo sviluppatore.
Nei file di origine MFC e nei file di intestazione creati dalla Creazione guidata applicazione MFC sono disponibili commenti come questi all'interno delle dichiarazioni di classe (in genere in questo ordine):
// Constructors
// Attributes
// Operations
// Overridables
// Implementation
Esempio dei commenti
L'elenco parziale seguente della classe CStdioFile usa la maggior parte dei commenti standard usati da MFC nelle relative classi per dividere i membri della classe in base ai modi in cui vengono usati:
/*============================================================================*/
// STDIO file implementation
class CStdioFile : public CFile
{
DECLARE_DYNAMIC(CStdioFile)
public:
// Constructors
CStdioFile();
// . . .
// Attributes
FILE* m_pStream; // stdio FILE
// m_hFile from base class is _fileno(m_pStream)
// Operations
// reading and writing strings
virtual void WriteString(LPCTSTR lpsz);
virtual LPTSTR ReadString(_Out_writes_z_(nMax) LPTSTR lpsz, _In_ UINT nMax);
virtual BOOL ReadString(CString& rString);
// Implementation
public:
virtual ~CStdioFile();
#ifdef _DEBUG
void Dump(CDumpContext& dc) const;
#endif
virtual ULONGLONG GetPosition() const;
virtual ULONGLONG GetLength() const;
virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError = NULL);
// . . .
protected:
void CommonBaseInit(FILE* pOpenStream, CAtlTransactionManager* pTM);
void CommonInit(LPCTSTR lpszFileName, UINT nOpenFlags, CAtlTransactionManager* pTM);
};
Questi commenti contrassegnano in modo coerente le sezioni della dichiarazione di classe che contengono tipi simili di membri della classe. Tenere presente che si tratta di convenzioni MFC, non di impostare regole.
Commento costruttori
La // Constructors sezione di una dichiarazione di classe MFC dichiara costruttori (nel senso C++) ed eventuali funzioni di inizializzazione necessarie per usare effettivamente l'oggetto. Ad esempio, CWnd::Create si trova nella sezione costruttori perché prima di usare l'oggetto CWnd , deve essere "completamente costruito" chiamando prima il costruttore C++ e quindi chiamando la Create funzione. In genere, questi membri sono pubblici.
Ad esempio, la classe CStdioFile ha cinque costruttori, uno dei quali viene visualizzato nell'elenco in Un esempio dei commenti.
Commento attributi
La // Attributes sezione di una dichiarazione di classe MFC contiene gli attributi pubblici (o le proprietà) dell'oggetto . In genere gli attributi sono variabili membro o funzioni Get/Set. Le funzioni "Get" e "Set" possono essere virtuali o meno. Le funzioni "Get" sono spesso const, perché nella maggior parte dei casi non hanno effetti collaterali. Questi membri sono normalmente pubblici. Gli attributi protetti e privati sono in genere disponibili nella sezione relativa all'implementazione.
Nell'elenco di esempio della classe , in Un esempio dei commenti, l'elenco include una variabile membro m_pStream.CStdioFile La classe CDC elenca quasi 20 membri sotto questo commento.
Nota
Le classi di grandi dimensioni, ad esempio CDC e CWnd, possono avere così tanti membri che elencano semplicemente tutti gli attributi in un unico gruppo non aggiungerebbero molto per chiarezza. In questi casi, la libreria di classi usa altri commenti come intestazioni per delineare ulteriormente i membri. Ad esempio, CDC usa // Device-Context Functions, // Drawing Tool Functions, // Drawing Attribute Functionse altro ancora. I gruppi che rappresentano gli attributi seguiranno la sintassi consueta descritta in precedenza. Molte classi OLE hanno una sezione di implementazione denominata // Interface Maps.
Commento operazioni
La // Operations sezione di una dichiarazione di classe MFC contiene funzioni membro che è possibile chiamare sull'oggetto per eseguire operazioni o eseguire azioni (eseguire operazioni). Queste funzioni sono in genere non-const perché in genere hanno effetti collaterali. Possono essere virtuali o non virtuali a seconda delle esigenze della classe. In genere, questi membri sono pubblici.
Nell'elenco di esempio della classe , in Un esempio dei commenti, l'elenco include tre funzioni membro in questo commento: WriteString e due overload di ReadString.CStdioFile
Come per gli attributi, le operazioni possono essere ulteriormente suddivise.
Commento sostituibile
La // Overridables sezione di una dichiarazione di classe MFC contiene funzioni virtuali di cui è possibile eseguire l'override in una classe derivata quando è necessario modificare il comportamento della classe di base. Vengono in genere denominati a partire da "On", anche se non è strettamente necessario. Le funzioni sono progettate per essere sottoposte a override e spesso implementano o forniscono una sorta di "callback" o "hook". In genere, questi membri sono protetti.
In MFC stesso, le funzioni virtuali pure vengono sempre inserite in questa sezione. Una funzione virtuale pura in C++ ha il formato seguente:
virtual void OnDraw( ) = 0;
Nell'elenco di esempio della classe CStdioFile, in Un esempio dei commenti, l'elenco non include alcuna sezione sottoponibile a override. La classe CDocument, d'altra parte, elenca circa 10 funzioni membro sostituibili.
In alcune classi è anche possibile visualizzare il commento // Advanced Overridables. Queste funzioni sono quelle che solo i programmatori avanzati devono tentare di eseguire l'override. Probabilmente non dovrai mai eseguirne l'override.
Nota
Le convenzioni descritte in questo articolo funzionano anche bene, in generale, per i metodi e le proprietà di automazione (in precedenza noti come automazione OLE). I metodi di automazione sono simili alle operazioni MFC. Le proprietà di automazione sono simili agli attributi MFC. Gli eventi di automazione (supportati per i controlli ActiveX, in precedenza noti come controlli OLE) sono simili alle funzioni membro sottoponibili a override MFC.
Commento di implementazione
La // Implementation sezione è la parte più importante di qualsiasi dichiarazione di classe MFC.
Questa sezione contiene tutti i dettagli di implementazione. Entrambe le variabili membro e le funzioni membro possono essere visualizzate in questa sezione. Tutto sotto questa riga potrebbe cambiare in una versione futura di MFC. A meno che non sia possibile evitarlo, non è consigliabile basarsi sui dettagli sotto la // Implementation riga. Inoltre, i membri dichiarati sotto la riga di implementazione non sono documentati, anche se alcune implementazioni sono illustrate nelle note tecniche. Le sostituzioni delle funzioni virtuali nella classe base risiedono in questa sezione, indipendentemente dalla sezione in cui è definita la funzione della classe di base. Quando una funzione esegue l'override dell'implementazione della classe di base, viene considerata un dettaglio di implementazione. In genere, questi membri sono protetti, ma non sempre.
Nell'elenco CStdioFile in Un esempio dei commenti, i membri dichiarati sotto il // Implementation commento possono essere dichiarati come public, protectedo private. Usare questi membri con cautela, perché potrebbero cambiare in futuro. Dichiarando un gruppo di membri public , potrebbe essere necessario per il corretto funzionamento dell'implementazione della libreria di classi. Tuttavia, non significa che è possibile usare in modo sicuro i membri così dichiarati.
Nota
È possibile trovare commenti dei tipi rimanenti sopra o sotto il // Implementation commento. In entrambi i casi, descrivono i tipi di membri dichiarati di seguito. Se si verificano sotto il // Implementation commento, è consigliabile presupporre che i membri possano cambiare nelle versioni future di MFC.