[Debutant]Problème Insertion dans une Struct

**sniperseb** · 14/12/2006, 15h41

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** · 14/12/2006, 15h43

Salut,

Tu t'es trompé de forum ,)

**zooro** · 14/12/2006, 16h02

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** · 14/12/2006, 16h22

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** · 14/12/2006, 16h27

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** · 14/12/2006, 17h24

Salut,

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

Envoyé par sniperseb

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

**alskaar** · 14/12/2006, 21h42

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);

repartons du code que tu voudrais :
la premiere ligne implique une construction de ta structure sans initialisation.
les lignes 2 et 3 elles impliquent un constructeur ayant 3 doubles

ce qui te permet d'écrire le code que tu veux

Code :

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

1
2
3
4
5
6
7
8
9
 
struct POINT3D
{
    POINT3D():X(0),Y(0),Z(0){};
	POINT3D(double arg_x,double arg_y, double arg_z):X(arg_x),Y(arg_y),Z(arg_z){};
	 double X;
	 double Y;
	 double Z;
};

sinon je rejoins l'avis de koala, une structure ou une classe est tres similaire
si ce n'est que tu n'as pas de notion de private,protected pour les membres.

**koala01** · 14/12/2006, 22h03

Envoyé par alskaar

<snip>
sinon je rejoins l'avis de koala, une structure ou une classe est tres similaire
si ce n'est que tu n'as pas de notion de private,protected pour les membres.

En C++, tu as aussi la notion de private et de protected sur les structures...

La seule différence à ce niveau, c'est que la visibilité est différente par défaut (AKA si tu ne précise pas la visibilité que tu veux)...

La classe maclass

Code :

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

1
2
3
4
5
6
 
class maclass
{
    int unmembre;
    int unautremembre;
};

aura les membres privés (vu qu'on n'a pas indiqué qu'ils étaient public ou protected)

alors que la meme chose sous la forme de

Code :

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

1
2
3
4
5
struct mastruct
{
    int unmembrestruct;
    int unautremembrestruct;
};

aura des membre public, à défaut d'avoir précisé une autre visibilité

Par contre, la class

Code :

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

1
2
3
4
5
6
class monautreclass
{
    public:
        int unmembre; 
        int unautremembre
};

aura les membres visible de tous (vu qu'ils sont déclarés public)
alors que la strucutre

Code :

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

1
2
3
4
5
6
7
 
struct monautrestruct
{
    private:
        int monmembre;
        int monautremembre;
}

aura des membres dont elle seule a un acces direct (vu que les membres sont déclarés private)

Il existe d'autres différences mineures entre les structures et les classes, mais, voici le peu de différence qui court du point de vue de la visibilité entre les deux...

**loufoque** · 14/12/2006, 22h10

new alloue dynamiquement et retourne un pointeur.
C'est totalement différent de ce que tu avais au début.

**alskaar** · 14/12/2006, 23h42

oki merci koala

j avais jamais utilisé une structure avec le mode private

**sniperseb** · 15/12/2006, 09h34

Déja, je vous remercie chaleureusement pour m'avoir trouver comment faire.

Ensuite, quelques explication s'imposent quand même.

--> Les droits : pour le moment, je ne me prend pas la tête pour le moment

--> Cette structure POINT3D n'est pas utilisé que pour la classe CUBE mais pour beaucoup fichiers ainsi que le main.cpp . Utilisateur peut inséré un point comme paramètre d'entrée. Donc il fait le même fonctionnement qu'un INT.

--> Je ne savais pas qu'on peut mettre des droits dans une struct

(merci koala) mais les droits de restrictions seront appliquées sur les class

Encore une fois, Merci

Signé : ChtitSeb

PS: pour ceux qui pense que c'était du C++,j'en suis désolé, mais je pensais que comme c'était des problèmes sur les struct je pensais que c'était du C.

**koala01** · 15/12/2006, 11h35

Ce qu'il faut bien comprendre, c'est qu'il n'y a rien que tu puisse faire avec une struct que tu ne puisse pas faire avec une classe...

Au contraire, certains compilateurs risquent de rechigner à utiliser une structure en tant que parametre template, là où ils accepteront sans aucun problème de travailler avec une classe...

Rien ne t'empeche non plus de créer une classe Point, utilisée dans les cubes, mais aussi les pyramides, les cercles, les disques, les tores et les étoiles si tu le souhaites, et d'utiliser les points en tant qu'entité propres...

De plus, et c'est un principe à essayer de suivre en programmation orientée objet, il faut autant que faire se peut essayer de faire de manière à ce que le code utilisateur puisse rester identique si tu décides un jour de changer tes trois double séparés en un tableau "à la C" ou en un std::vecto<double> (ou en n'importe quoi d'autre)...

La manière dont tu décide d'implémenter tes coordonnées dois pouvoir être indépendante de la manière dont l'utilisateur (ca peut etre toi, au travèrs d'une autre classe

) va utiliser la classe que tu as créée pour lui...

Imagine, meme pour toi...

Mettons que tu ignores tout de la S(T)L ou que, parce qu'il est vrai que ca fait un sérieux paquet d'informations à assimiler en commençant, tu décide de t'en passer...

Tu utilises new/new[] et delete/delete[] mais tu geres l'ensemble de tes tableau à la manière C, de meme, tu garde les bonnes vieilles habitude de travailler avec des chaines de caractères "C style"

Et tu crées, gaillardement, tes 89 classes et structures, selon le principe que "l'encapsulation des données, connais pas"...

Puis, dans trois mois, peut etre six... peut etre meme dans un an, tiens, tu tombes sur LE bug qui était passé à la trappe et qui survient parce que, justement, la gestion des chaines en C, c'est pas folichon (il faut dire ce qui est

)... ou parce que tu avais prévus cinq points pour une pyramide et que, pas de bol, tu te retrouve avec une pyramide à 6...

Et, comme tu as pris un peu de bouteille, qu'en attendant, tu as écumé les forums, que tu as pris quelques minutes pour t'initier à l'utilisation de la S(T)L, tu te dis que c'est peut etre le moment d'améliorer un peu l'application...

Et tu décides, avec raison, d'utiliser un tableau, ou mieux, un std::vector, pour les coordonées de tes points...

Et là, alors qu'il t'aurais "suffit" de modifier les méthodes de la classe (ou de la structure) point si tu avais fournis une interface indépendante de l'implémentation, tu te retrouve à devoir modifier... le code des 88 autres classes et structures... Ce qui a de fortes chances de te dégouter avant meme de commencer

Ne va surtout pas croire que j'écrive cela pour te rabrouer, ou, pire, pour te dégouter...

Non, si je l'écris, c'est pour essayer de te donner directement les bonnes habitudes (la différence entre les bonnes et les mauvaises habitudes, c'est que les bonnes sont difficiles à prendre, et les mauvaises, difficiles à perdre

) et c'est, surtout, pour te donner l'occasion d'éviter bien des déboires classiques chez ceux qui commencent... (un petit avoeux: je suis tombé moi meme dans l'un ou l'autre de ces pièges

... je parle donc en connaissance de cause

)

[EDIT]Et c'est sans compter le fait que, bien que la STL soit un gros morceau à attaquer, elle facilite énormément la vie à l'utilisation

[/EDIT]

**JolyLoic** · 15/12/2006, 21h06

Envoyé par koala01

Il existe d'autres différences mineures entre les structures et les classes

A part les privilèges d'accès par défaut des données membre et de l'héritage, il n'y en a aucune.

Il y a des endroits où le mot clef class peut être utilisé, et pas le mot clef struct, mais entre classes et structures, c'est du pareil au même, hors bugs du compilateur.

**Luc Hermitte** · 17/12/2006, 03h57

On peut aussi rajouter des réticences psychologiques et autres conventions d'écriture.

[Debutant]Problème Insertion dans une Struct

C++

Discussions similaires

Partager

Partager