Discussion :

[LostInGeekLand]

Bonjour,

j'ai une structure qui doit se présenter à priori de la façon suivante :

Code :

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

1
2
3
4
5
6
 
struct Test{
	float	Min;
	float	Max;
	float	Coord[3];
} Test;

J'aimerai utiliser un tableau pour le dernier champ pour rentrer les coordonnées 3D d'un vecteur par exemple.
Est-ce que c'est possible ?

Je dois ensuite remplir grâce à une fonction les champs de cette structure, et je ne fais apparement pas ça comme il faut, à moins que le problème ne vienne de l'utilisation du tableau :

Code :

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

1
2
3
4
5
6
7
8
9
 
void FillStruct( float *fStat, ClassPoint *fCoord, Test *StructTest )
{
	 StructTest->Min = fStat[0] ;
	 StructTest->Max = fStat[1];
              StructTest->Coord[0] = fCoord.x;
              StructTest->Coord[1] = fCoord.y;
              StructTest->Coord[2] = fCoord.z;
}

Voilà, j'ai à peu près ça, et j'ai une erreur :

un indice requiert un tableau ou type pointeur.

Je sens que j'ai soit fait une ptite erreur et que je m'endors sur mon clavier et ne la vois pas soit une grosse boulette
Si qqun a la solution je prends
Merci

[adrien1]

heu juste comme ca par soucis de conception.
ne pourrais-tu pas utiliser une classe plutot que une struct
tu pourrais y inserer des methodes de remplissage. non?

[Lucien63]

Code :

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

              StructTest->Coord[0] = ClassPoint.x;

Dans ton code ClassPoint est un type.

Ce n'est pas plutôt :

Code :

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

              StructTest->Coord[0] = fCoord->x;

que tu voulais faire ?

[LostInGeekLand]

Ce n'est pas plutôt :

Code :

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

              StructTest->Coord[0] = fCoord->x;

que tu voulais faire ?

mmh
Si si, je me suis rendue compte de mon erreur avec le post de Dalini71, donc j'ai été éditer mon 1er post, pardon je l'ai écrit un peu vite

- On préfère l'utilisation d'un vector à l'utilisation de tableaux
Sinon pour ton erreur, la paramètre fStat est bien un tableau ?

j'ai un peu simplifié le code pour le poster ici, mais en gros fStat est un pointeur et à priori l'erreur vient bien de Coord[3]


En fait pour faire plus simple sur ce qui me pause à priori problème:

Code :

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

1
2
3
4
5
6
7
 
void FillStruct( ClassPoint *fCoord, Test *StructTest )
{
              StructTest->Coord[0] = fCoord.x;
              StructTest->Coord[1] = fCoord.y;
              StructTest->Coord[2] = fCoord.z;
}

Que veux tu dire par "- On préfère l'utilisation d'un vector à l'utilisation de tableaux" ?

[LostInGeekLand]

heu juste comme ca par soucis de conception.
ne pourrais-tu pas utiliser une classe plutot que une struct
tu pourrais y inserer des methodes de remplissage. non?

Je confirme, une classe serai bien plus simple,
seulement dans mon cas je n'ai pas le choix, ça doit être une structure

[Arzar]

Je confirme, une classe serai bien plus simple,
seulement dans mon cas je n'ai pas le choix, ça doit être une structure

Les classes et les stuctures sont totalement identiques en C++. (enfin, excepté leur visibilité par défaut, public pour une struct, private pour une classe).

[LostInGeekLand]

Les classes et les stuctures sont totalement identiques en C++. (enfin, excepté leur visibilité par défaut, public pour une struct, private pour une classe).

OK
En fait j'en ai besoin pour un usage ensuite externe à C++
Bref c'est compliqué mais en gros j'ai vraiment pas le choix

[Arzar]

Sinon, pour ton problème... et bien ça dépend probablement de la définition de ClassPoint...

Edit : Hmm, d'après msdn :

Message d'erreur
un indice requiert un type tableau ou pointeur
subscript requires array or pointer type

L'indice a été utilisé sur une variable qui n'était pas un tableau.

L'exemple suivant génère l'erreur C2109 :

Tu nous montres bien le code que tu essayes réellement de compiler ?

Edit 2 : Juste pour préciser, car la traduction automatique de msdn est complètement à coter de la plaque : Par subscript, il faut comprendre "opérateur []" et pas "indice".
Donc a priori, tu essayes d'appliquer un [] à une variable qui n'est pas un tableau. Peut-être une erreur inattention?

[Dalini71]

Bonjour,

Déjà, quand on code en C++ :

- On préfère :

Code :

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

1
2
3
4
struct maStructure
{
...
};

à

Code :

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

1
2
3
4
struct maStructure
{
...
} maStructure;

- On préfère le passage par référence au passage par pointeurs
- On préfère l'utilisation d'un vector à l'utilisation de tableaux

Sinon pour ton erreur, la paramètre fStat est bien un tableau ?
Si non, ton erreur vient surement de là.

[koala01]

Salut,

Déjà,le "Test" qui se trouve entre l'accolade fermante et le point virgule est inutile et... dangeureux...

En effet, il déclare une variable globale Test qui est du type... Test, et ca risque de foutre le bordel intégral
Ceci dit, lorsque tu essaye d'accéder à
ClassPoint.x, ClassPoint.y et ClassPoint.z, tu utilise un nom de type là où tu devrais utiliser... un nom de variable (fCoord, en l'occurrence)

Et, comme tu as passé fCoord sous la forme d'un pointeur sur un objet de type ClassPoint, tu dois utiliser la flèche " -> " pour accéder au membre souhaité
Ton code

Code :

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

1
2
3
              StructTest->Coord[0] = ClassPoint.x;
              StructTest->Coord[1] = ClassPoint.y;
              StructTest->Coord[2] = ClassPoint.z;

doit donc être modifié en

Code :

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

1
2
3
              StructTest->Coord[0] = fCoord -> x;
              StructTest->Coord[1] = fCoord -> y;
              StructTest->Coord[2] = fCoord -> z;

Ceci dit...

Il existe en C++ un mécanisme qui permet d'éviter l'utilisation de pointeurs et les problèmes qui y sont liés (dont la nécessité de récupérer l'adresse de l'objet, et le changement de syntaxe pour accéder aux membres) lorsqu'il s'agit, simplement, de passer des structures en en évitant la copie

J'ai nommé: la référence.

La référence agit comme un alias de l'objet que l'on transmet lors de l'appel, et, pour être sur que nous n'iront pas modifier, dans la fonction appelée, l'objet transmis, il est possible et conseillé de déclarer un argument qui ne doit pas être modifié sous la forme d'une référence constante.

Ainsi, le code, finalement assez lourd proche 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
void FillStruct( float *fStat, ClassPoint *fCoord, Test *StructTest )
{
    /* ici, il faut accéder aux membres de fCoord et de StructTest
     * avec la fleche, parce que nous manipulons des pointeurs
     * et que nous voulons accéder au contenu des objet pointés
     */
}
void foo()
{
    float ftab[2]; /* notre tableau de float */
    ClassPoint cp; /* notre instance de classe point origielle */
    Test t; /* notre instance de classe de teste */
    /*
     * initialisation de ftab[0] et de ftab[]1
     */
    /* pour passer des pointeurs sur cp et sur t, il faut en prendre l'adresse */
    FillStruct(ftab, & cp, & t);
}

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
serait avantageusement remplacé par
/* fStat doit rester un pointeur,
 * fCoord deviendrait une référence constante (car fCoord n'a
 * pas vocation à être modifié)
 * et StructTest deviendrait une référence (car les modification apportées 
 * au sein de FillStruct doivent être répercutées dans la fonction appelante )
 */
void FillStruct( float *fStat, ClassPoint const & fCoord, Test &StructTest )
{
    /* Il n'y a plus de changement de syntaxe entre l'objet et la référence
     */
	 StructTest . Min = fStat[0] ;
	 StructTest . Max = fStat[1];
              StructTest . Coord[0] = fCoord.x;
              StructTest . Coord[1] = fCoord.y;
              StructTest . Coord[2] = fCoord.z;
 
}
void foo()
{
    float ftab[2]; /* notre tableau de float */
    /*
     * initialisation de ftab[0] et de ftab[]1
     */
    ClassPoint cp; /* notre instance de classe point origielle */
    Test t; /* notre instance de classe de teste */
   /* nous pouvons passer cp et t sans même devoir en prendre l'adresse */
    FillStruct(ftab, cp, t);
}

Enfin, si le tableau de float à transmettre en tant que fStat venait à devoir contenir un nombre important ou inconnu d'éléments, il serait opportun d'utiliser de préférence la classe vector, fournie par le standard et disponible dans l'espace de noms std par simple inclusion du fichier <vector>.

On peut d'ailleurs, bien que cela ne change pas grand chose dans le cas présent, envisager d'utiliser cette classe pour un tableau de taille minime et connue à l'avance

Cela aurait pour avantages:

1. De nous décharger de la gestion manuelle de la mémoire à allouer (et à libérer) dynamiquement
2. De nous permettre de passer la structure sous forme de référence (éventuellement constante), et donc de supprimer la dernière utilisation de pointeurs présente dans le code
3. le fait que la classe vector connait sa taille (au travers de la fonction membre size() ) alors qu'il nous serait nécessaire de la transmettre en paramètre autrement

Nous en arriverions donc à un code proche 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
/* tout est passé par référence
 * fStat et fCoord sous la forme de références constantes car
 * ils n'ont pas vocation à être modifés
 * et structTest sous la forme de référence non constante, car les
 * modifications apportées dans la fonction appelées doivent être
 * répercutées dans la fonction appelante
 */
void FillStruct(std::vector<float> const &fStat, ClassPoint const & fCoord,
                Test &StructTest )
{
    /* Il n'y a plus de changement de syntaxe entre l'objet et la référence
     */
	 StructTest . Min = fStat[0] ;
	 StructTest . Max = fStat[1];
              StructTest . Coord[0] = fCoord.x;
              StructTest . Coord[1] = fCoord.y;
              StructTest . Coord[2] = fCoord.z;
 
}
void foo()
{
    std::vector<float> ftab(2); /* notre tableau de float */
    /*
     * initialisation de ftab[0] et de ftab[1]
     */
    ClassPoint cp; /* notre instance de classe point origielle */
    Test t; /* notre instance de classe de teste */
   /* nous pouvons passer cp et t sans même devoir en prendre l'adresse */
    FillStruct(ftab, cp, t);
}

Enfin, tant qu'à faire, nous pourrions envisager de mettre le RAII (Ressource Aquisition Is Initialization ou en francais l'acquisition des ressource vaut initialisation) en oeuvre...

En effet, min et max peuvent être considérés comme étant des valeurs constantes connues à la compilation

Cela nous donnerait une classe Test proche 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
class Test
{
    public:
        /* le constructeur par défaut */
        Test():min(-999.9999),max(999.9999),x(0.0)(0.0),z(0.0){}
        /* le constructeur prenant x, y et z */
        Test(float x, float y, float z):min(-999.9999), max(999.9999), 
            x(0.0)(0.0),z(0.0){}
         /* éventuellement, un constructeur prenant un ClassPoint en 
          * argument le mot clé explicit évite que ce constructeur ne serve
          * d'opérateur de conversion implicite d'un objet de type
          * ClassPoint en un objet de type Test
          */
         explicit Test (ClassPoint const & cp):min(-999.9999),max(999.9999),
             x(cp.x)(cp.y),z(cp.z){}
         /* les accesseurs sur x, y et z */
         float getX() const{return x;}
         float getY() const{return y;}
         float getZ() const{return z;}
    private:
        /* interdisons l'acces à x, y et z en dehors de la classe */
        float x;
        float y;
        float z;
}

Nous pourrions alors utiliser un code proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void foo()
{
    /* créons une instance avec les valeurs par défaut */
    Test t; /* plus besoin d'initialiser, c'est magique :D */
    /* créons une instance avec des valeurs données pour x, y et z */
    Test t2(3.1415, 6.2831, 9.4246);
    /* ou encore, utilisons un objet de type ClassPoint */
    ClassPoint cp;
    /* je laisse l'initialisation */
   Test t3(cp);
}

[Dalini71]

Que veux tu dire par "- On préfère l'utilisation d'un vector à l'utilisation de tableaux" ?

Grosso-Modo, les vector représentent une alternative aux tableaux, c'est plus simple/intuitif, mieux optimisé.

Je vais pas te faire un cours, certains l'ont fait mieux que moi, d'ailleurs voila un lien

- Sur notre chère FAQ

Edit : Grillé

[Lucien63]

mmh
Si si, je me suis rendue compte de mon erreur avec le post de Dalini71, donc j'ai été éditer mon 1er post, pardon je l'ai écrit un peu vite

Oui, sauf que tu as lu à moitier le bout de code que je t'ai posté !

[LostInGeekLand]

Merci à tous
Je devrais arriver à m'en sortir avec tout ça, je ferme quand même pas le sujet pour l'instant, on sait jamais
Et je vais essayer de regarder ces <vector> de plus près
Merci

[LostInGeekLand]

Je ferme le sujet,
ça m'a permit de mieux comprendre qques trucs
Même si au final (à part ma mauvaise retranscription entre ClassePoint et les -> remplacés par des . ) je n'étais pas si loin de la solution. Une erreur s'était glissée dans la déclaration de fonctions au dessus de tout ça et la compilation ne l'avait pas vu (et moi non plus )
merci à tous