class MaClasse
{
    static int x = 0; // erreur : pas constant
    const int y = 5; // erreur : pas statique
    static const float z = 4.2f; // erreur : pas entier
};

class MaClasse
{
    enum {MAX = 10};
};

// dans le fichier Exemple.h
#ifndef EXEMPLE_H
#define EXEMPLE_H

class Exemple
{ 
public: 
    static int compteur; 
}; 

#endif 

// dans le fichier Exemple.cpp
#include "Exemple.h" 

int Exemple::compteur = 0;

Exemple::Exemple() :
compteur(5) // ERREUR
{

}

class Fred {
    public:
        ...
    private:
        static int j_;   // Déclare la donnée membre static Fred::j_
        ...
 };

#include "Fred.h"
 
int Fred::j_ = some_expression_evaluating_to_an_int;
 
// A côté de ça, si vous souhaitez utiliser la valeur implicite des entiers static :
// int Fred::j_;

#include "Fred.hpp"

Fred x;

#include "Barney.hpp"

Barney y;

#include "Barney.hpp"

Barney::Barney()
{
    // ...
    x.goBowling();
    // ...
}

#include "Fred.hpp"

Fred& x()
{
    static Fred* ans = new Fred();
    return *ans;
}

#include "Barney.hpp"

Barney::Barney()
{
    // ...
    x().goBowling();
    // ...
}

 #include "Fred.hpp"
 
 Fred& x()
 {
   static Fred ans;  // was static Fred* ans = new Fred();
   return ans;       // was return *ans;
 }

static Fred* ans = new Fred();

static Fred ans;

class X {
    public:
        ...
 
    private:
        static Fred x_;
};

#include "X.hpp"
 
Fred X::x_;

void X::someMethod()
{
    x_.goBowling();
}

class X {
    public:
        ...
 
    private:
        static Fred& x();
};

#include "X.hpp"
 
Fred& X::x()
{
    static Fred* ans = new Fred();
    return *ans;
}

void X::someMethod()
{
    x().goBowling();
}

void X::someMethod()
{
    static Fred& x = X::x();
    x.goBowling();
}

#include <iostream>
 
int f();  // forward declaration
int g();  // forward declaration
 
int x = f();
int y = g();
 
int f()
{
   std::cout << "using 'y' (which is " << y << ")\n";
   return 3*y + 7;
}
 
int g()
{
   std::cout << "initializing 'y'\n";
   return 5;
}

#include <iostream>
 
int f();  // forward declaration
int g();  // forward declaration
 
int& x()
{
   static int ans = f();
   return ans;
}
 
int& y()
{
   static int ans = g();
   return ans;
}
 
int f()
{
   std::cout << "using 'y' (which is " << y() << ")\n";
   return 3*y() + 7;
}
 
int g()
{
   std::cout << "initializing 'y'\n";
   return 5;
}

#include <iostream>
 
int& y();  // forward declaration
 
int& x()
{
   static int ans;
 
   static bool firstTime = true;
   if (firstTime) {
     firstTime = false;
     std::cout << "using 'y' (which is " << y() << ")\n";
     ans = 3*y() + 7;
   }
 
   return ans;
}
 
int& y()
{
   static int ans;
 
   static bool firstTime = true;
   if (firstTime) {
     firstTime = false;
     std::cout << "initializing 'y'\n";
     ans = 5;
   }
 
   return ans;
}

int& y();  // forward declaration
 
int& x()
{
   static int ans = 3*y() + 7;
   return ans;
}
 
int& y()
{
   static int ans = 5;
   return ans;
}