class MaClasse 
{ 
    // Déclaration de toutes les variables ou fonctions membres
    // constitutives de la classe

    int a; // variable membre
    void b(); // fonction membre
};

#ifndef MACLASSE_H
#define MACLASSE_H

class MaClasse
{
public:
    void Fonction();
};

#endif

#include "maclasse.h"

void MaClasse::Fonction()
{
    // implémentation de la fonction
}

#include "autreclasse.h"
#include "maclasse.h"

void AutreClasse::Fonction()
{
    MaClasse M;
    M.Fonction();
}

#ifndef MACLASSE_H
#define MACLASSE_H

class MaClasse
{
public:
    void FonctionInline()
    {
        // placée dans la déclaration de la classe
        // cette fonction est considérée en ligne sans
        // que le mot clé inline ne figure
    }
};

// placée en dehors de la déclaration de la classe, le mot clé inline
// est indispensable pour ne pas provoquer des définitions multiples
// de la fonction et donc des erreurs à l'édition de liens
inline void FonctionInline2()
{
}
#endif

class mere
{
// ...
} 

class fille : public mere
{
// ...
} 
 

template<class T>
class stBuffer
{
	...
	T* Lock(...);
};
 
template< typename T >
class stD3D9Buffer : public stBuffer<T>
{
};
 
class stD3DVertexBuffer : public stD3D9Buffer<vertex>
{
};

// fichier Singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

class Singleton 
{ 
public : 
    // Fonction permettant de récupérer l'instance unique de notre classe 
    static Singleton & GetInstance();

private :
    // On empêche la création directe d'objets Singleton en mettant son constructeur par défaut privé
    // Ainsi on oblige l'utilisateur à passer par GetInstance
    Singleton() {} 

    // On empêche la recopie d'objets Singleton en mettant le constructeur par copie
    // et l'opérateur d'affectation en privé
    // On peut même ne pas les implémenter, c'est encore mieux
    Singleton( const Singleton & ); 
    Singleton & operator =( const Singleton & ); 
}; 

#endif

// fichier Singleton.cpp
#include "Singleton.h"

Singleton & Singleton::GetInstance()
{
    static Singleton instance; // instance unique cachée dans la fonction. Ne pas oublier le static !
    return instance;
}

// exemple d'utilisation
#include "Singleton.h"

int main() 
{ 
    // Essai : on tente de créer un Singleton 
    Singleton erreur; // Ne compile pas - le constructeur par défaut n'est pas accessible 

    // Récupération de l'instance unique de la classe 
    Singleton & s = Singleton::GetInstance(); 
}

class A
{
public :

    int x;

protected :

    int y;
    
private :

    int z;
};

class B : private A
{
    // x et y sont ici en accès privé, et z est innaccessible
}

struct A
{
    int a;
    
private :

    int b;
};

class B
{
    int b;
    
public :

    int a;
};

// Ici, A et B sont équivalents

class Base {}; // class ou struct, peu importe

class A1 : public Base
{
};

struct A2 : Base
{
};

class B1 : Base
{
};

struct B2 : private Base
{
}; 

// Ici, A1 et A2 sont équivalents, ainsi que B1 et B2

// OK
template <class T>
struct A
{
};

// ERREUR
template <struct T>
class B
{
};

struct A; // déclaration anticipée en tant que struct

A * Exemple();

class A // déclaration en tant que class
{
};

A * Exemple()
{
    return new A;
}

class B; 

class A 
{ 
    B* PtrB; 
}; 

#include "A.h" 
#include "B.h" 

// ...

#include "A.h" 

class B 
{ 
    A a; 
};

#include "B.h" 

// ...

cout << x << y ;
 

cout << x 
 

// Définition de notre classe de base 
struct Base
{ 
    virtual ~Base() {}
    virtual Base* Clone() const = 0;
};

// Une classe dérivée de Base
struct Derivee1 : public Base
{
    virtual Base* Clone() const
    {
         return new Derivee1(*this);
    }
};

// Une autre classe dérivée de Base
struct Derivee2 : public Base
{
    virtual Base* Clone() const
    {
         return new Derivee2(*this);
    }
};

// Utilisation 
Base* Obj1 = new Derivee1;
Base* Obj2 = new Derivee2;

Base* Copy1 = Obj1->Clone(); // Copy1 pointe sur un objet de type Derivee1
Base* Copy2 = Obj2->Clone(); // Copy2 pointe sur un objet de type Derivee2

delete Obj1;
delete Obj2;
delete Copy1;
delete Copy2;

struct Derivee1 : public Base
{
    virtual Derivee1* Clone() const
    {
         return new Derivee1(*this);
    }
};

class Bienvenue // classe abstraite
{
public:
    // le "= 0" à la fin indique que c'est
    // une fonction virtuelle pure
    virtual void Message() = 0;
};

class BienvenueEnFrancais : public Bienvenue
{
public:
    void Message()
    {
        std::cout << "Bienvenue!\n";
    }
};

class BienvenueEnAnglais : public Bienvenue
{
public:
    void Message()
    {
        std::cout << "Welcome!\n";
    }
};