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

Version imprimable

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 :aie:.

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

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:

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:

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:

1 2 3 typedef struct { uchar *bands; } hyperSpec;
Que je veux ensuite utiliser comme ceci:
Code:

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 :

Citation:

- 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

On va essayer de te faire deviner tout seul.

Que fait la ligne suivante ?

Code:

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:

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:

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 :)

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:

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:

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:

vector2D<classe_a_n_composantes> im(10, 5);

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

Code:

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

On peut imaginer que «classe_a_n_composantes» soit telle quelle :

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
// 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:

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:

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.

23/04/2013, 19h07
antoine.lolo
Ok. Déjà merci beaucoup pour vos réponses :ccool: !

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 :aie:

Citation:

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:

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 :

Citation:

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) ...

Citation:

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:

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...

Citation:

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 (...)

Citation:

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:

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).

23/04/2013, 19h29
antoine.lolo

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 :ccool: