D�finition d'un tableau d'�l�ments de type "classe template"

**antoine.lolo** · 22/04/2013, 22h16

Bonjour � tous,

ma ma�trise limit�e du c++ et de ses rouages m'emp�chent de d�buguer mon code avec succ�s, j'en appelle donc � la communaut� en esp�rant ne pas trop vous emb�ter et apprendre de mes erreurs

.

Pour essayer de d�crire ma situation succintement, j'ai d�fini une template classe que j'ai nomm�e image:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
template <classe T>
class image {
 public: 
 
// diverses méthodes...
 
T *data;
 
 private:
int width, height;
}

Ensuite, je d�fini une structure rgb, me permettant de travailler avec des images "triples" (3 composantes ou bandes).

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
typedef struct { 
	uchar r, g, b; 
} rgb;

Que je manipule dans mes fonctions principales de la mani�re suivante (je n'�cris ici que la ligne d'allocation m�moire et le remplissage, je vous �pargne la d�finition d'imRef qui n'a pas d'importance ici):

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
image<rgb>* im = new image<rgb>(width, height);
 
// quelque part plus loin ...
 
 image<float> *red = new image<float>(width, height); 
 image<float> *green = new image<float>(width, height); 
 image<float> *blue = new image<float>(width, height);
 
  for (int y = 0; y < height; y++) {
    for (int x = 0; x < width; x++) {
      imRef(red, x, y) = imRef(im, x, y).r;	  //remplissage
      imRef(green, x, y) = imRef(im, x, y).g;	
      imRef(blue, x, y) = imRef(im, x, y).b;	
    }
  }

Jusqu'ici tout va bien ! Maintenant mon probl�me est que je cherche une solution pour travailler avec des images qui n'ont plus 3 composantes, mais un certain nombre N (N>>3). Chacune de ces composantes est � proprement dit une image elle-m�me, de taille constante width*height.
Je cherche donc � d�finir un "tableau de tableau" de mani�re � r�cup�rer un pointeur, que j'appelle bands, me permettant d'acc�der via bands[i] � la composante n�i de mon image.

J'ai donc fonctionn� en d�finissant une autre structure hyperSpec de la sorte:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
typedef struct {
	uchar *bands;
} hyperSpec;

Que je veux ensuite utiliser comme ceci:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
image<hyperSpec>* theIm = new image<hyperSpec>(width, height);
 
//quelque part plus loin ...
 
image<float> *b[num_bands] = new image<float>(width, height); // erreurs de compilation ici
 
for (int i = 0; i<num_bands; i++){
	 for (int y = 0; y < height; y++) {     // remplissage
	     for (int x = 0; x < width; x++) {
			 imRef(b[i], x, y) = imRef(im,x,y).bands[i] ; // erreurs de compilation ici
		 }
     }
  }

L'id�e �tant, apr�s remplissage, de r�cup�rer les composantes via b[i].

Mais ces derni�res lignes de code me renvoie des erreurs de compilation que je n'arrive pas � corriger. Ces erreurs sont les suivantes :

- expected constant expression
- cannot allocate an array of constant size 0
- 'b' : array initialization needs curly braces
- 'new' : 'image<T>' no default constructor to initialize arrays of objects
with
[
T=float
]

J'ai essay� de ne mettre que le strict minimum de code tout en essayant d'�tre clair sur mon probl�me, si ce n'est pas le cas n'h�sitez pas � me demander des compl�ments.

Merci d'avance

**Emmanuel Deloget** · 23/04/2013, 01h31

On va essayer de te faire deviner tout seul.

Que fait la ligne suivante ?

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

image<float> *b[num_bands] = new image<float>(width, height);

(je te laisse r�fl�chir un peu...)

Elle d�clare un tableau d'image<float> et affecte � ce tableau l'adresse retourn�e par new image<float>. Hors, le tableau a d�j� une adresse.

Deux solutions : soit tu cherches � allouer un tableau, auquel cas il faut passer par un pointeur de pointeur et l'op�rateur new[] (std::vector<> serait certainement plus appropri�).

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
// pas beau
image<float> **b = new image<float>[num_bands](width, height);
// mieux
std::vector<image<float> *> b(num_bands);
// la boucle est là pour expliciter l'initialisation. 
// il serait préférable d'utiliser un algorithme, ou de voir du coté
// de C++11 et de ses apports en la matière. 
for (size_t n=0; n < b.size(); ++n) {
   b[n] = new image<float>(width, height);
}

Soit tu cherches � allouer l'une des entr�es du tableau, auquel cas (c'est le sens du message d'erreur) tu dois �crire :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

image<float> *b[num_bands] = { new image<float>(width, height) }

Ce qui n'a gu�re de sens non plus, mais au moins, �a compile

**Ehonn** · 23/04/2013, 08h53

Le code est inutilement compliqu�...
L'allocation dynamique et les pointeurs (g�r�s par l'utilisateur) sont (une fois de plus) inutiles ici.

Apparemment, tu as besoin d'une classe image, qui ressemble � beaucoup � ce que j'appelle un vector2D (j'ai fait un copier coller super minimal de ma classe).

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
// Minimal encapsulation for a linear vector2D
template <class T>
class vector2D
{
private:
 
	std::size_t m_nb_row;
 
	std::size_t m_nb_col;
 
	std::vector<T> m_data;
 
public:
 
	vector2D(std::size_t const nb_row = 0, std::size_t const nb_col = 0 , T const & default_value = T())
		: m_nb_row(nb_row), m_nb_col(nb_col), m_data(m_nb_row * m_nb_col, default_value)
	{ }
 
	std::size_t nb_row() const { return m_nb_row; }
 
	std::size_t nb_col() const { return  m_nb_col; }
 
	T & operator()(std::size_t const i, std::size_t const j)
	{
		return m_data[i * m_nb_col + j];
	}
 
	// Ceci est un foncteur http://cpp.developpez.com/faq/cpp/?page=STL#STL_functor
	T const & operator()(std::size_t const i, std::size_t const j) const
	{
		return m_data[i * m_nb_col + j];
	}
};

Tu as une classe pour g�rer la couleur (qui ressemble beaucoup � une classe g�n�ralement appel� vector3, mais on �crit la classe qui va bien pour avoir les attributs r g b au lieu de x y z).
Au passage : FAQ C++ - Quelle est la diff�rence entre class et struct ?

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
// Color red, green, blue (values between 0 and 255)
class color
{
public:
 
	unsigned char r;
	unsigned char g;
	unsigned char b;
 
	explicit color(unsigned char const r = 0, unsigned char const g = 0, unsigned char const b = 0) :
		r(r), g(g), b(b)
	{ }
};
 
std::ostream & operator << (std::ostream & o, color const & c)
{
	o << "{";
	o.width(3); o << int(c.r) << ", ";
	o.width(3); o << int(c.g) << ", ";
	o.width(3); o << int(c.b);
	o << "}";
	return o;
}

Maintenant, si tes images ont N composantes, il suffit de d�clarer :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

vector2D<classe_a_n_composantes> im(10, 5);

ou de fa�on g�n�rale, on peut utiliser un std::vector

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

vector2D<std::vector<int>> im(10, 5, std::vector<int>(N));

On peut imaginer que �classe_a_n_composantes� soit telle quelle :

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
// vector 5
template <class T>
class vector5
{
public:
 
	T v;
	T w;
	T x;
	T y;
	T z;
 
	explicit vector5(T const & v = T(), T const & w = T(), T const & x = T(), T const & y = T(), T const & z = T()) :
		v(v), w(w), x(x), y(y), z(z)
	{ }
};
 
template <class T>
std::ostream & operator << (std::ostream & o, vector5<T> const & v)
{
	o << "{";
	o.width(3); o << int(v.v) << ", ";
	o.width(3); o << int(v.w) << ", ";
	o.width(3); o << int(v.x) << ", ";
	o.width(3); o << int(v.y) << ", ";
	o.width(3); o << int(v.z);
	o << "}";
	return o;
}

On peut maintenant �crire un programme simple qui fait ce que tu veux (je te laisse recopier les classes pr�c�dentes).

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
// g++ -Wall -Wextra -pedantic -O3 image.cpp -o image && ./image
 
#include <vector>
#include <cstdlib>
#include <iostream>
 
// Minimal encapsulation for a linear vector2D
// ...
// Color red, green, blue (values between 0 and 255)
// ...
// vector 5
// ...
 
int main()
{
	// Initialisation de la graine pour les nombre pseudo aléatoire
	srand(0);
 
	// N = 3, color
	{
		// Déclaration d'une image 10 x 5
		vector2D<color> im(10, 5);
 
		// Remplissage de l'image avec des coleurs pseudo-aléatoires
		for (std::size_t i = 0; i < im.nb_row(); ++i)
		{
			for (std::size_t j = 0; j < im.nb_col(); ++j)
			{
				// Affectation membre à membre
				im(i, j).r = rand() % 256;
				im(i, j).g = rand() % 256;
				im(i, j).b = rand() % 256;
				// Utilisation de l'opérateur =
				im(i, j) = color(rand() % 256, rand() % 256, rand() % 256);
			}
		}
 
		// Affichage
		for (std::size_t i = 0; i < im.nb_row(); ++i)
		{
			for (std::size_t j = 0; j < im.nb_col(); ++j)
			{
				std::cout << im(i, j) << " ";
			}
			std::cout << std::endl;
		}
	}
	std::cout << std::endl;
 
	// N = 5 composantes avec une classe spécifique
	{
		// Déclaration d'une image 10 x 5
		vector2D< vector5<int> > im(10, 5);
 
		// Remplissage de l'image avec des coleurs pseudo-aléatoires
		for (std::size_t i = 0; i < im.nb_row(); ++i)
		{
			for (std::size_t j = 0; j < im.nb_col(); ++j)
			{
				im(i, j) = vector5<int>(rand() % 256, rand() % 256, rand() % 256, rand() % 256, rand() % 256);
			}
		}
 
		// Affichage
		for (std::size_t i = 0; i < im.nb_row(); ++i)
		{
			for (std::size_t j = 0; j < im.nb_col(); ++j)
			{
				std::cout << im(i, j) << " ";
			}
			std::cout << std::endl;
		}
	}
	std::cout << std::endl;
 
	// N = 4 composantes avec std::vector
	{
		// Déclaration d'une image 10 x 5
		vector2D< std::vector<int> > im(10, 5, std::vector<int>(4));
 
		// Remplissage de l'image avec des coleurs pseudo-aléatoires
		for (std::size_t i = 0; i < im.nb_row(); ++i)
		{
			for (std::size_t j = 0; j < im.nb_col(); ++j)
			{
				for (std::size_t n = 0; n < im(i, j).size(); ++n)
				{
					im(i, j)[n] = rand() % 256;
				}
			}
		}
 
		// Affichage
		for (std::size_t i = 0; i < im.nb_row(); ++i)
		{
			for (std::size_t j = 0; j < im.nb_col(); ++j)
			{
				std::cout << "{";
				for (std::size_t n = 0; n < im(i, j).size(); ++n)
				{
					std::cout.width(3); std::cout << im(i, j)[n];
					if (n != im(i, j).size() - 1) { std::cout << ", "; }
				}
				std::cout << "} ";
			}
			std::cout << std::endl;
		}
	}
	std::cout << std::endl;
 
	return 0;
}

Et voici l'ex�cution qui correspond :

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
{255,  81, 115} {171, 186, 205} {194, 124,  70} {141, 231, 232} {159,  51,  99} 
{183,  13,  50} { 93,  37,  90} {212,  94, 233} {180, 155, 198} { 65, 116, 130} 
{233, 112, 135} {103, 252, 225} {220, 234, 151} { 42,  92,  56} {175,  50, 251} 
{ 92, 219,  24} {250, 251,  67} {230, 209,  41} {216, 117, 148} {187,  92, 249} 
{235, 177, 149} {  0, 247, 239} { 11, 202, 229} {189, 100,  71} {123,  28, 168} 
{197,  90, 115} {112,  59,  99} {220,   9, 158} { 16,  27, 242} { 80, 227, 205} 
{111, 187,  92} {245, 125, 155} { 35, 127,  28} { 19,  27, 164} { 50, 152, 232} 
{ 52,  61,  77} {203, 250, 119} { 43,  33, 134} {112, 190, 162} {211,  92,   4} 
{240, 226, 175} { 73,  21,  50} {112,   8, 169} { 72,  84,  41} { 24,  14, 213} 
{142, 243,  91} { 66,   9, 155} {205, 175,  51} {212, 173,  45} {236,  28,  50} 
 
{ 32, 246,  48, 196,  74} {178, 251, 108, 133,  35} { 11, 236, 244,   4,   7} {195, 134, 186,  32, 185} {217, 236, 241,   5,  62} 
{ 80, 153, 183,  51, 103} {217, 211,  20, 227, 163} {242, 160,  94, 247,  52} {148,   5, 246, 168,  16} { 68, 188, 180, 190,   1} 
{230, 105,  73, 250, 120} {105, 218,  26, 208,  35} { 81, 126,  76, 126, 106} { 83, 132,  72, 179,  37} {153,  49, 251, 148,  58} 
{238,  68,  87,  50, 144} { 37, 229, 233, 188, 155} {226, 233, 245,   8, 207} {210, 170,  96,  83,  94} { 84, 250, 133, 208, 178} 
{102, 212, 232,  53, 216} {168, 217, 152, 100, 130} { 90, 112, 101, 117, 135} { 41, 128,  98,  63, 138} {137, 165, 124, 222,  68} 
{ 81, 211,  89,  87,  78} {128, 149, 134, 172, 173} {241, 133, 228,  23, 236} {124, 241, 102,  12, 140} {252,  34, 187, 124, 192} 
{ 11,  97, 218, 102, 228} {131, 188,  98, 175,  99} {255,  58,  47, 105, 180} {172, 147,  22,  39, 175} { 17, 109, 184,  31,   7} 
{ 79, 239, 141,  45,  52} { 53,  99, 182, 212, 137} {131,  36, 228, 199, 193} { 18, 150, 237, 216, 103} {216,   2,  57,  69, 236} 
{119, 157, 248,  10, 229} {193, 150, 165, 209,   9} {130, 170, 149,  31, 244} {144, 174,  73, 108, 202} {172, 186, 104,  22, 205} 
{168, 180, 242, 166, 122} { 55, 194, 178, 153, 202} { 97, 207,   8, 203,  42} {110,  94, 128, 195, 201} {215,  76, 218,  40,   3} 
 
{106,  25, 237, 210} {211, 153,  76, 121} {139,   0,  34,  86} {154, 212,  24, 209} {254, 228, 217, 205} 
{ 69, 163, 145, 198} {  1, 255, 201,  42} {217,  21,   1,  67} { 47, 238,  21,   2} {135,  97, 124,  19} 
{ 98, 158, 105, 252} {114, 129, 205, 113} {101, 166,  62, 171} { 73, 207, 113,  75} {206,  58, 117, 167} 
{ 79, 118, 234, 126} {100, 255, 129, 235} { 97, 253, 254, 195} {155, 103, 191,  13} {233, 140, 126,  78} 
{ 50, 189, 249, 124} {140, 106, 199,  91} {164,  60,   2, 244} {178, 237, 114,  22} {236, 243,   1,  77} 
{240,   0,  16, 139} {103, 207, 153,  80} { 91,  23, 159, 142} {212, 152,  10,  97} {  3, 209, 188, 167} 
{ 13, 190, 155, 191} {171,  14, 213, 152} {  1, 214, 229, 242} {214, 246, 125,  62} {197,  22, 142,  33} 
{ 46,  45, 175,   2} {198, 185,  99, 201} {138,  31, 112, 151} {222,  12,  86, 137} { 26,  43,  33,  27} 
{  1,   7,  13, 216} {253, 139,  22, 194} {161, 164, 227, 207} {210, 146, 210, 152} { 75,  53,  97, 213} 
{ 85, 209, 108,  51} {221, 194, 188, 247} {237, 222,  19, 239} {229,  32, 199, 226} {171, 221, 164,  77}

Je te laisse le soin d'adapter vector2D pour en faire une classe image avec une hauteur et une largeur. De la m�me fa�on on pourrait s�rement simplifier vector2D< vector5<int> > et vector2D< std::vector<int> > avec des typedef.

**antoine.lolo** · 23/04/2013, 19h07

Ok. D�j� merci beaucoup pour vos r�ponses

!

La manipulation des structures types containers en c++ et tout ce qui avec avec (manipulation de la STL, compr�hension pr�cise des pointeurs etc...) est assez nouveau pour moi et je dois dire que c'est pas ce que je pr�f�re

soit tu cherches � allouer un tableau, auquel cas il faut passer par un pointeur de pointeur et l'op�rateur new[]
Soit tu cherches � allouer l'une des entr�es du tableau

En fait mon id�e �tait simple. Ecrire dans la m�moire les bandes de l'image � la suite les unes apr�s les autres et me balader dedans gr�ce � un pointeur, en l'occurence un pointeur sur le premier �l�ment du tableau. Donc c'est v�ritablement �a que je cherchais � faire:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

image<float> *b[num_bands] = { new image<float>(width, height) } ; //sans oublier le ;

Par contre, cette ligne en question ne compile pas avec succ�s telle qu'elle. L'utilisation de num_bands lui pose un probl�me :

error C2466: cannot allocate an array of constant size 0

Si je remplace num_bands par un entier d�fini (5 par exemple), pas de soucis. D'o� vient le probl�me ? Il me semble que c'est tout � fait possible de cr�er un tableau dont la taille est d�finie par une des entr�es de la fonction (c'est le cas ici, num_bands est une entr�e de la fonction o� la ligne pr�cdente est �crite) ...

Le code est inutilement compliqu�...

Oui... Pour tout vous dire je travaille sur un code d�j� �crit que je me contente de modifier. Plus le temps passe et plus je me dis que j'aurais simplement d� tout r��crire moi-m�me, cela m'aurait caus� moins de soucis !

La classe vector2D que tu me pr�sente ici ressemble en effet � la classe image que j'ai d�finie. Toutefois, il y a des choses que je ne comprends pas vraiment.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
	T & operator()(std::size_t const i, std::size_t const j)
	{
		return m_data[i * m_nb_col + j];
	}

Cette m�thode te permet de surcharger l'op�rateur "appel de fonction" , (), pour r�cup�rer les infos... C'est flou pour moi, je ne comprends pas l'int�r�t ni l'utilisation.

Sinon l'utilisation de std::vector semble plus pertinente en effet, comme vous l'avez tous les deux remarqu�.

Pour la suite j'ai bien compris ton id�e, mais elle ne r�soud pas mon "probl�me" de base, qui est celui de manipuler facilement un grand nombre de bandes, et quand je dis grand nombre, je ne pense pas � 4 ou 5, mais plut�t � 103 (le jeu de donn�es sur lequel j'essaie de travailler). A cette dimension, cr�er une classe qui a autant d'attributs que de composantes devient impossible � �crire et � manipuler, d'o� mon id�e d'un pointeur unique...

**Ehonn** · 23/04/2013, 19h23

Envoy� par antoine.lolo

Cette m�thode te permet de surcharger l'op�rateur "appel de fonction" , (), pour r�cup�rer les infos... C'est flou pour moi, je ne comprends pas l'int�r�t ni l'utilisation.

Il s'agit d'un foncteur. Contrairement � [], () peut prendre autant de param�tres que tu veux. Cela est pratique pour prendre i et j en m�me temps.
FAQ C++ - Qu'est-ce qu'un foncteur ?
FAQ C++ - Pourquoi est-il pr�f�rable que l'interface de ma classe Matrix ne soit pas bas�e sur le mod�le du tableau de tableaux ?
Pour l'utilisation, voir l'exemple dans le main (...)

Envoy� par antoine.lolo

Pour la suite j'ai bien compris ton id�e, mais elle ne r�soud pas mon "probl�me" de base, qui est celui de manipuler facilement un grand nombre de bandes, et quand je dis grand nombre, je ne pense pas � 4 ou 5, mais plut�t � 103 (le jeu de donn�es sur lequel j'essaie de travailler). A cette dimension, cr�er une classe qui a autant d'attributs que de composantes devient impossible � �crire et � manipuler, d'o� mon id�e d'un pointeur unique...

Relis bien ma derni�re solution dans le main, elle r�sout ton probl�me.

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
// N = 103 composantes avec std::vector
{
	// Déclaration d'une image 10 x 5
	vector2D< std::vector<int> > im(10, 5, std::vector<int>(103));
 
	// Remplissage de l'image avec des coleurs pseudo-aléatoires
	for (std::size_t i = 0; i < im.nb_row(); ++i)
	{
		for (std::size_t j = 0; j < im.nb_col(); ++j)
		{
			for (std::size_t n = 0; n < im(i, j).size(); ++n)
			{
				im(i, j)[n] = rand() % 256;
			}
		}
	}
 
	// Affichage
	for (std::size_t i = 0; i < im.nb_row(); ++i)
	{
		for (std::size_t j = 0; j < im.nb_col(); ++j)
		{
			std::cout << "{";
			for (std::size_t n = 0; n < im(i, j).size(); ++n)
			{
				std::cout.width(3); std::cout << im(i, j)[n];
				if (n != im(i, j).size() - 1) { std::cout << ", "; }
			}
			std::cout << "} ";
		}
		std::cout << std::endl;
	}
}

Tu noteras qu'on peut remplacer vector2D< std::vector<int> > im(10, 5, std::vector<int>(103)); par std::vector<std::vector<std::vector<int> > > im(10, std::vector<std::vector<int>>(5, std::vector<int>(103))).
Les acc�s im(i, j)[n] seront remplac�s par im[i][j][n].
L'int�r�t principal de passer par une classe image est de fournir une information pour le programmeur par le type (et d'all�ger la syntaxe au passage).

**antoine.lolo** · 23/04/2013, 19h29

En effet.

Je vais aller regarder �a de plus pr�s et me creuser un peu la t�te, je reviens vers vous si j'ai encore des difficult�s.

Merci

D�finition d'un tableau d'�l�ments de type "classe template"

C++

Vue hybride

Discussions similaires

Partager

Partager