static const dans une classe

Bonjour à tous,

J'ai la classe suivante qui permet de manipuler des coordonnees :

1. #ifndef COORDINATES_H
2. #define COORDINATES_H
3. 
   
4. #include <ostream>
5.     using std::ostream;
6. 
   
7. /**
8.  * Classe Coordinates.
9.  * Classe permettant de gerer des coordonnees.
10.  */
11. class Coordinates
12. {
13. private:
14.     /** @var abscisse */
15.     int x;
16.     /** @var ordonnee */
17.     int y;
18. 
    
19. public:   
20.     /** @var coordonnees au dessus */
21.     static const Coordinates up(0,1);
22.     /** @var coordonnees en dessous */
23.     static const Coordinates down(0,-1);
24.     /** @var coordonnees a droite */
25.     static const Coordinates right(1,0);
26.     /** @var coordonnees a gauche */
27.     static const Coordinates left(-1,0);
28.    
29.     /** @var coordonnees au dessus a droite */
30.     static const Coordinates up_right(up+right);
31.     /** @var coordonnees au dessus a gauche */
32.     static const Coordinates up_left(up+left);
33.     /** @var coordonnees en dessous a droite */
34.     static const Coordinates down_right(down+right);
35.     /** @var coordonnees en dessous a gauche */
36.     static const Coordinates down_left(down+left);
37. 
    
38.     /** @var tableau contenant les 8 directions */
39.     static const Coordinates directions[8]={up, up_right, right, down_right, down, down_left, left, up_left};
40. 
    
41.     /**
42.      * Constructeur.
43.      * @param x_ abscisse
44.      * @param y_ ordonnee
45.      */
46.     Coordinates(int x_, int y_);
47.     /**
48.      * Constructeur de copie.
49.      * @param rCoordinates reference sur l'objet Coordinates a copier
50.      */
51.     Coordinates(const Coordinates & rCoordinates);
52.     /**
53.      * Destructeur.
54.      */
55.     ~Coordinates();
56.     /**
57.      * Accesseur pour x.
58.      * @return abscisse
59.      */
60.     int getX();
61.     /**
62.      * Accesseur pour y.
63.      * @return ordonnee
64.      */
65.     int getY();
66.     /**
67.      * Mutateur pour x.
68.      * @param x_ nouvelle abscisse
69.      */
70.     void setX(int x_);
71.     /**
72.      * Mutateur pour y.
73.      * @param y_ nouvelle ordonnee
74.      */
75.     void setY(int y_);
76.     /**
77.      * Mutateur pour x et y.
78.      * @param x_ nouvelle abscisse
79.      * @param y_ nouvelle ordonnee
80.      */
81.     void setXY(int x_, int y_);
82.     /**
83.      * Surcharge de l'operateur d'affectation.
84.      * @param rCoordinates reference sur les coordonnees a copier.
85.      * @return reference sur la copie.
86.      */
87.     Coordinates& operator=(const Coordinates& rCoordinates);
88.     /**
89.      * Surcharge de l'operateur addition.
90.      * @param rCoordinates reference sur les coordonnees a additionner avec les coordonnees courantes.
91.      * @return addition des coordonnees.
92.      */
93.     Coordinates operator+(const Coordinates& rCoordinates) const;
94.     /**
95.      * Surcharge de l'operateur addition puis affectation.
96.      * @param rCoordinates reference sur les coordonnees a ajouter aux coordonnees courantes.
97.      * @return somme des coordonnees.
98.      */
99.     Coordinates& operator+=(const Coordinates& rCoordinates);
100.     /**
101.      * Surcharge de l'operateur addition puis affectation.
102.      * @param rCoordinates reference sur les coordonnees a comparer aux coordonnees courantes.
103.      * @return true si les coordonnees sont identiques, sinon false
104.      */
105.     bool operator==(const Coordinates& rCoordinates) const;
106.     /**
107.      * Surcharge de l'operateur addition puis affectation.
108.      * @param rCoordinates reference sur les coordonnees a comparer aux coordonnees courantes.
109.      * @return true si les coordonnees sont differentes, sinon false
110.      */
111.     bool operator!=(const Coordinates& rCoordinates) const;
112.     /**
113.      * Surcharge de l'operateur <<.
114.      * @return flux sortant contenant les coordonnees.
115.      */
116.     friend ostream& operator<<(ostream& out, const Coordinates& rCoordinates);
117. };
118. 
     
119. ostream& operator<<(ostream& out,const Coordinates& rCoordinates);
120. 
     
121. #endif

Mais lorsque je compile :

Coordinates.h:21: erreur: expected identifier before numeric constant
Coordinates.h:21: erreur: expected «," or «..." before numeric constant
Coordinates.h:23: erreur: expected identifier before numeric constant
Coordinates.h:23: erreur: expected «," or «..." before numeric constant
Coordinates.h:25: erreur: expected identifier before numeric constant
Coordinates.h:25: erreur: expected «," or «..." before numeric constant
Coordinates.h:27: erreur: expected identifier before «-" token
Coordinates.h:27: erreur: expected «," or «..." before «-" token
Coordinates.h:30: erreur: «up" is not a type
Coordinates.h:30: erreur: expected «," or «..." before «+" token
Coordinates.h:32: erreur: «up" is not a type
Coordinates.h:32: erreur: expected «," or «..." before «+" token
Coordinates.h:34: erreur: «down" is not a type
Coordinates.h:34: erreur: expected «," or «..." before «+" token
Coordinates.h:36: erreur: «down" is not a type
Coordinates.h:36: erreur: expected «," or «..." before «+" token
Coordinates.h:39: erreur: a brace-enclosed initializer is not allowed here before «{" token
Coordinates.h:39: erreur: invalid in-class initialization of static data member of non-integral type «const Coordinates [8]"

Je voudrais utiliser up/down/right... de la manière suivante par exemple :
position += Coordonnees::up;

En mettant mon bloc de "static const" (lignes 20->39) après ma classe (ligne 120), ça compile mais up/down/right... ne font plus parti du namespace Coordonnees. Je peux donc les utiliser comme ça :
position += up;
mais je trouve que c'est beaucoup moins clair.

Est-ce quelqu'un aurait une solution ?

Merci d'avance.

Salut,

la raison pour laquelle le programme ne compile pas c'est que tu essaies de definir un bloc de memoire ayant les proprietes du'une classe avant meme que cettte classe ne soit creee. Par contre en utilisant un pointeur, ca passera.Exemple:

fichier .hpp
class Test
{
    public:
       Test();
       virtual~ Test();

    static const Test *m_staticTest;
    static long m_ref;
}
fichier .cpp
#include "Test.hpp"

const Test* Test::m_staticTest = new Test;
long Test::m_ref = 0;

Test::Test()
{
    ++m_ref;
}
Test::~Test()
{
    if(!--m_ref) delete m_staticTest;
}

J'espere avoir aide, Salut et Bonne annee 2008
je suis heureux de faire partie d'une grande famille ...!

nickydaquick
Non, le pointeur n'est pas nécessaire. Le meme static déclarer de facon statique ne pose aucun problème ici. Le seul pb est qu'il initialise le membre static lors de sa déclaration.

C'est exactement ce que je voulais, merci.
Je savais pas (ou j'avais oublié) que l'on ne pouvait pas initialiser un membre static lors de la déclaration.