Erreur de compilation d'un projet avec libraire en DevC++: probleme design ou autre ?

Version imprimable

Bonjour,

Voila j'utilise une librairie de traitement d'images (GD), cette librairie écrit en C
peut s'intégrer dans un environnement Mingw ainsi que DevC++, jusque là j'ai bien su intégrer dans DevC++ avec Vista et tester les fonctions seules de la librairie sans problème de compilation. Mais J'ai dans mon projet plusieurs classes afin de mettre en oeuvre un vrai projet POO avec de l'héritage, de la généricité, des surcharges de méthodes etc....

Mes classes :
Conceptuellement, Pixel doit heriter de la classe Couleur,
la classe Image devra hériter de la classe Image2D et de la classe générique Matrice (dont le paramètre de généricité sera la classe Pixel). La classe Image2D devra contenir les données et les méthodes qui ne concernent que les images en 2D. Idem pour les classes Matrice ou Pixel.

Pour le moment j'ai simplifier en ne mettant pas la classe Image2D ( d'ailleurs on peut s'en passer)

Maintenant que j'ai commencé à intégrer plusieurs classes (fichiers .h et .cpp) j'ai ces erreurs de compilation :

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
38
 
Compiler: Default compiler
Building Makefile: "C:\mygd\gdtestpng\Makefile.win"
Executing  make...
make.exe -f "C:\mygd\gdtestpng\Makefile.win" all
g++.exe -c main.cpp -o main.o -I"C:/Dev-Cpp/lib/gcc/mingw32/3.4.2/include"  -I"C:/Dev-Cpp/include/c++/3.4.2/backward"  -I"C:/Dev-Cpp/include/c++/3.4.2/mingw32"  -I"C:/Dev-Cpp/include/c++/3.4.2"  -I"C:/Dev-Cpp/include"  -I"C:/mygd/gd-latest-win32/include"  -I"C:/mygd/gd_build_win32_deps/gd_deps/include"   
 
In file included from image.h:5,
                 from main.cpp:13:
pixel.h:18: error: expected unqualified-id before "unsigned"
pixel.h:18: error: expected `)' before "unsigned"
 
pixel.h:25: error: abstract declarator `<anonymous class>' used as declaration
 
pixel.h:25: error: namespace-scope anonymous aggregates must be static
In file included from image.h:6,
                 from main.cpp:13:
matrice.h:9: error: template class without a name
matrice.h:22: error: expected unqualified-id before "int"
matrice.h:22: error: expected `)' before "int"
matrice.h:33: error: expected class-name before '(' token
matrice.h:56: error: abstract declarator `<anonymous class><T>' used as declaration
matrice.h:56: error: namespace-scope anonymous aggregates must be static
 
In file included from main.cpp:13:
image.h:15: error: expected unqualified-id before '<' token
 
image.h: In constructor `Image::Image(int, int)':
image.h:22: error: class `Image' does not have any field named `matrice_pixel'
image.h:22: error: expected `(' at end of input
image.h:22: error: expected `{' at end of input
 
main.cpp: In function `int main()':
main.cpp:69: error: 'class Image' has no member named 'exportimg'
 
make.exe: *** [main.o] Error 1
 
Execution terminated

Je pense que c'est moi qui intègre mal mais classes est-ce le cas ?
Voici mon code :

--main.cpp--

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
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
 
 
#include <iostream>
#include <windows.h> 
#include <cstdlib>
#include <fstream>
 
#include <stdio.h>
#include <stdlib.h> 
//#include "gd.h"
//#include "Pixel.h"
//#include "Matrice.h"
 
//Première ligne de bug 13 In file included from image.h:5,     from main.cpp 
#include "image.h"
 
using namespace std;
int main()
{
 
   //ICI il faut instancier objet de la classe Image car c'est la classe fille
   Image monimg(512,512);
   Image *monimglist = new Image(512,512);
 
   // ICI appeler methode de la classe Image (qui elle appelera methodes Matrice
   // Pixel, 
 
 
   //ICI code de la biblitheque GD
  // Declarations
  gdImagePtr im;
  gdImagePtr imout;
  FILE *jpegout;
  int x,y,c=0;
  int black,r=0,v=0,b=0;
  char n;
 
  // Initialisations
  im = gdImageCreateTrueColor(512, 512);
  imout = gdImageCreateTrueColor(512, 512);
  // fond de l'image mis a noir
  black = gdImageColorAllocate(im, 0, 0, 0);
 
  for (x=0;x<gdImageSX(im);x++)
    for (y=0;y<gdImageSY(im);y++)
      { // Genere trois nombres r,v,b entre 0 et 256
    r=(int) (256.0*rand()/(RAND_MAX+1.0));
    v=(int) (256.0*rand()/(RAND_MAX+1.0));
    b=(int) (256.0*rand()/(RAND_MAX+1.0));
    // avec ces trois nombres, on "genere" une couleur
    c= gdImageColorAllocate(im, r, v, b);
    /* NB : Ces 3 lignes pourraient etre condensees en une seule
       car on travaille en "couleur vraie" :
       c=(int) (16777216.0*rand()/(RAND_MAX+1.0));
       "c" est bel et bien un entier entre 0 et 256^3, rien de plus !
       Le gdImageColorAllocate est superflu !
       Pour s'en persuader, printf("R:%d-V:%d-B:%d=>C:%d\n",r,v,b,c);
    */
    // met le pixel en (x,y) a cette couleur
    gdImageSetPixel(im, x, y, c);
      }
 
  // Ecriture de l'image et nettoyage
 
  jpegout = fopen("toto.jpg", "wb");
 
  gdImageJpeg(im, jpegout, -1);
 // monimg =im;
  monimg.exportimg(imout);
  FILE * sortie;
  sortie= fopen("recup.jpg", "wb");
  //(gdImagePtr im, FILE * out, int quality);
  gdImageJpeg(imout,sortie,10);
 
  fclose(sortie);
  fclose(jpegout);
  gdImageDestroy(im);
  gdImageDestroy(imout);
  system("pause") ;
 
  return 0;
}

--image.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
 
//- la classe image qui est définie par la classe générique matrice avec paramètre d'instanciation la classe pixel
//#ifndef Image
//#define Image 
 
#include "pixel.h"
#include "matrice.h"
#include "gd.h"
 
//typedef Matrice<Pixel> t_Cpixelmat;
//template <class T>
class Image //: public Matrice <T>
{
	private:
 
	Matrice<Pixel> matrice_pixel;
 
	public:
    //Image(const Image&);
    //~Image(){    } // dois je detruire matrice_pixel ? ==> non, c'est fait dans la classe mère
 
	//Image(int n, int m) : t_Cpixelmat(n,m) ;
     Image(int n, int m) : matrice_pixel ;
 
};
 
//#endif

--fichier image.cpp--

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#include "image.h"
#include "gd.h"
//#include "Pixel.h"
//#include "Matrice.h"
 
Image::Image(int n, int m) : matrice_pixel (n,m)
{
Pixel p;
matrice_pixel M;
for(int i=0; i<n;i++)
         (for(int j=0; j<n;j++)
         M(i,j,p=Pixel(0,0,0,0,i,j);
 
}
 
Image::~Image()
{
}
 
};

--Pixel.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
 
//- la classe pixel qui derive de la classe couleur
#ifndef Pixel
#define Pixel 
 
#include "couleur.h"
 
class Pixel : public Couleur
{
//private:
protected:
unsigned int X; //abscisse
unsigned int Y; //coordonnée
 
public:
 
//Pixel() : Couleur(0,0,0,0) { X = Y = 0; }
 
//seconde ligne de bug : pixel.h expected unqualified-id before "unsigned" 
Pixel(unsigned int x, unsigned int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a /*= 0*/)  
		: Couleur(r,g,b,a)
	{
		X = x;
		Y = y;
	}
 
};
 
#endif

--Matrice.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
38
39
40
41
42
43
44
 
#ifndef Matrice
#define Matrice
 
//#include "Pixel.h"
 
template <class T>
class Matrice
{
protected:
 
T **mat;
 
int max_de_lignes;
int max_de_colonnes;
int nombre_de_lignes;
int nombre_de_colonnes;
 
public:
 
     //voir 
Matrice(int n,int m)
{
	max_de_lignes=n,
	max_de_colonnes=m;
	nombre_de_lignes=0;
	nombre_de_colonnes=0;
	mat=new T*[max_de_lignes];
	for(int i=0;i<max_de_lignes;i++)
	mat[i] = new T[max_de_colonnes];
}
 
~Matrice()
{
	for(int i=0;i<max_de_lignes;i++)
	{
		delete[] mat[i];
	}
	delete[] mat;
}
 
};
 
#endif

--couleur.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
38
 
 
#ifndef _COULEUR 
#define _COULEUR 
 
class Couleur
{
protected:
 
	unsigned char R, G, B; //(ou l'inverse ... à voir plus tard);
	//unsigned char V[4];
	//unsigned long Col;
 
public:
 
 
 void  set(	unsigned char Rp,unsigned char Gp,unsigned char Bp)
          { R = Rp;
          G =Gp;
          B= Bp;
 
                }
 unsigned char get_R()
           { return R;               }
 
 unsigned char get_G()
  { return G;               }
 unsigned char get_B()
  { return B;               }
 
 unsigned int get_color() //32 bits
 {
          return ( (unsigned long)R << 16 | (unsigned long)G << 8 | (unsigned long)B);
 } 
Couleur() { R = G = B = 0; }
Couleur(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 0) { set(r, g, b);}
};
#endif

Enfin j'ai pas fait de fichiers séparé pour l'implémentatoin de toutes mes classes est ce vraiment utile ? Pourriez vous m'aider dans la conception et code de ce projet car je n'arrive pas du tout à éliminer ces erreurs de compilations ?

Merci

25/05/2009, 17h36
3DArchi

Bonjour,
Tu as un problème avec ton header guard (Pixel) qui est le même que le nom de ta classe (Pixel). C'est probablement cette même mauvaise raison qui a fait que le header guard de Image est commenté.
Tu devrais utiliser quelque chose de moins ambiguë ( PIXEL_HEADER_).
25/05/2009, 17h40
ram-0000
Je viens de voir cela dans un des header
Code:

1 2 3 4 5 6 #ifndef Matrice #define Matrice template <class T> class Matrice ...
Ce n'est pas un problème d'avoir 2 objets qui s'appellent Matrice. Ou bien il y en a un qui est géré par la table des symboles du preprocesseur et l'autre qui est géré par la table des symboles du compilateur.

Citation:

Envoyé par ram-0000

Ce n'est pas un problème d'avoir 2 objets qui s'appellent Matrice.

Si

Citation:

Envoyé par ram-0000

Ou bien il y en a un qui est géré par la table des symboles du preprocesseur et l'autre qui est géré par la table des symboles du compilateur.

En fait, 'Matrice' sera remplacé par rien partout avant d'être injecté au compilateur.
On se retrouve 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 37 template <class T> class { protected: T **mat; int max_de_lignes; int max_de_colonnes; int nombre_de_lignes; int nombre_de_colonnes; public: //voir (int n,int m) { max_de_lignes=n, max_de_colonnes=m; nombre_de_lignes=0; nombre_de_colonnes=0; mat=new T*[max_de_lignes]; for(int i=0;i<max_de_lignes;i++) mat[i] = new T[max_de_colonnes]; } ~() { for(int i=0;i<max_de_lignes;i++) { delete[] mat[i]; } delete[] mat; } };
:aie:

Quand vous dites header guard si je comprend bien ça veut dire les #define tel que par exemple :

#ifndef Matrice
#define Matrice

... (contenut du fichier .cpp d'une classe)

#endif

Mais au fond est ce que les header guard ce n'est pas plutôt utlisé dans les implémentations c-à-d les fichiers .cpp des classes et non dans les .h et si on peut les utiliser dans les .h c'est dans quel cas ?

Et donc apparemment j'aurais eu pour Pixel et pour Matrice des header guard de même nom.

En tous cas maintenant en ayant mis en commentaire mes header guard dans mes fichiers Pixel.h et Matrice.h et en ayant rajouter une fonction GD dans les fichiers Image. et Image.cpp car je n'avais pas fait attention qu'elle était appelée dans le main, j'ai moins d'erreurs maintenant.

mon log du compil me donne:
Code:

1 2 3 4 5 6 7 8 9 10 11 Compiler: Default compiler Building Makefile: "C:\mygd\gdtestpng\Makefile.win" Executing make... make.exe -f "C:\mygd\gdtestpng\Makefile.win" all g++.exe -c main.cpp -o main.o -I"C:/Dev-Cpp/lib/gcc/mingw32/3.4.2/include" -I"C:/Dev-Cpp/include/c++/3.4.2/backward" -I"C:/Dev-Cpp/include/c++/3.4.2/mingw32" -I"C:/Dev-Cpp/include/c++/3.4.2" -I"C:/Dev-Cpp/include" -I"C:/mygd/gd-latest-win32/include" -I"C:/mygd/gd_build_win32_deps/gd_deps/include" In file included from main.cpp:13: image.h: In constructor `Image::Image(int, int)': image.h:22: error: expected `(' at end of input image.h:22: error: expected `{' at end of input
--Image.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 //- la classe image qui est définie par la classe générique matrice avec paramètre d'instanciation la classe pixel //#ifndef Image //#define Image #include "pixel.h" #include "matrice.h" #include "gd.h" //typedef Matrice<Pixel> t_Cpixelmat; //template <class T> class Image //: public Matrice <T> { private: Matrice<Pixel> matrice_pixel; public: //Image(const Image&); //~Image(){ } // dois je detruire matrice_pixel ? ==> non, c'est fait dans la classe mère //Image(int n, int m) : t_Cpixelmat(n,m) ; Image(int n, int m) : matrice_pixel ; void exportimg(gdImagePtr pgdimg) ; }; //#endif
--Image.cpp--
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 #include "image.h" #include "gd.h" //#include "Pixel.h" //#include "Matrice.h" Image::Image(int n, int m) : matrice_pixel (n,m) { Pixel p; matrice_pixel M; for(int i=0; i<n;i++) (for(int j=0; j<n;j++) M(i,j,p=Pixel(0,0,0,0,i,j); } Image::~Image() { } void Image::exportimg(gdImagePtr pgdimg) { int pixel: for (int x =0; x<max_de_lignes; x++) for (int y=0 ; y<max_de_colonnes; y++) { pixel = mat[i,j].get_R(); gdImageSetPixel (pgdimg, x, y, pixel); } } };
Je comprends pas trop bien mais je penses avoir des problèmes avec mon design et la manière que j'implémente mes méthodes. Pourriez vous me corriger l'implémentation de mes méthodes s'il vous plaîts ? Car je préfère partir sur un bon design avant de mettre encore d'autres méthodes de traitements d'images avec surcharges d'opérateurs.

Le but de ce projet c'est de montrer les aspects de la POO ( héritage, les contructeur ( defaut, de copie), surcharges , polymorphisme.

Encore une chose comment pourrais faire correctement dérivé ma classe Image de Matrice<Pixel> ?

Merci

Citation:

Envoyé par Aliveli

Quand vous dites header guard si je comprend bien ça veut dire les #define tel que par exemple :

#ifndef Matrice
#define Matrice

... (contenut du fichier .cpp d'une classe)

#endif

Mais au fond est ce que les header guard ce n'est pas plutôt utlisé dans les implémentations c-à-d les fichiers .cpp des classes et non dans les .h et si on peut les utiliser dans les .h c'est dans quel cas ?

Et donc apparemment j'aurais eu pour Pixel et pour Matrice des header guard de même nom.

C'est nommé "header guard" parce qu'il "guard" ton "header" contre les conséquences d'être inclus deux fois du même .cpp

Tu mets les header guards dans tous les headers et tu ne les mets jamais dans les .cpp. Je préfère ce format:
Code:

1 2 3 4 5 6 7 #ifndef MYHEADER_H #define MYHEADER_H ... #endif
C-à-d j'utilise le nom du header, tout en majuscules, et je remplace le point avec un _ Ce format évite toujours les conflits avec les noms des classes etc.
Citation:
Envoyé par Aliveli
En tous cas maintenant en ayant mis en commentaire mes header guard dans mes fichiers Pixel.h et Matrice.h et en ayant rajouter une fonction GD dans les fichiers Image. et Image.cpp car je n'avais pas fait attention qu'elle était appelée dans le main, j'ai moins d'erreurs maintenant.

mon log du compil me donne:
((coupé))

--Image.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 //- la classe image qui est définie par la classe générique matrice avec paramètre d'instanciation la classe pixel //#ifndef Image //#define Image #include "pixel.h" #include "matrice.h" #include "gd.h" //typedef Matrice<Pixel> t_Cpixelmat; //template <class T> class Image //: public Matrice <T> { private: Matrice<Pixel> matrice_pixel; public: //Image(const Image&); //~Image(){ } // dois je detruire matrice_pixel ? ==> non, c'est fait dans la classe mère //Image(int n, int m) : t_Cpixelmat(n,m) ; Image(int n, int m) : matrice_pixel ; void exportimg(gdImagePtr pgdimg) ; }; //#endif
La déclaration du constructeur doit être:

Image( int n, int m );
Citation:
Envoyé par Aliveli
--Image.cpp--
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 #include "image.h" #include "gd.h" //#include "Pixel.h" //#include "Matrice.h" Image::Image(int n, int m) : matrice_pixel (n,m) { Pixel p; matrice_pixel M; for(int i=0; i<n;i++) (for(int j=0; j<n;j++) M(i,j,p=Pixel(0,0,0,0,i,j); } Image::~Image() { } void Image::exportimg(gdImagePtr pgdimg) { int pixel: for (int x =0; x<max_de_lignes; x++) for (int y=0 ; y<max_de_colonnes; y++) { pixel = mat[i,j].get_R(); gdImageSetPixel (pgdimg, x, y, pixel); } } };
Je comprends pas trop bien mais je penses avoir des problèmes avec mon design et la manière que j'implémente mes méthodes. Pourriez vous me corriger l'implémentation de mes méthodes s'il vous plaîts ? Car je préfère partir sur un bon design avant de mettre encore d'autres méthodes de traitements d'images avec surcharges d'opérateurs.
Pixel ne devrait pas hériter de Couleur, parce que un Pixel n'est pas une Couleur. Un Pixel a une Couleur.

Citation:

Envoyé par Aliveli

Le but de ce projet c'est de montrer les aspects de la POO ( héritage, les contructeur ( defaut, de copie), surcharges , polymorphisme.

Les surcharges ne sont pas un aspect de la POO.

Citation:

Envoyé par Aliveli

Encore une chose comment pourrais faire correctement dérivé ma classe Image de Matrice<Pixel> ?

Merci

Ok Cynique,

Je vois plis clair maintenant en ayant fait comme tu m'as dit je n'ai plus d'erreur de compilation mais de link.

Je crois que ma classe Matrice est correcte. Concernant la classe Couleur si elle n'est pas une super class de Image , elle est une composition sans doute pour la classe Pixel mais comment coder cela ?

Voici mes fichiers :

--Matrice.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
38
39
40
41
42
43
 
 
#ifndef MATRICE_H
#define MATRICE_H
 
 
template <class T>
class Matrice
{
protected:
 
T **mat;
 
int max_de_lignes;
int max_de_colonnes;
int nombre_de_lignes;
int nombre_de_colonnes;
 
public:
 
Matrice(int n,int m)
{
	max_de_lignes=n,
	max_de_colonnes=m;
	nombre_de_lignes=0;
	nombre_de_colonnes=0;
	mat=new T*[max_de_lignes];
	for(int i=0;i<max_de_lignes;i++)
	mat[i] = new T[max_de_colonnes];
}
 
~Matrice()
{
	for(int i=0;i<max_de_lignes;i++)
	{
		delete[] mat[i];
	}
	delete[] mat;
}
 
};
 
#endif

--Image.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
 
//- la classe image qui est définie par la classe générique matrice avec paramètre d'instanciation la classe pixel
#ifndef IMAGE_H
#define IMAGE_H 
 
#include "matrice.h"
#include "pixel.h"
 
#include "gd.h"
 
//typedef Matrice<Pixel> t_Cpixelmat;
//template <class T>
class Image : public Matrice <Pixel>
{
	private:
 
//	Matrice<Pixel> matrice_pixel;
 
	public:
    Image(const Image&);
    ~Image(); // dois je detruire matrice_pixel ? ==> non, c'est fait dans la classe mère
 
	//Image(int n, int m) : t_Cpixelmat(n,m) ;
  //   Image(int n, int m) : matrice_pixel ;
  Image(int n, int m) ;//: Matrice <Pixel> (n,m);
     void exportimg(gdImagePtr pgdimg) ;   
};
 
#endif

--Image.cpp--

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
 
#include "image.h"
#include "gd.h"
#include "Pixel.h"
#include "Matrice.h"
 
Image::Image(int n, int m) //:Matrice <Pixel> (n,m)
{
Pixel p;
//matrice_pixel M;
 Matrice <Pixel> M;
for(int i=0; i<n;i++)
         (for(int j=0; j<m;j++)
         M(i,j,p=Pixel(0,0,0,0,i,j);
 
}
 
Image::~Image()
{
}
 
void Image::exportimg(gdImagePtr pgdimg)              
{
      int pixel:
      for (int x =0; x<max_de_lignes; x++)
       for  (int y=0 ; y<max_de_colonnes; y++)
            {
                pixel = 	mat[i,j].get_R();
                gdImageSetPixel (pgdimg, x,  y, pixel);
            }
 
}
 
};

--Pixel.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
 
//- la classe pixel qui derive de la classe couleur
 
#ifndef PIXEL_H
#define PIXEL_H
 
#include "couleur.h"
 
class Pixel : public Couleur
{
//private:
protected:
unsigned int X; //abscisse
unsigned int Y; //coordonnée
 
public:
 
 
	//Pixel() : Couleur(0,0,0,0) { X = Y = 0; }
	Pixel(unsigned int x, unsigned int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a /*= 0*/)  
		: Couleur(r,g,b,a)
	{
		X = x;
		Y = y;
	}
 
};
 
#endif

--Couleur.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
38
 
 
#ifndef COULEUR_H 
#define COULEUR_H 
 
class Couleur
{
protected:
 
	unsigned char R, G, B; //(ou l'inverse ... à voir plus tard);
	//unsigned char V[4];
	//unsigned long Col;
 
public:
 
 
 void  set(	unsigned char Rp,unsigned char Gp,unsigned char Bp)
          { R = Rp;
          G =Gp;
          B= Bp;
 
                }
 unsigned char get_R()
           { return R;               }
 
 unsigned char get_G()
  { return G;               }
 unsigned char get_B()
  { return B;               }
 
 unsigned int get_color() //32 bits
 {
          return ( (unsigned long)R << 16 | (unsigned long)G << 8 | (unsigned long)B);
 } 
Couleur() { R = G = B = 0; }
Couleur(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 0) { set(r, g, b);}
};
#endif

--main.cpp--

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
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
 
 
#include <iostream>
#include <windows.h> 
#include <cstdlib>
#include <fstream>
 
#include <stdio.h>
#include <stdlib.h> 
//#include "gd.h"
//#include "Pixel.h"
//#include "Matrice.h"
#include "Image.h"
 
 
using namespace std;
//using namespace gd;
int main()
{
 
   //ICI il faut instancier objet de la classe Image car c'est la classe fille
   Image monimg(512,512);
   Image *monimglist = new Image(512,512);
 
   // ICI appeler methode de la classe Image (qui elle appelera methodes Matrice
   // Pixel, 
 
 
   //ICI code de la biblitheque GD
  // Declarations
  gdImagePtr im;
  gdImagePtr imout;
  FILE *jpegout;
  int x,y,c=0;
  int black,r=0,v=0,b=0;
  char n;
 
  // Initialisations
  im = gdImageCreateTrueColor(512, 512);
  imout = gdImageCreateTrueColor(512, 512);
  // fond de l'image mis a noir
  black = gdImageColorAllocate(im, 0, 0, 0);
 
  for (x=0;x<gdImageSX(im);x++)
    for (y=0;y<gdImageSY(im);y++)
      { // Genere trois nombres r,v,b entre 0 et 256
    r=(int) (256.0*rand()/(RAND_MAX+1.0));
    v=(int) (256.0*rand()/(RAND_MAX+1.0));
    b=(int) (256.0*rand()/(RAND_MAX+1.0));
    // avec ces trois nombres, on "genere" une couleur
    c= gdImageColorAllocate(im, r, v, b);
    /* NB : Ces 3 lignes pourraient etre condensees en une seule
       car on travaille en "couleur vraie" :
       c=(int) (16777216.0*rand()/(RAND_MAX+1.0));
       "c" est bel et bien un entier entre 0 et 256^3, rien de plus !
       Le gdImageColorAllocate est superflu !
       Pour s'en persuader, printf("R:%d-V:%d-B:%d=>C:%d\n",r,v,b,c);
    */
    // met le pixel en (x,y) a cette couleur
    gdImageSetPixel(im, x, y, c);
      }
 
  // Ecriture de l'image et nettoyage
 
  jpegout = fopen("toto.jpg", "wb");
 
  gdImageJpeg(im, jpegout, -1);
 // monimg =im;
  monimg.exportimg(imout);
  FILE * sortie;
  sortie= fopen("recup.jpg", "wb");
  //(gdImagePtr im, FILE * out, int quality);
  gdImageJpeg(imout,sortie,10);
 
  fclose(sortie);
  fclose(jpegout);
  gdImageDestroy(im);
  gdImageDestroy(imout);
  system("pause") ;
 
  return 0;
}

Voila ce que je ne comprend pas c'est comment coder mes fichiers Image.h et Image.cpp ? J'ai fait comme tu m'a demandé avec les header guard , c'est plus propre.

Et la classe couleur elle devrait etre declarée dans la classe Image ?

Merci

Pixel.h peut être comme ça:

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
 
//- la classe pixel 
#ifndef PIXEL_H
#define PIXEL_H
 
#include "couleur.h"
 
class Pixel
{
//private:
protected:
unsigned int X; //abscisse
unsigned int Y; //coordonnée
Couleur couleur;
 
public:
	Pixel(unsigned int x, unsigned int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a /*= 0*/)  
		: X(x), Y(y), couleur(r,g,b,a)
	{
	}
 
};
 
#endif

Image.h, c'est bon. :ccool:

Image.cpp:

Code:

1
2
3
4
5
6
7
8
 
Image::Image(int n, int m) 
  :Matrice <Pixel> (n,m)
{
  for(int i=0; i<n;i++)
         for(int j=0; j<m;j++)
           mat[i][j] = Pixel(0,0,0,0,i,j);
}

Fait attention avec les "arrays" de deux dimensions.

int a[N][M];

a[0,1] = 3; // ça ne marche pas, c'est a[1] = 3;

a[0][1] = 3;

(regarde dans void Image::exportimg(gdImagePtr pgdimg) )

Merci Cynique,

En fait, j'ai fait comme tu m'as dit pour Pixel.h et Image.cpp mais
j'ai toujours un probleme de link que je ne sais pas pourquoi la raison ?

log compil:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
Compiler: Default compiler
Building Makefile: "C:\mygd\gdtestpng\Makefile.win"
Executing  make...
make.exe -f "C:\mygd\gdtestpng\Makefile.win" all
g++.exe main.o m_Trtmnt_images.o  -o "gdtestpng.exe" -L"C:/Dev-Cpp/lib" -L"C:/mygd/gd-latest-win32/lib" -L"C:/mygd/gd_build_win32_deps/gd_deps/lib" ../gd-latest-win32/lib/bgd.lib ../gd_build_win32_deps/gd_deps/lib/zlib.lib ../gd_build_win32_deps/gd_deps/lib/libjpeg.lib ../gd_build_win32_deps/gd_deps/lib/libpng.lib ../gd_build_win32_deps/gd_deps/lib/freetype2.lib  
 
main.o(.text+0x18c):main.cpp: undefined reference to `Image::Image(int, int)'
main.o(.text+0x1d0):main.cpp: undefined reference to `Image::Image(int, int)'
main.o(.text+0x462):main.cpp: undefined reference to `Image::exportimg(gdImageStruct*)'
main.o(.text+0x4ef):main.cpp: undefined reference to `Image::~Image()'
main.o(.text+0x51c):main.cpp: undefined reference to `Image::~Image()'
collect2: ld returned 1 exit status
 
make.exe: *** [gdtestpng.exe] Error 1
 
Execution terminated

Dois je revoir mes constructeurs de Image ?

Merci

26/05/2009, 07h32
cynique

Citation:

Envoyé par Aliveli

Dois je revoir mes constructeurs de Image ?

Merci

Non, tu dois compiler et lier Image.cpp et Pixel.cpp

Sans faire ça, le linker ne peut pas trouver le code compilé des constructers etc.

Bonjour Cynique,

Je compile mais j'ai des erreurs de link je n'arrive pas à lier Image.cpp et Pixel.cpp comment dois je faire ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
ompiler: Default compiler
Building Makefile: "C:\mygd\gdtestpng\Makefile.win"
Executing  make...
make.exe -f "C:\mygd\gdtestpng\Makefile.win" all
g++.exe main.o m_Trtmnt_images.o  -o "gdtestpng.exe" -L"C:/Dev-Cpp/lib" -L"C:/mygd/gd-latest-win32/lib" -L"C:/mygd/gd_build_win32_deps/gd_deps/lib" ../gd-latest-win32/lib/bgd.lib ../gd_build_win32_deps/gd_deps/lib/zlib.lib ../gd_build_win32_deps/gd_deps/lib/libjpeg.lib ../gd_build_win32_deps/gd_deps/lib/libpng.lib ../gd_build_win32_deps/gd_deps/lib/freetype2.lib  
 
main.o(.text+0x18c):main.cpp: undefined reference to `Image::Image(int, int)'
main.o(.text+0x1d0):main.cpp: undefined reference to `Image::Image(int, int)'
main.o(.text+0x462):main.cpp: undefined reference to `Image::exportimg(gdImageStruct*)'
main.o(.text+0x4ef):main.cpp: undefined reference to `Image::~Image()'
main.o(.text+0x51c):main.cpp: undefined reference to `Image::~Image()'
collect2: ld returned 1 exit status
 
make.exe: *** [gdtestpng.exe] Error 1
 
Execution terminated

Merci

26/05/2009, 11h57
Médinoc

Pour les defines, je conseille H_NOMDUHEADER_AAAAMMJJ_hhmm
Cela réduit les chances de collision avec un autre symbole...
26/05/2009, 13h55
Aliveli

Oui,

j'ai fait H_NOMDUHEADER_AAAAMMJJ
mais j'ai toujours mes links erreurs ??

Merci
26/05/2009, 14h28
3DArchi

Citation:

Envoyé par Aliveli

mais j'ai toujours mes links erreurs ??

image.cpp ne fait pas parti du projet ... donc non compilé et non linké.

Je ne vois pas comment Image.cpp ne peut pas fairepartit du projet ?? etant donné que dansce projet j'appelle le header Image ??

Actuellement je n'ai qu'une erreur:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Compiler: Default compiler
Building Makefile: "C:\mygd\gdtestpng\Makefile.win"
Executing  make...
make.exe -f "C:\mygd\gdtestpng\Makefile.win" all
g++.exe -c main.cpp -o main.o -I"C:/Dev-Cpp/lib/gcc/mingw32/3.4.2/include"  -I"C:/Dev-Cpp/include/c++/3.4.2/backward"  -I"C:/Dev-Cpp/include/c++/3.4.2/mingw32"  -I"C:/Dev-Cpp/include/c++/3.4.2"  -I"C:/Dev-Cpp/include"  -I"C:/mygd/gd-latest-win32/include"  -I"C:/mygd/gd_build_win32_deps/gd_deps/include"   
 
In file included from main.cpp:13:
Image.h:30: error: ISO C++ forbids declaration of `exportimg' with no type
 
make.exe: *** [main.o] Error 1
 
Execution terminated

Mes fichiers sources sont : --main.cpp

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
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
#include <iostream>
#include <windows.h> 
#include <cstdlib>
#include <fstream>
 
#include <stdio.h>
#include <stdlib.h> 
//#include "gd.h"
//#include "Pixel.h"
//#include "Matrice.h"
#include "Image.h"
 
 
//using namespace std;
 
int main()
{
 
   //ICI il faut instancier objet de la classe Image car c'est la classe fille
   Image monimg(512,512);
   Image *monimglist = new Image(512,512);
 
   //ICI code de la biblitheque GD
  // Declarations
  gdImagePtr im;
  gdImagePtr imout;
  FILE *jpegout;
  int x,y,c=0;
  int black,r=0,v=0,b=0;
  char n;
 
  // Initialisations
  im = gdImageCreateTrueColor(512, 512);
  imout = gdImageCreateTrueColor(512, 512);
  // fond de l'image mis a noir
  black = gdImageColorAllocate(im, 0, 0, 0);
 
  for (x=0;x<gdImageSX(im);x++)
    for (y=0;y<gdImageSY(im);y++)
      { // Genere trois nombres r,v,b entre 0 et 256
    r=(int) (256.0*rand()/(RAND_MAX+1.0));
    v=(int) (256.0*rand()/(RAND_MAX+1.0));
    b=(int) (256.0*rand()/(RAND_MAX+1.0));
    // avec ces trois nombres, on "genere" une couleur
    c= gdImageColorAllocate(im, r, v, b);
    /* NB : Ces 3 lignes pourraient etre condensees en une seule
       car on travaille en "couleur vraie" :
       c=(int) (16777216.0*rand()/(RAND_MAX+1.0));
       "c" est bel et bien un entier entre 0 et 256^3, rien de plus !
       Le gdImageColorAllocate est superflu !
       Pour s'en persuader, printf("R:%d-V:%d-B:%d=>C:%d\n",r,v,b,c);
    */
    // met le pixel en (x,y) a cette couleur
    gdImageSetPixel(im, x, y, c);
      }
 
  // Ecriture de l'image et nettoyage
 
  jpegout = fopen("toto.jpg", "wb");
 
  gdImageJpeg(im, jpegout, -1);
 // monimg =im; //ICI
  monimg.exportimg(imout);
  FILE * sortie;
  sortie= fopen("recup.jpg", "wb");
  //(gdImagePtr im, FILE * out, int quality);
  gdImageJpeg(imout,sortie,10);
 
  fclose(sortie);
  fclose(jpegout);
  gdImageDestroy(im);
  gdImageDestroy(imout);
  system("pause") ;
 
  return 0;
}

--Image.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
38
39
40
41
42
43
44
45
46
47
 
//- la classe image qui est définie par la classe générique matrice avec paramètre d'instanciation la classe pixel
/*
#ifndef IMAGE_H
#define IMAGE_H 
*/
#ifndef H_IMAGE_090526
#define H_IMAGE_090526
 
#include "Matrice.h"
#include "Pixel.h"
 
#include "gd.h"
 
//typedef Matrice<Pixel> t_Cpixelmat;
//template <class T>
class Image : public Matrice <Pixel>
{
    private:
 
//    Matrice<Pixel> matrice_pixel;
 
    public:
    Image(const Image&);
    ~Image(); // dois je detruire matrice_pixel ? ==> non, c'est fait dans la classe mère
 
    //Image(int n, int m) : t_Cpixelmat(n,m) ;
  //   Image(int n, int m) : matrice_pixel ;
      // Image(int n, int m): Matrice <Pixel> (n,m);
        Image(int, int);
 
   /*     //ICI 
     Image& operator=(const image &img)
    {
        if(this != &img)
        {
        matrice_pixel=img.matrice_pixel; //j'utilise le surcharge de l'operateur= de classe matrice ?
        }
        return (*this);
    
    }
    */
 
       exportimg(gdImagePtr pgdimg) ;   
};
 
#endif

--Image.cpp

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
38
39
40
41
42
43
44
45
 
#include "Image.h"
#include "gd.h"
#include "Pixel.h"
#include "Matrice.h"
 
/*
Image::Image(int n, int m) //:Matrice <Pixel> (n,m)
{
Pixel p;
//matrice_pixel M;
 Matrice <Pixel> M;
for(int i=0; i<n;i++)
         (for(int j=0; j<m;j++)
         M(i,j,p=Pixel(0,0,0,0,i,j);
          
}
*/
 
 
Image::Image(int n, int m) 
  :Matrice <Pixel> (n,m)
{
  for(int i=0; i<n;i++)
         for(int j=0; j<m;j++)
           mat[i][j] = Pixel(0,0,0,0,i,j);
}
 
Image::~Image()
{
}
 
void Image::exportimg(gdImagePtr pgdimg)              
{
      int pixel:
      for (int x =0; x<max_de_lignes; x++)
       for  (int y=0 ; y<max_de_colonnes; y++)
            {
                pixel =     mat[i,j].get_R();
                gdImageSetPixel (pgdimg, x,  y, pixel);
            }
 
}
 
//};

--Pixel.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
38
39
40
41
42
43
44
45
46
47
 
//- la classe pixel qui derive de la classe couleur
/*
#ifndef PIXEL_H
#define PIXEL_H
*/
#ifndef H_PIXEL_090526
#define H_PIXEL_090526
#include "Couleur.h"
/*
class Pixel //: public Couleur
{
//private:
protected:
unsigned int X; //abscisse
unsigned int Y; //coordonnée
 
Couleur couleur;
public:
 
   
    //Pixel() : Couleur(0,0,0,0) { X = Y = 0; }
    Pixel(unsigned int x, unsigned int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a )  
        : X(x), Y(y), couleur(r,g,b,a)
    {
    
    }
 
};
*/
 
class Pixel : public Couleur {
  //private:
  protected:
    unsigned int X; //abscisse
    unsigned int Y; //coordonnée
 
  public:
 
    //Pixel() : Couleur(0,0,0,0) { X = Y = 0; }
 
    Pixel(unsigned int x, unsigned int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a /*= 0*/) : Couleur(r,g,b,a), X(x), Y (y) {}
};  // class Pixel
 
 
 
#endif

--Matrice.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
38
39
40
41
42
43
44
45
46
 
/*
#ifndef MATRICE_H
#define MATRICE_H
*/
#ifndef H_MATRICE_090526
#define H_MATRICE_090526
 
 
template <class T>
class Matrice
{
protected:
 
T **mat;
 
int max_de_lignes;
int max_de_colonnes;
int nombre_de_lignes;
int nombre_de_colonnes;
 
public:
 
Matrice(int n,int m)
{
    max_de_lignes=n,
    max_de_colonnes=m;
    nombre_de_lignes=0;
    nombre_de_colonnes=0;
    mat=new T*[max_de_lignes];
    for(int i=0;i<max_de_lignes;i++)
    mat[i] = new T[max_de_colonnes];
}
 
~Matrice()
{
    for(int i=0;i<max_de_lignes;i++)
    {
        delete[] mat[i];
    }
    delete[] mat;
}
 
};
 
#endif

--Couleur.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
38
39
40
41
42
 
/*
#ifndef COULEUR_H 
#define COULEUR_H 
*/
 
#ifndef H_COULEUR_090526
#define H_COULEUR_090526
 
class Couleur
{
protected:
 
    unsigned char R, G, B; //(ou l'inverse ... à voir plus tard);
    //unsigned char V[4];
    //unsigned long Col;
 
public:
 
 
 void  set(    unsigned char Rp,unsigned char Gp,unsigned char Bp)
          { R = Rp;
          G =Gp;
          B= Bp;
 
                }
 unsigned char get_R()
           { return R;               }
 
 unsigned char get_G()
  { return G;               }
 unsigned char get_B()
  { return B;               }
 
 unsigned int get_color() //32 bits
 {
          return ( (unsigned long)R << 16 | (unsigned long)G << 8 | (unsigned long)B);
 } 
Couleur() { R = G = B = 0; }
Couleur(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 0) { set(r, g, b);}
};
#endif

Maintenant je voudrais ajouter une méthode FusionImg() pour additionner 2 images et sauver le resultat sur un autre fichier image par exemple, ici il faut surcharges de l'opérateur + (addionner les 2 photos).

Ainsi qu'une méthode DiminutionImg() qui permet de diminuer la taille de l'image ici il faut surcharges de l'opérateur / .

Pourriez vous m'aider pour ces 2 méthodes ? Et j'ai fait pour l'opérateur = une surcharge ( voir commentaires //ICI dans fichiers main.cpp et Image.h ) mais j'ai mis en commentaire car ça donne des erreurs de compils ?

Merci

26/05/2009, 17h03
3DArchi
Citation:

Envoyé par Aliveli

Je ne vois pas comment Image.cpp ne peut pas fairepartit du projet ?? etant donné que dansce projet j'appelle le header Image ??

Que tu fasses un include du header ne veut absolument pas dire que le .cpp correspondant va être compilé (traité récemment)
Citation:
Envoyé par Aliveli

Actuellement je n'ai qu'une erreur:

Code:

1 2 Image.h:30: error: ISO C++ forbids declaration of `exportimg' with no type

image.h :

Code:

1 2 3 4 5 class Image : public Matrice <Pixel> { /* ... */ exportimg(gdImagePtr pgdimg) ; };
Il me semble que l'erreur est assez explicite, non ? Tu n'as pas défini de type retour pour ta fonction exportimg.

Ok,

Je vois plus clair maintenant effectivement en ayant ajouté dans le workspace de mon projet le fichier Image.cpp

j'ai d'autres comportements :

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
 
Compiler: Default compiler
Building Makefile: "C:\mygd\gdtestpng\Makefile.win"
Executing  make...
make.exe -f "C:\mygd\gdtestpng\Makefile.win" all
g++.exe -c Image.cpp -o Image.o -I"C:/Dev-Cpp/lib/gcc/mingw32/3.4.2/include"  -I"C:/Dev-Cpp/include/c++/3.4.2/backward"  -I"C:/Dev-Cpp/include/c++/3.4.2/mingw32"  -I"C:/Dev-Cpp/include/c++/3.4.2"  -I"C:/Dev-Cpp/include"  -I"C:/mygd/gd-latest-win32/include"  -I"C:/mygd/gd_build_win32_deps/gd_deps/include"   
 
In file included from Image.cpp:1:
Image.h:43: error: ISO C++ forbids declaration of `exportimg' with no type
 
Image.cpp:33: error: prototype for `void Image::exportimg(gdImage*)' does not match any in class `Image'
 
Image.h:43: error: candidate is: int Image::exportimg(gdImage*)
Image.cpp:33: error: `void Image::exportimg(gdImage*)' and `int Image::exportimg(gdImage*)' cannot be overloaded
Image.cpp: In member function `void Image::exportimg(gdImage*)':
Image.cpp:34: error: expected primary-expression before "int"
Image.cpp:34: error: expected `;' before "int"
Image.cpp:35: error: `x' undeclared (first use this function)
Image.cpp:35: error: (Each undeclared identifier is reported only once for each function it appears in.)
Image.cpp:35: error: expected `;' before ')' token
Image.cpp:36: error: `y' undeclared (first use this function)
 
Image.cpp:36: error: expected `;' before ')' token
Matrice.h: In constructor `Matrice<T>::Matrice(int, int) [with T = Pixel]':
Image.cpp:22:   instantiated from here
Matrice.h:31: error: no matching function for call to `Pixel::Pixel()'
Pixel.h:31: note: candidates are: Pixel::Pixel(const Pixel&)
Pixel.h:41: note:                 Pixel::Pixel(unsigned int, unsigned int, unsigned char, unsigned char, unsigned char, unsigned char)
 
make.exe: *** [Image.o] Error 1
 
Execution terminated

Mais ça devient plus lourd avec tous les interactions avec les classes ?