Une classe peut définir des éléments dit statiques.

Les éléments pouvant être définis comme étant statiques sont :

• les fonctions membres ou les méthodes,
• les champs.

Ces éléments sont appelés membres statiques ou membres de classes du fait qu'ils sont accessibles sans qu'il soit nécessaire de construire l'objet. Ainsi la méthode execute() définie comme statique dans la classe A pourra être appelée sans qu'il soit nécessaire de créer un objet de type A mais simplement en faisant référence à la classe par un appel de type A::execute(). De même, le champ const double Pi = 3.14 défini comme statique dans la classe B pourrait être accéder en faisant référence non pas à une instance de l'objet mais simplement en faisant référence au nome de la classe A, soit A::Pi.

D'une certaine manière, les autres membres de la classe que sont :

• les déclarations de types,
• la définition d'alias de types,

sont par essence liés à la classe et non pas à l'instance de l'objet. D'une certaine manière, ces éléments sont déjà statiques par construction.

Une méthode (ou fonction membre) statique (aussi appelée méthode de classe) est une méthode définie au sein de la classe et préfixée par le mot clé static.

class Complex
{
private:
    double m_real;
    double m_imaginary;
public:
    Complex(double theRealPart, double theImaginaryPart):
        m_real(theRealPart), m_imaginary(theImaginaryPart)
    {}
    static Complex createFromPolar(double rho, double theta)
    {
       return Complex(rho*cos(theta), rho*sin(theta);
    }
};
 
int main()
{
    Complex complex = Complex::createFromPolar(1.41, O.785); 
        // Create a complex number from its polar coordinate.        
}

La méthode createFromPolar est appellée non pas en passant une référence à une objet mais simplement en la préfixant par le nom de la classe Complex::. Cette méthode ne reçoit aucune référence à l'instance de l'objet. De ce fait, le pointeur ''this'' n'est pas accesible et il n'est pas non plus possible d'appeller d'autres méthodes que les méthodes statiques et d'accéder à d'autres champs qu'aux champs statiques.

Un champ statique est un champ qui est associé non pas à l'objet instance de la classe mais à la classe elle-même. Ceci signifie que le champ n'est alloué qu'une seule fois et ce pour toutes les instances de la classe.

Le champ statique est déclaré comme un champ habituel d'une classe à la différence que la déclaration doit être précédée par le mot-clé static.

#include<random>
 
class RandomGeneratorBase
{
private:
    static std::random_device m_seed;
    static std::mt19937 m_generator;
 
public:    
    static UniformGenerator getUniform(int theMinValue, int theMaxValue)
    {
        return UniformGenerator(theMinValue, theMaxValue);
    }
    static PoissonGenerator getPoisson(double theMean)
    {
        return PoissonGenerator(theMean);
    }
};
 
RandomGeneratorBase::m_seed;
RandomGeneratorBase::m_generator(m_seed());
 
class UniformGenerator: public RandomGeneratorBase
{
private:
    sdt::uniform_int_distribution<> m_distribution;
public:
    UniformGenerator(int theMinValue, int theMaxValue):
        m_distribution(theMinValue, theMaxValue)
    {}
    int get()
    {
        return m_distribution(m_generator);
    }
};
 
class PoissonGenerator: public RandomGeneratorBase
{
private:
    sdt::poisson_distribution<> m_distribution;
public:
    PoissonGenerator(double theMean):
        m_distribution(theMean)
    {}
    int get()
    {
        return m_distribution(m_generator);
    }
};