Utilisation des fichiers sources MFC

La bibliothèque MFC (Microsoft Foundation Class) fournit du code source complet. Les fichiers d’en-tête (.h) se trouvent dans le répertoire \atlmfc\include . Les fichiers d’implémentation (.cpp) se trouvent dans le répertoire \atlmfc\src\mfc .

Cet article explique les conventions que MFC utilise pour commenter les différentes parties de chaque classe, ce que ces commentaires signifient et ce que vous devez vous attendre à trouver dans chaque section. Les Assistants Visual Studio utilisent des conventions similaires pour les classes qu’ils créent pour vous, et vous trouverez probablement ces conventions utiles pour votre propre code.

Vous connaissez peut-être les publicprotectedmot clé , C++ et private C++. Dans les fichiers d’en-tête MFC, vous trouverez que chaque classe peut avoir plusieurs d’entre elles. Par exemple, les variables et fonctions membres publiques peuvent se trouver sous plusieurs public mot clé. C’est parce que MFC sépare les variables membres et les fonctions en fonction de leur utilisation, et non par le type d’accès autorisé. MFC utilise private avec parcimonie. Même les éléments considérés comme les détails de l’implémentation sont souvent protected, et plusieurs fois sont public. Bien que l’accès aux détails de l’implémentation soit déconseillé, MFC vous laisse la décision.

Dans les fichiers sources MFC et les fichiers d’en-tête créés par l’Assistant Application MFC, vous trouverez des commentaires comme ceux-ci dans les déclarations de classe (généralement dans cet ordre) :

// Constructors

// Attributes

// Operations

// Overridables

// Implementation

Un exemple des commentaires

La liste partielle suivante de classes CStdioFile utilise la plupart des commentaires standard utilisés par MFC dans ses classes pour diviser les membres de classe par les méthodes utilisées :

/*============================================================================*/
// 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);
};

Ces commentaires marquent constamment les sections de la déclaration de classe qui contiennent des types similaires de membres de classe. N’oubliez pas qu’il s’agit de conventions MFC, et non de définir des règles.

Commentaire des constructeurs

La // Constructors section d’une déclaration de classe MFC déclare des constructeurs (au sens C++) et toutes les fonctions d’initialisation requises pour utiliser réellement l’objet. Par exemple, CWnd::Create se trouve dans la section constructeurs, car avant d’utiliser l’objet CWnd , il doit être « entièrement construit » en appelant d’abord le constructeur C++, puis en appelant la Create fonction. En règle générale, ces membres sont publics.

Par exemple, la classe CStdioFile a cinq constructeurs, dont l’un est affiché dans la liste sous Un exemple de commentaires.

Commentaire d’attributs

La // Attributes section d’une déclaration de classe MFC contient les attributs publics (ou propriétés) de l’objet. En règle générale, les attributs sont des variables membres ou des fonctions Get/Set. Les fonctions « Get » et « Set » peuvent ou non être virtuelles. Les fonctions « Get » sont souvent const, car dans la plupart des cas, elles n’ont pas d’effets secondaires. Ces membres sont normalement publics. Les attributs protégés et privés se trouvent généralement dans la section d’implémentation.

Dans l’exemple de liste de la classe CStdioFile, sous Un exemple de commentaires, la liste inclut une variable membre, m_pStream. La classe CDC répertorie près de 20 membres sous ce commentaire.

Commentaire des opérations

La // Operations section d’une déclaration de classe MFC contient des fonctions membres que vous pouvez appeler sur l’objet pour effectuer des actions ou effectuer des actions (effectuer des opérations). Ces fonctions ne sont généralement pas,const car elles ont généralement des effets secondaires. Elles peuvent être virtuelles ou non virtuelles en fonction des besoins de la classe. En règle générale, ces membres sont publics.

Dans l’exemple de liste de classe CStdioFile, dans Un exemple de commentaires, la liste inclut trois fonctions membres sous ce commentaire : WriteString et deux surcharges de ReadString.

Comme pour les attributs, les opérations peuvent être subdivées.

Commentaire substituable

La // Overridables section d’une déclaration de classe MFC contient des fonctions virtuelles que vous pouvez remplacer dans une classe dérivée lorsque vous devez modifier le comportement de la classe de base. Ils sont généralement nommés à partir de « On », bien qu’il ne soit pas strictement nécessaire. Les fonctions ici sont conçues pour être remplacées, et implémentent souvent ou fournissent une sorte de « rappel » ou de « hook ». En règle générale, ces membres sont protégés.

Dans MFC lui-même, les fonctions virtuelles pures sont toujours placées dans cette section. Une fonction virtuelle pure en C++ prend la forme :

virtual void OnDraw( ) = 0;

Dans l’exemple de liste de la classe CStdioFile, dans Un exemple de commentaires, la liste n’inclut aucune section substituable. En revanche, la classe CDocumentrépertorie environ 10 fonctions membres substituables.

Dans certaines classes, vous pouvez également voir le commentaire // Advanced Overridables. Ces fonctions sont celles que seuls les programmeurs avancés doivent tenter de remplacer. Vous n’aurez probablement jamais besoin de les remplacer.

Commentaire d’implémentation

La // Implementation section est la partie la plus importante de toute déclaration de classe MFC.

Cette section contient tous les détails de l’implémentation. Les variables membres et les fonctions membres peuvent apparaître dans cette section. Tout ce qui se trouve en dessous de cette ligne pourrait changer dans une prochaine version de MFC. Sauf si vous ne pouvez pas l’éviter, vous ne devez pas vous appuyer sur les détails sous la // Implementation ligne. En outre, les membres déclarés sous la ligne d’implémentation ne sont pas documentés, bien que certaines implémentations soient abordées dans les notes techniques. Les remplacements de fonctions virtuelles dans la classe de base résident dans cette section, quelle que soit la section dans laquelle la fonction de classe de base est définie. Lorsqu’une fonction remplace l’implémentation de classe de base, elle est considérée comme un détail d’implémentation. En règle générale, ces membres sont protégés, mais pas toujours.

Dans la CStdioFile liste sous Un exemple de commentaires, les membres déclarés sous le // Implementation commentaire peuvent être déclarés en tant que public, protectedou private. Utilisez uniquement ces membres avec prudence, car ils peuvent changer à l’avenir. La déclaration d’un groupe de membres comme public peut être nécessaire pour que l’implémentation de la bibliothèque de classes fonctionne correctement. Toutefois, cela ne signifie pas que vous pouvez utiliser en toute sécurité les membres ainsi déclarés.

Voir aussi

Rubriques MFC générales