Problème de #define

Version imprimable

Problème de #define

Bonjour,
j'ai un problème de compilation avec g++. J'inclus le fichier Bernstein.h dans deux fichiers Bezier3.cc et RQBC.cc.

Lors de la compilation, j'ai le message suivant :

RQBC.o: dans la fonction « B1(double)»:
RQBC.cc:(.text+0x0): définitions multiples de « B1(double)»
Bezier3.o:Bezier3.cc:(.text+0x0): défini pour la première fois ici
RQBC.o: dans la fonction « B33(double)»:
RQBC.cc:(.text+0x210): définitions multiples de « B33(double)»
Bezier3.o:Bezier3.cc:(.text+0x90): défini pour la première fois ici
RQBC.o: dans la fonction « B23(double)»:
RQBC.cc:(.text+0x240): définitions multiples de « B23(double)»
Bezier3.o:Bezier3.cc:(.text+0xc0): défini pour la première fois ici
RQBC.o: dans la fonction « B13(double)»:
RQBC.cc:(.text+0x260): définitions multiples de « B13(double)»
Bezier3.o:Bezier3.cc:(.text+0xe0): défini pour la première fois ici
RQBC.o: dans la fonction « B03(double)»:
RQBC.cc:(.text+0x280): définitions multiples de « B03(double)»
Bezier3.o:Bezier3.cc:(.text+0x100): défini pour la première fois ici
RQBC.o: dans la fonction « B2(double)»:
RQBC.cc:(.text+0x2b0): définitions multiples de « B2(double)»
Bezier3.o:Bezier3.cc:(.text+0x130): défini pour la première fois ici
RQBC.o: dans la fonction « B0(double)»:
RQBC.cc:(.text+0x2c0): définitions multiples de « B0(double)»
Bezier3.o:Bezier3.cc:(.text+0x140): défini pour la première fois ici
collect2: ld returned 1 exit status
make: *** [OpenGL] Erreur 1

Voici le fichier Bernstein.h :
Code:

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 #ifndef _BERNSTEIN_ #define _BERNSTEIN_ double B0 (double t) { return pow(1-t,2); } double B1 (double t) { return (2*t*(1-t)); } double B2 (double t) { return pow(t,2); } double B03 (double t) { return pow(1-t,3); } double B13 (double t) { return (3*t*pow(1-t,2)); } double B23 (double t) { return (3*(1-t)*pow(t,2)); } double B33 (double t) { return pow(t,3); } #endif
Merci d'avance à toute personne qui pourra me donner une solution.

Lionel

01/11/2007, 09h01
yan

Ton . h as l'air correcte.
Peut tu montrer les premières lignes de ton .cpp?

Voici le début de RQBC.cc

Code:

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
 
#include "Point.h"
#include "RQBC.h"
#include "Bernstein.h"
 
 
 
int RQBC::calcW1()
{
  int re=0;
  if (fabs(P1.distanceCarre(P0)-P1.distanceCarre(P2))<0.0001) re=1;
  { double w=w0+w2;
    Point G;
    G.bar(P0,w0,P2,w2);
    Point O;
    O.centreCercle(P0,P1,P2);
    double R2=O.distanceCarre(P0);
    double alpha=4.0*(R2-O.distanceCarre(P1));
    double beta=pow(w,2)*(R2-O.distanceCarre(G));
    w1=sqrt(-beta/alpha);
  }
  return re;
}
 
int RQBC::calcW1n()
{
  int re=calcW1();
  w1=-w1;
 return re;
}

Et voici le début de Bezier3.cc

Code:

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
 
#include "Point.h"
#include "Bezier3.h"
#include "Bernstein.h"
 
double bez3::x(double t)
{ return (tab[0].getX0()*B03(t)+tab[1].getX0()*B13(t)+tab[2].getX0()*B23(t)+tab[3].getX0()*B33(t) );
}
 
double bez3::y(double t)
{ return (tab[0].getY0()*B03(t)+tab[1].getY0()*B13(t)+tab[2].getY0()*B23(t)+tab[3].getY0()*B33(t) );
}
 
 
void bez3::openGL(int nb)
{ for (int t=0;t<nb;t++)
  { Point M0,M1;
    double t0=double (t) / double (nb);
    M0.setX0(x(t0));
    M0.setY0(y(t0));
    t0=(double (t + 1)) / double (nb);
    M1.setX0(x(t0));
    M1.setY0(y(t0));
    M0.trace_segment(M1); //cout<<"M0 : "<<M0<<" t0 = "<<t0<<" et M1 :"<<M1<<endl;
  } 
  tab[0].trace_segment(tab[1],(1.0-tab[0].getR())/2.0,(1.0-tab[0].getG())/2.0,(1.0-tab[0].getB())/2.0, tab[0].getS()/3.0);
  tab[1].trace_segment(tab[2],(1.0-tab[1].getR())/2.0,(1.0-tab[1].getG())/2.0,(1.0-tab[1].getB())/2.0, tab[1].getS()/3.0);
  tab[3].trace_segment(tab[2],(1.0-tab[2].getR())/2.0,(1.0-tab[2].getG())/2.0,(1.0-tab[2].getB())/2.0, tab[2].getS()/3.0);
  tab[0].openGL();tab[1].openGL();tab[2].openGL();tab[3].openGL();
}

Ce qui me trouble aussi, c'est que j'inclus deux fois Point.h et là, il n'y a pas de problème.

Lionel

01/11/2007, 09h23
yan

:tagcode:
Ton code semble correcte:roll:
01/11/2007, 09h27
lionel50

J'ai skotché deux collègues enseignants-chercheurs en informatique. On ne comprend pas pourquoi ça ne marche pas.8O
01/11/2007, 09h29
yan

Manque pas des include dans le .h ??

#incude <math.h> par exemple?
Essaye de faire un petit main qui utilise les fonctions du .h
01/11/2007, 09h29
NiamorH

Quand tu fais clean et build ça résoud rien ?

En fait, le math.h est inclus dans le Point.h

Code:

1
2
3
4
5
6
7
8
9
10
11
#ifndef _Point_
#define _Point_
 
#include <GL/glut.h>
//#include <stdio.h>
#include <math.h>
#include <fstream.h>
#include <iostream.h>
//#include <string>
#include "Vecteur.h"
//#define pi 3.1415926

Le make clean ne fait rien.

Je mets mon makefile :

Code:

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
LIB_PATHS= -L/usr/X11R6/lib -L/usr/lib
HDR_PATHS= -I/usr/X11R6/include
LIBS=-lglut -lGLU -lGL -lm -L/usr/X11/lib -lXext -lXmu -lXi -lX11 -g-std=c++98
 
CFLAGS=$(HDR_PATHS) -Wno-deprecated
#CC=g++
CC=gcc
 
ok : OpenGL 
 
.cc.o:
	$(CC) -c -O3 $(CFLAGS) $<
 
#OBJECTS_main = OpenGL.o RBBP.o RQBC3d.o  RQBC.o  Point3d.o Vecteur3d.o Vecteur.o Point.o 
OBJECTS_main = OpenGL.o Bezier3.o RQBC.o  Vecteur.o Point.o 
 
OpenGL: $(OBJECTS_main)
	$(CC) $(OBJECTS_main) -o OpenGL $(LIB_PATHS) $(LIBS)
 
indenter :
	for i in *.h *.cpp do sed -i~ -f sed.sed  $i done
	indent  *.h *.cpp
 
clean :
	rm -fr *.o
 
delete :
	rm -f *.h~
	rm -f *.cc~

Lionel

01/11/2007, 09h47
NiamorH

Citation:

Envoyé par lionel50

En fait, le math.h est inclus dans le Point.h

Peut-être, mais d'après ce que tu nous a montré dans ton 1er post, Bernstein.h, lui, ne connait ni math.h ni Point.h. Et il utilise pourtant pow...
01/11/2007, 09h50
yan

Citation:

Envoyé par NiamorH

Peut-être, mais d'après ce que tu nous a montré dans ton 1er post, Bernstein.h, lui, ne connait ni math.h ni Point.h. Et il utilise pourtant pow...

c'est ce que je voulais dire :king:
01/11/2007, 09h50
lionel50

J'ai ajouté

Code:

#include <math.h>

dans Bernstein.h et j'obtiens le même message après avoir fait un make clean.

Lionel
01/11/2007, 09h55
yan
Citation:

Envoyé par lionel50

J'ai ajouté

Code:

#include <math.h>

dans Bernstein.h et j'obtiens le même message après avoir fait un make clean.

Lionel

Tu devrait avoir des erreurs de compilation, selon lequel il ne sait pas qu'elle fonction pow utilisé
rajoute un "." aprés chaque chiffre que tu écrit
Code:

1 2 3 double B13 (double t) { return (3.*t*pow(1.-t,2.)); }
[edit]
ton makefile est complet?
01/11/2007, 10h00
NiamorH

Revérifie les gardes d'inclusion.

Je n'ai pas de nouveau problème de compilation avec :

Code:

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
#include <math.h>
 
#ifndef _BERNSTEIN_
#define _BERNSTEIN_
 
double B0 (double t)
{ return pow(1-t,2.);
}
 
double B1 (double t)
{ return (2*t*(1-t));
}
 
double B2 (double t)
{ return pow(t,2.);
}
 
double B03 (double t)
{ return pow(1-t,3.);
}
 
double B13 (double t)
{ return (3*t*pow(1-t,2.));
}
 
double B23 (double t)
{ return (3*(1-t)*pow(t,2.));
}
 
 
double B33 (double t)
{ return pow(t,3.);
}
 
 
#endif

Je pense que mon makefile (mis en ligne plus haut) est bon.

Je suis dubitatif :cry:

01/11/2007, 10h04
Jean-Marc.Bourguet
Ton entête contient des définitions pour tes fonctions. Donc tes fonctions sont définies dans chaque unité de compilation qui inclus l'entête, et par après l'éditeur de liens se plaint des définitions multiples.

Solution 1: mettre des définitions inline dans l'entête:
Code:

1 2 3 4 inline double B0 (double t) { return pow(1-t,2); }
Solution 2: mettre des déclarations dans l'entête

Code:

inline double B0 (double t);

et avoir une seule unité de compilation fournissant les définitions.

ATTENTION
ajoute un "." a tout les chiffre. La t'aura des erreurs de calcul. Une autre chose, n'utilise pas pow pour faire des carré et cube. Fait les à la main , se sera beaucoup plus rapide en execution. Je ne pense pas que le compilot le fasse.

Je te met en rouge les erreurs de calcul qui vont surement apparaitre
Code:

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 #ifndef _BERNSTEIN_ #define _BERNSTEIN_ #include <math.h> double B0 (double t) { return pow(1-t,2.); } double B1 (double t) { return (2*t*(1-t)); } double B2 (double t) { return pow(t,2.); } double B03 (double t) { return pow(1-t,3.); } double B13 (double t) { return (3*t*pow(1-t,2.)); } double B23 (double t) { return (3*(1-t)*pow(t,2.)); } double B33 (double t) { return pow(t,3.); } #endif

01/11/2007, 10h10
yan

Citation:

Envoyé par lionel50

Je pense que mon makefile (mis en ligne plus haut) est bon.

il manque la partie linkage non??
01/11/2007, 10h11
Jean-Marc.Bourguet

Citation:

Envoyé par Mongaulois

ATTENTION
ajoute un "." a tout les chiffre. La t'aura des erreurs de calcul.

Je ne suis pas contre le fait d'employer des littéraux du type correct -- ça évite effectivement parfois des problèmes et ça n'en cause jamais -- mais dans les cas que tu as mis en évidence, les règles du C++ assurent un comportement correct.

Merci, ça marche, voici mon nouveau Bernstein.h :

Code:

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
 
#include <math.h>
 
#ifndef _BERNSTEIN_
#define _BERNSTEIN_
 
inline double B0 (double t)
{ return pow(1-t,2.0);
}
 
inline double B1 (double t)
{ return (2*t*(1-t));
}
 
inline double B2 (double t)
{ return pow(t,2.0);
}
 
inline double B03 (double t)
{ return pow(1-t,3.0);
}
 
inline double B13 (double t)
{ return (3*t*pow(1-t,2.0));
}
 
inline double B23 (double t)
{ return (3*(1-t)*pow(t,2.0));
}
 
 
inline double B33 (double t)
{ return pow(t,3.0);
}
 
 
#endif

01/11/2007, 10h21
yan

Citation:

Envoyé par Jean-Marc.Bourguet

Je ne suis pas contre le fait d'employer des littéraux du type correct -- ça évite effectivement parfois des problèmes et ça n'en cause jamais -- mais dans les cas que tu as mis en évidence, les règles du C++ assurent un comportement correct.

ah ok....
mais normalement le type du résultat d'un calcul ne dépend t'il pas du type du premier chiffre?
int*double + float +... ne donne pas un résultat en int?
double *int+flaot +... ne donne pas un résultat en double?

[edit]
pour les inline, l'optimsation ne le fera t'il pas tout seule?
01/11/2007, 10h30
Jean-Marc.Bourguet

Citation:

Envoyé par Mongaulois

ah ok....
mais normalement le type du résultat d'un calcul ne dépend t'il pas du type du premier chiffre?

Je suppose que tu veux dire nombre plutôt que chiffre. Non, il y a des promotions pour déterminer quelque chose de commun. Dans te exemples:

Citation:

int*double + float +... ne donne pas un résultat en int?

double

Citation:

double *int+flaot +... ne donne pas un résultat en double?

exact, mais parce que c'est le type le plus "haut" qui apparait; pas parce que c'est le premier.

(Où les règles de promotion sont plus compliquées, c'est quand des unsigned et des signed apparaissent dans l'expression).

Citation:

pour les inline, l'optimsation ne le fera t'il pas tout seule?

Tu ne peux pas avoir plusieurs définitions pour la même fonction sauf si elles sont toutes inline. Le fait que les fonctions inline pour le C++ sont généralement générée en ligne par les compilateurs mais qu'ils se permettent aussi de générer d'autres fonctions en ligne n'intervient pas dans la conformité du programme.
01/11/2007, 10h42
yan

ok, merci
01/11/2007, 10h54
yan

es que tu connait une doc ou un tuto quiexplique les promotions?
01/11/2007, 11h06
lionel50

J'ai remodifié mon fichier bernstein.h.

Merci à tous pour vos éclaircissements.

Lionel
01/11/2007, 11h46
Jean-Marc.Bourguet

Citation:

Envoyé par Mongaulois

es que tu connait une doc ou un tuto quiexplique les promotions?

- si une des deux opérandes est un long double, l'autre est convertie en long double
- si une des deux opérandes est un double, l'autre est convertie en double
- si une des deux opérandes est un float, l'autre est convertie en float
- les deux opérandes sont modifiées (indépendamment) comme suit:
- si c'est un wchart_t ou un enum, l'opérande est convertie dans le premier type qui peut représenter toutes les valeurs dans la liste int, unsigned, long, unsigned long.
- si c'est un char, signed char, unsigned char, short, unsigned short: si int peut représenter toutes les valeurs du type de l'opérande, elle est convertie en int, sinon elle est convertie en unsigned int
- sinon, l'opérande n'est pas modifiée
- si une des deux opérandes est unsigned long, l'autre est convertie en unsigned long
- si une des deux opérandes est un long et l'autre unsigned, alors
- si long peut représenter toutes les valeurs d'unsigned, l'unsigned est converti en long
- sinon, les deux sont converties en unsigned long
- si une des deux opérandes est un long, l'autre est convertie en long
- si une des deux opérandes est un unsigned, l'autre est convertie en unsigned
- sinon, les deux opérandes sont des int

Je suppose que le type des littéraux t'intéresse aussi. Pour les entiers:
- décimal sans suffixe: premier de int, long qui est capable de représenter la valeur
- octal ou hexadécimal sans suffixe: premier de int, unsigned, long, unsigned long qui est capable de représenter la valeur
- suffixe de U: premier de unsigned, unsigned long qui est capable de représenter la valeur
- suffixe de L: premier de long, unsigned long qui est capable de représenter la valeur
- suffixe de UL: unsigned long

Les flottants sont des doubles sauf avec un suffixe F (float) ou L (long double).

Si j'ai bonne mémoire, les choses sont les mêmes en C90, différentes en C99 (introduction de long long et possibilité de types supplémentaires), et seront différentes en C0X (les mêmes règles que C99 me semble-t'il mais j'ai pas vérifié).
04/11/2007, 21h05
yan

puif.
Un grand merci
faut que je relise cela tranquillement.