Salut.
Merci pour ta réponse.
Par contre, ton compilateur te renvoie des messages un peu plus cohérent.
Ce que je voulais faire est historique. Je voulais créer une classe eau, qui permet de calculer les propriétes physique de l'eau. Le calcul ce fait sur plusieurs fonctions différentes, et avec des variables qui passent de l'une à l'autre. Bref, j'ai essayer, j'ai planter et je me suis démerder.
Et maintenant, je me disait que mon problème aurai pu être résolue grace à "static"... Donc, mon but est de regarder comment utilisé ce mot clé, et notament de faire un tableau de double en static.
Ce qui ne semble pas fonctionner.
Les instructions :
(a*eau::b[0]);
et
eau::b[0];
Sont là pour réaliser un appel à eau::b[0], pour voir si ça fonctionne : si j'ai bien compris le livre, lorsque tu tape "1+3+8*9+6;" le calcul est bien effectué, mais comme il n'est pas assigné à une variable ou afficher, c'est COMME SI tu ne fesait rien. Salutation !
Char Snipeur

Bon je pense que tu n'as pas bien compris à quoi servait le mot clé static. Alors pour static il y a deux utilisations :
1) pour des membres de classes (variables)
2) pour des méthodes

1) Pour les membres de classe :

Il s'agit d'un membre partagé en commun par toutes les instances de cette classe. C'est à dire que si tu la modifies dans un objet de cette classe ça va la corriger dans tous les autres objets de ce type. C'est une sorte de variable globale dont la portée est limitée à la classe.

Exemple d'utilisation : compter le nombre d'instance de classe :

#include <iostream>

class plop{
protected:
  static unsigned int nb_instance_plop=0;
  int x;
public;
  plop(int x0):x(x0){
    ++nb_instance_plop;
    std::cout << nb_instance_plop << "eme instance 'plop'" << std::endl
  }
};

int main(){
  plop p1(10);
  plop p2(6);
  plop p3(9);
  return 0;
}

#include <iostream>

class plop(){
  protected:
  unsigned int x;
  public:
  plop(unsigned int x0):x(x0){}
  static inline void nom_classe(){
    std::cout << "plop" << std::endl;
  }
};

int main(){
  plop p1(69);
  plop::nom_classe();
  return 0;
}

Salut.
Merci pour ta réponse, j'avai bien compris l'utilisation de static. Le seul problème c'est que je me heurte à des problèmes pratique de compilation.
Mais après divers tests, j'ai trouvé la règle:
Il est possible d'inialisé une variable static dans la class SI elle est const.
Si elle n'est pas const ou que c'est un tableau, alors il faut le faire en dehors de la class.

struct eau
    {
    static const double a=12;
    static double e;
    static const double b[3];//={0,1,2};
    static double P2TD(double T,double D)
        {double c;
        c=b[0];
        c=(a*eau::b[0]);
        return c;}
    };
static double abc=125;
int main()
    {
    double a=eau::e;
    double P=eau::P2TD(325,456);
    double tab[3]={0,1,2};
    tab[0]=eau::b[0];
    return 0;
    }
double eau::e=3;
const double eau::b[3]={0,1,2};

struct eau
    {
    static double a=0;
    }

ISO C++     forbids in-class initialization of non-const static member `nb_instance_plop'

Tu as raison je me suis trompée, dans ce cas précis la variable static est en fait interne à la fonction (ou doit rester const) :

#include <iostream>

class plop{
  protected:
  unsigned int x;
  public:
  plop(unsigned int x0):x(x0){
      static unsigned int nb_instance_plop = 0;
      ++nb_instance_plop;
      std::cout << nb_instance_plop << "eme instance 'plop'" << std::endl;
  }
  static inline void nom_classe(){
    std::cout << "plop" << std::endl;
  }
};

int main(){
  plop p1(69);
  plop p2(28);
  plop p3(47);
  plop::nom_classe();
  return 0;
}

#include <iostream>
namespace eau{
    unsigned int a = 56;
}

int main(){
  std::cout << a::eau << std::endl;
  return 0;
}

Il est possible d'initialiser un membre const static SI il est de type int !

static const int i = 0; //Fonctionne
static const double d = 0.0;//Fonctionne pas

http://c.developpez.com/faq/cpp/?page=static#CLASS_static_co­nst