Discussion :

[x-programer]

bonjour.
j'ai un probléme avec ce code !

Code :

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

1
2
3
4
5
6
7
8
9
 
typedef struct
{
float p[8];
}Pp;
 
Pp* tableau;
float p[8] = {-12.5f,72.5f,-12.5f,67.0f,-5.0f,72.5f,-5.0f,67.0f};
tableau[0].p = p;

quand je compile je trouve le l'erreur suivant :
expected primary-expression before '{' token
expected `;' before '{' token

merci pour l'aide

[LittleWhite]

Bonjour,

Il me semble que votre code à plusieurs problème...
*va voir avec son g++*

Premièrement, il faut allouer le pointeur qui pointe sur la structure. ( appelé tableau )
avec une ligne du genre:

Code :

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

1
2
 
Pp* tableau = new Pp();

Il faudra aussi vérifié si le pointeur est correct, et aussi le désallouer quand on aura fini de jouer avec.

Deuxièmement, tableau[0].p est équivalent à tableau->p
Du moins pour ce cas ou vous avez juste un Pp* initialiser comme je l'ai fait.

Troisièmement, la copie du tableau comme vous l'a demandé n'est pas possible.
Il faudra faire une copie à la main.

Mais j'ai l'impression que je me trompe, ou alors, c'est que je ne saisi pas le pourquoi vous faites tout ça...

[x-programer]

merci pour ta réponse
bon ben,je ne trouve pas un algorithme(pour un débutant)qui fait les box bounding d'un objet ".md2" !
donc j'ai remplis l'ensemble des coordonnées manuellement comme suit:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
numBox = 10;
     boxCollision[0].p = {26.2,77.3,26.2,40.6,27.5,77.3,27.5,40.6}
     boxCollision[1].p = {26.2,77.3,63.1,77.3,26.2,76.3,63.1,76.3}
     boxCollision[2].p = {63.1,45.4,63.1,77.3,62.8,45.4,62.8,77.3}
     boxCollision[3].p = {26.2,40.4,62.8,40.4,26.2,40.8,62.8,40.8}
     boxCollision[4].p = {26.8,41.9,33.1,41.9,26.8,41.4,33.1,41.4}
     boxCollision[5].p = {26.8,51.2,33.1,51.2,26.8,50.7,33.1,50.7}
     boxCollision[6].p = {33.1,41.9,33.1,46.2,32.6,41.9,32.6,26.2}
     boxCollision[7].p = {33.1,49.1,3.1,511.2,32.6,49.1,32.6,51.2}
     boxCollision[8].p = {60.4,57.0,60.4,77.3,59.8,57.0,59.8,77.3}
     boxCollision[9].p = {60.4,57.0,38.4,57.0,60.4,57.5,38.4,57.5}

je sais que ça prend beaucoup de temp mais pas moyen pour l'instant !j'utiliserai cette technique jusqu'à trouver un algo !
j'ai toujours le même erreur

[koala01]

Salut,

Ce qu'il faut savoir, c'est que lorsque tu déclares un tableau "C style" (sous la forme de)

Code :

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

type tab[N];

tab représente en réalité... l'adresse premier élément du tableau (tab[0]).

Et donc, si tu écris un code proche de

Code :

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

1
2
3
4
double tab1[8]={26.2,77.3,26.2,40.6,27.5,77.3,27.5,40.6};
double tab2[8];
/*..*/
tab2=tab1;

ce que tu va faire, c'est... affecter l'adresse du premier élément de tab1 à celle du premier élément de tab2.

Il n'y a donc pas de copie des différentes valeurs, et le résultat sera que, si tu décide de modifier une des valeurs de tab1 (par exemple tab1[5]), la modification sera répercutée sur tab2, et inversement.

Or, je présumes que ce n'est pas ce que tu souhaites

Il faut donc t'assurer de copier effetivement les différentes valeurs en utilisant, par exemple, la fonction memcpy sous une forme proche de

Code :

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

1
2
3
4
double tab1[8]={26.2,77.3,26.2,40.6,27.5,77.3,27.5,40.6};
double tab2[8];
/*..*/
std::memcpy(tab1,tab2,size_of(double)*8);

(supprimes le "std::" si tu code en C pur et non en C++)

Ceci dit, en C++ on préfère bien souvent éviter le recours aux tableaux "C style" du fait des problèmes qu'ils occasionnent parmi lesquels on trouve:

• Le problème de la copie que je viens d'évoquer
• le fait qu'un tableau ne connait pas sa taille
• les problème liés à la gestion dynamique de la taille des tableau (d'allocation et de libération dynamique de la mémoire)

On préférera souvent utiliser la classe vector, fournie par le standard dans l'espace de noms std par simple inclusion du fichier d'en-tête <vector>.

En effet, elle permet offre les même caractéristiques et posssibilités qu'un tableau C style ( éléments contigus en mémoire, accès aléatoire aux différents éléments avec l'opérateur []) tout en ayant les avantages
de connaitre le nombre d'éléments qu'elle contient (grâce à sa fonction

• membre size() )
• d'être facilement copiable
• d'éviter à l'utilisateur d'avoir à gérer lui-même la mémoire nécessaire pour représenter les éléments.

Et, ce qui ne gache rien, il est même possible de créer directement un tableau qui sera la copie exacte d'un tableau C style sous la forme de

Code :

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

1
2
3
4
double tab1[8]={26.2,77.3,26.2,40.6,27.5,77.3,27.5,40.6};
std::vector<double> vect(tab1,tab1+8);
/* il est facilement copiable: */
std::vect<double> vect2(vect);

Il faut aussi faire attention au fait que tu déclares ta variable tableau comme étant un pointeur de type Pp...

C'est à dire que tu la déclare comme étant... l'adresse à laquelle tu trouvera la variable correspondante.

Si tu veux l'utiliser, il faut commencer par t'assurer que l'adresse en question soit valide et cohérente (en un mot: que l'adresse corresponde effectivement à un endroit où ... on trouve une variable de type Pp)...

Cela devrait se faire en utilisant l'allocation dynamique de la mémoire sous une forme proche de

Code :

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

1
2
3
4
Pp *tableau= new Pr[n];
/*...*/
/* il ne faut pas oublier de libérer la mémoire "juste à temps" */
delete tableau;

Mais, encore une fois, tu risque d'être confronté aux problèmes relatifs à la gestion dynamique de la mémoire

Tu devrais donc encore une fois envisager de gérer tes différents Pp avec... la classe vector, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
std::vector<Pp> tableau;
/* mettons-y 20 éléments remplis par défaut */
double tab1[8]={26.2,77.3,26.2,40.6,27.5,77.3,27.5,40.6};
Pp temp;
temp.p = std::vector<double>(tab1,tab1+8);
/* l'insertion dans un vecteur passe par la copie de l'élément à insérer */
for(size_t i=0;i<20;++i)
    tableau.push_back(temp);

En outre, il faut savoir que la définition d'une structure ou d'une classe en C++ provoque automatiquement la déclaration du type correspondant...

Tu pourrais donc te contenter d'un code proche de

Code :

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

1
2
3
4
struct Pp
{
 std::vector<double> p;
};

Enfin, il faut savoir que l'on préfère utiliser l'idiome RAII (Ressource Aquisition Is Initialisation) en C++ de manière à pouvoir manipuler directement les objets que l'on a créés en étant surs qu'ils soient correctement initialisés.

Pour ta structure, cela peut passer par la création de deux constructeurs différents, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
struct Pp
{
    std::vector<double> p;
    /* le constructeur "par défaut": aucune valeur n'est donnée
     * (il faudra les indiquer) mais p est déjà prévu pour  avoir
     * 8 valeurs distinctes 
     */
    Pp():p(8,0.0){}
    /* un constructeur permettant de passer un nombre (quelconque)
     * de valeurs
   Pp(double * debut, double * fin):p(debut, fin){}
};

et qui serait utilisés sous une forme proche de

Code :

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

1
2
3
4
5
6
double tab1[8]={26.2,77.3,26.2,40.6,27.5,77.3,27.5,40.6};
Pp p1(tab1,tab1+8);
/* ou */
Pp p2;
for(int i=0;i<8;++i)
   p2.p[i]=tab1[i];

[x-programer]

merci COALA01,merci beaucoup pour l'aide,tu m'as expliqué bien la manipulation su les tableaux et les pointeurs

[Olivier ol]

std::memcpy(tab1,tab2,size_of(double)*8);

Salut,
je voulais savoir si il était possible d'utiliser la méthode ci-dessous pour un tableau multidimensionnel.
Si oui, comment?
Dans mon programme, mon tableau fais 2 sur 8

Code :

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

1
2
 
std::memcpy(tab1,tab2,size_of(double)*8);