Discussion :

[sniperseb]

Bonjour, voici un petit problème d'insertion de struct :

Je déclare dans une class.h ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

POINT3D A,B,C,D,E,F,G,H;

Jé déclare ma structure dans un autre fichier qui est include dans ma classe/

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
struct POINT3D
{ 
	 double X;
	 double Y;
	 double Z;
};

Le problème est pour initialiser mes valeurs, pour le moment je suis obliger de faire ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
void Cube::SetPOINT3D(POINT3D ptA,double distance)
 
A = ptA;
B.X = ptA.X+distance;
B.Y = ptA.Y;
B.Z = ptA.Z;
C.X = ptA.X;
C.Y = ptA.Y +distance;
C.Z = ptA.Z;

Je voudrais faire du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
A= ptA;
B = new POINT3D (ptA.X+distance,ptA.Y,ptA.Z);
C= new POINT3D(ptA.X,ptA.Y+distance,ptA.Z);

Mais ceci ne marche pas, donc si quelqu'un pourrait m'aider.

Merci d'avance

[Gruik]

Salut,

Tu t'es trompé de forum ,)

[zooro]

Salut,
Comme l'a dit Gruik, ici, c'est le forum C. Utilises plutôt le forum C++.
Celà dit, j'ai du mal à saisir l'intérêt du mélange des structures et classes... Pour résoudre ton problème, il suffirait d'utiliser une classe POINT3D au lieu d'une structure.

[sniperseb]

ben je voudrais utiliser une structure car sinon jaurai trop de classes :s .

Ben c'est un probleme de struct et non un problème de classe. Mais j'ai juste dit que la déclaration des structures sont fait sur une classe. Mais le problème est pur C .

[Thierry Chappuis]

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void Cube::SetPOINT3D(POINT3D ptA,double distance)

Tu appelles ça du pur C? Je ne comprends pas bien ta remarque "je voudrais utiliser une structure car sinon jaurai trop de classes"... Si tu programmes en C++, utilise plutôt des classes. Pourrais-tu préciser ton problème? Si tu désires programmer en C, il faudra reprendre tout ça depuis le début.

Thierry

[koala01]

Salut,

Bon, bien que tu te sois trompé de forum...

ben je voudrais utiliser une structure car sinon jaurai trop de classes :s .

Ca, c'est typiquement le genre d'argument qui ne tient pas la route...

Il n'y a qu'une différence de visibilité entre une classe et une structure en C++...

Par défaut, la visibilité des membres et des fonctions est privée dans une classe et publique dans une structure... mais sinon, tu peux très bien envisager une classe dans le genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
//exemple d'une classe n'ayant que des membres publiques 
class Maclass
{
     public:
          double x;
          double y;
          double z;
          maclass(double, double, double);
          ~maclass();
};

ou une structure héritant d'une classe de manière privée

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
// une structure qui hérite de Maclass de manière privée
struct Mastruct: private Maclass
{
    // il faudra un constructeur, vu que x, y et z sont prives
    Mastruct(double x, double y, double z):Maclass(x, y, z){}
    // et un destructeur, meme s'il ne fait rien dans l'exemple 
    ~Mastruct(){}
    //il faut peut etre des assesseurs
    double GetX(){return x;}
    double GetY(){return y;}
    double GetZ(){return z;}
};

qui, comme tu le remarque, peut également contenir des méthodes

Enfin, une struct peut très bien hériter d'une classe et inversément...

Ceci dit, je ne vois que très peu l'utilité de déclarer six points "hors de tout"...

tu aurais largement intéret à déclarer correctement ton cube, dans le genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
class CUBE
{
    public: 
    // prévoyons plusieurs moyens de le créer:
        CUBE(const point& p1, const point& p2, 
             const point& p3, const point& p4, 
             const point& p5, const point& p6
             const point& p7, const point& p8)
        {
            //on le cache à l'utilisateur de la classe, mais c'est simplement
           // un vecteur de points
           Points.push_back(p1);
           Points.push_back(p2);
           Points.push_back(p3);
           Points.push_back(p4);
           Points.push_back(p5);
           Points.push_back(p6);
           Points.push_back(p7);
           Points.push_back(p8);
        }
    // l'utilisateur peut donner un vecteur de points
        CUBE(const std::vector<point>& points):Point(points)
        { assert(Point.size()==8);}
    // ou peut etre prévois tu que l'utilisateur de la classe veuille
    // passer une std::list de points ?
        CUBE(const std::list<point>& points)
        {
             for(std::list<point>iterator it= point.begin(); 
                   it!=point.end();it++)
                 Points.push_back((*it));
             assert(Points.size()==8);
             //je crois, mais je suis pris d'un doute, qu'il y aurait moyen
             // de faire Points=points;
        }
    // voire meme un tableau "à la C"
        CUBE(point* points)
        {
             for(unsigned int i=0;i<8;i++)
                 Points.push_back(points[i]);
        }
    // ou, enfin, un cube existant
        CUBE(const CUBE& ref)
        {
              Points.clear();
              Points=ref.Points;
        }
    // on n'oublie pas le destructeur
        ~CUBE()
        {Points.clear();}
    // et sans doutes les assesseurs
    const Point& GetFrontUpLeft() const {return Points[0];}
    const Point& GetFrontUpRight() const {return Points[1];}
    const Point& GetFrontDownLeft() const {return Points[2];}
    const Point& GetFrontDownRight() const {return Points[3];}
    const Point& GetRearUpLeft() const {return Points[4];}
    const Point& GetReartUpRight() const {return Points[5];}
    const Point& GetRearDownLeft() const {return Points[6];}
    const Point& GetRearDownRight() const {return Points[7];}
    private:
        std::vector<point> Points;
}

désolé, mais j'avais la flegme de séparer l'implémentation et de la déclaration