Initialisation d'un vector a 3 dimensions

Version imprimable

19/05/2011, 16h20
AirSounet

Initialisation d'un vector a 3 dimensions

Bonjour,

Je vous expose mon problème:
J'aimerais créer un tableau d'entiers 3D en utilisant la classe vector, cependant je n'arrive pas a l'initialiser correctement.
Je connais les 2 premières dimensions qui sont égales a 2 mais j'ai a priori aucune information de la dernière dimension.
De plus j'aimerais initialise ce tableau avec uniquement des -1.

Pourriez-vous m'expliquer comment faire ?
Je vous remercie !
19/05/2011, 16h43
Nhaps

Dans la doc il y a tout ce qu'il te faut par contre je ne comprend pas d'où tu sors tes coordonnés ? d'un vector ? ou d'un autre conteneur ?

sinon pour initialiser un vector à la création :

Code:

vector<Type> nom (nb_case, valeur_par_default);
20/05/2011, 09h39
AirSounet

Merci Tooxx !

Cependant quand j'utilise la commande pour initialiser mon vector :

Code:

vector<vector< vector<int> > > Tab(1,-1);

J'ai une erreur de ce type:
terminate called after throwing an instance of 'std::bad_alloc'
what(): St9bad_alloc
Aborted

En fait ce que j'aimerais faire c'est que Tab soit une matrice 2x2 avec une profondeur variable sachant que j'aimerais fixer la profondeur a "0" case et remplir Tab avec des -1. Ceci dans l'optique d'utiliser la méthode push_back pour changer ma profondeur.

Merci encore de ton aide. :)
20/05/2011, 10h03
Nhaps

ouch un vector de vector de vector.... :aie:

Je pense que tu peux créer une classe Matrice tu auras ainsi un

Code:

vector<Matrice> Tab;

tu crées tes objets Matrice comme tu veux.

Code:

Matrice m;

et tu peux quand même faire des push_bach

Code:

Tab.push_back(m);

j’espère t'avoir aidé un minimum

Jo'
20/05/2011, 10h28
AirSounet

Et oui un vector de vector de vector ! :mrgreen:

Oui je pourrai créer une classe comme tu le dis mais le fait est que j'utilise ce triple vector une seule fois dans mon code donc je n'ai pas trop envie de me lancer la dedans....

Il me suffirait uniquement de savoir comment écrire l'initialisation sachant que pour un vector de vector je n'ai pas de probleme :?

Merci encore !
20/05/2011, 10h59
dasycarpum
Citation:

Envoyé par AirSounet

Et oui un vector de vector de vector ! :mrgreen:

Il me suffirait uniquement de savoir comment écrire l'initialisation sachant que pour un vector de vector je n'ai pas de probleme :?

Merci encore !

Tu peux essayer ça : chez moi ça marche sans problème...
Code:

1 2 3 4 5 6 7 vector<vector<vector<int> > > Tab(10); for (int i = 0; i < 10; ++i) for (int j = 0; j < 10; ++j) for (int k = 0; k < 10; ++k) Tab[i][j][k] = -1;
20/05/2011, 11h25
AirSounet

Merci dasycarpum !

Par contre moi ce ne fonctionne pas... j'obtiens une erreur de segmentation :aie:
Pour moi la dimension sur k serait de 1 et la dimension sur i et j serait égale a 2.
Aurais-tu une autre façon de faire ?

Je te remercie.
20/05/2011, 13h24
dasycarpum

Citation:

Envoyé par AirSounet

Merci dasycarpum !

Par contre moi ce ne fonctionne pas... j'obtiens une erreur de segmentation :aie:
Pour moi la dimension sur k serait de 1 et la dimension sur i et j serait égale a 2.
Aurais-tu une autre façon de faire ?

Je te remercie.

Un vector 3D c'est comme un parallélépipède de dimension i * j * k : si tu mets k = 1, il n'y a forcément plus que 2 dimensions... et tu as un rectangle i * j ! C'est sans doute ça qui doit coincer, et sur le fond, le compilateur a raison : un vector 3D dont une dimension = 1 c'est un vector 2D :?

Salut,

Pourquoi ne pas faire:
Code:

1 2 3 4 5 6 7 8 9 10 int width = 10; int height = 10; int depth = 10; int defaultValue = 42; std::vector<int> v(width*height*depth, defaultValue); // accède a l'element (i,j,k) int ijk = v[k * width * height + j * width + i];
Ok, c'est moins claire à l'utilisation (au pire on peu faire une petit fonction/macro pour acceder a l'élément ijk) mais niveau perf c'est autre chose qu'un vecteur de vecteur de vecteur :ccool:

La bonne façon de faire cela, c'est de créer une classe dédiée (template c'est encore mieux), par exemple Matrice3D. Cette classe possèderait un vecteur et des accesseurs/mutateurs simples.

Cette classe ressemblerait à quelque chose 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
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
#include <vector>
#include <iostream>
 
using namespace std;
 
template <typename T>
class Matrice3D
{
private:
	vector< T > buffer;
	size_t size_i, size_j, size_k;
 
public:
	// constructeur
	Matrice3D( size_t size_i, size_t size_j, size_t size_k )
		: size_i( size_i )
		, size_j( size_j)
		, size_k( size_k )
		, buffer( std::vector<T>( size_i * size_j * size_k ) )
 
	{}
 
	// mutateur
	T & operator() ( size_t i, size_t j, size_t k )
	{
		return buffer[ i + size_i*j + (size_i * size_j) * k ];
	}
 
	// accesseur
	const T & operator() ( size_t i, size_t j, size_t k ) const
	{
		return buffer[ i + size_i*j + (size_i * size_j) * k ];
	}
 
};
 
int main(int argc, char** argv)
{
	Matrice3D<int> matrice( 2, 3, 4 ); // creation d'un matrice 3d de taille (2,3,4)
 
	// remplissage de la matrice (utilisation du mutateur)
	for ( size_t i=0; i<2; ++i )
		for ( size_t j=0; j<3; ++j )
			for (size_t k=0; k<4; ++k )
				matrice( i, j, k ) = (int) ( i + j * k + 3 ) % 10;
 
	// affichage de la matrice (utilisation de l'accesseur)
	for (size_t k=0; k<4; ++k )
	{
		for ( size_t j=0; j<3; ++j )
		{
			for ( size_t i=0; i<2; ++i )
			{
				cout << matrice( i, j, k );
			}
			cout << endl;
		}
		cout << endl << endl;
	}
 
	cout << "end" << endl;
	cin.get(); // attente que l'utilisateur appuie sue la touche entrée
	return 0;
}

output de ce programme:

Citation:

34
34
34

34
45
56

34
56
78

34
67
90

end

Hope it helps.

20/05/2011, 17h10
pyros

Créer une classe est la méthode la plus propre, mais comme l'a dit AirSounet, pour un truc utilisé une seul fois dans le code ça soule un peu de créer une classe pour ça.
20/05/2011, 17h16
r0d

Citation:

Envoyé par pyros

Créer une classe est la méthode la plus propre, mais comme l'a dit AirSounet, pour un truc utilisé une seul fois dans le code ça soule un peu de créer une classe pour ça.

Et pourtant, vu de coût de création d'une classe (créer 2 fichiers et les ajouter au projet, et pis, dans ce cas, seul le fichier .h suffit puisque c'est une classe template), le gain est énorme. On y gagne en lisibilité, en sémasiologie, en modularité, en maintenance et en réusabilité. Autrement dit, c'est une excellente pratique (encore mieux qu'une bonne pratique).

Citation:

Mon collocataire fait un café dégueulasse. Quand je le lui dit, il me répond "mais au moins je fais le café". Il a raison, mais du coup il n'apprendra jamais à faire du bon café.

(traduction libre d'une citation célèbre en espagnol)
21/05/2011, 16h20
Joel F

chaque fois que je vois des acces multidimensionel avec un polynome d'acces, je pleure interieurement. google vector de iliffe et tableau NRC :o
21/05/2011, 19h18
Davidbrcz

Citation:

Envoyé par Joel F

chaque fois que je vois des acces multidimensionel avec un polynome d'acces, je pleure interieurement. google vector de iliffe et tableau NRC :o

Tu peux détailler en quoi un vector de iliffe est mieux ? N indirection coûtent moins chères (en temps CPU) qu'un calcul polynômial d'ordre N sur des entiers ? (je demande ca car j'y connais presque rien là dessus)

Et j'ai jamais lu Numerical recipes, tu peux détailler aussi les tableaux NRC ?
21/05/2011, 21h45
Invité
Citation:

Envoyé par Davidbrcz

Et j'ai jamais lu Numerical recipes, tu peux détailler aussi les tableaux NRC ?

Les tableaux Numerical Recipes, ce sont des cas particulier des vecteurs de Iliffe. En gros, un vecteur de Iliffe représente une matrice par N pointeurs sur ses colonnes. Un truc du genre
Code:

1 2 double **mat=new double*[NbCol]; for(int i=0;i<NbCol;i++) mat[i]=new double[NbLig];
Un tableau NR implémente cela de façon contigue :
Code:

1 2 3 double **mat=new double*[NbCol]; mat[0]=new double[NbCol*NbLig]; for(int i=1;i<NbCol;i++) mat[i]=mat[i-1]+NbLig;
A l'origine, le tableau NumRec était un peu plus compliqué, car il était implémenté en base d'index 1... (tu mettais mat[1][1] pour accéder à l'élément qu'en C et en C++ on appelle habituellement mat[0][0])

Sur l'aspect polynomial, le gain est moins une affaire de vitesse de calcul que de flexibilité du tableau... Un tableau à acces polynomial devra être rectangulaire, un tableau représenté par indirection pourra avoir une forme quelconque (dans l'exemple précédent, rien n'oblige NbLig à être constant...)

Egalement, si tes matrices sont en lecture seule, la représentation de Iliffe peut parfois permettre de les stocker de manière très compacte. Par exemple, tu n'as pas besoin de stocker deux fois une ligne identique, une sous matrice peut être représentée par des pointeurs sur la matrice dont elle est extraite, etc...

Francois
22/05/2011, 01h09
Joel F

Reponse parfaite ^^

On peut aussi trivialement avoir des tableaux a index quelconque et semantiquement fort ( mes filtres FIR, j'aime bien quand ils sosnt indexé de -n/2 a n/2).

Apres, je te demande d'extraire un sous cube d'un tableau 3D, je parie 10 que tu va te vautrer 34697 fois en polynomial.

L'aspect contigu rend le cache content, facilite la vectorisation et l'ecriture d'algo d'acces non triviaux.

Nioveaux perfs, en 2d/1d c'est strictement identique a l'autre version, en 3+D, le gain est de l'ordre de 10 a 25%, certains compilateurs utilisant des instructions non inlinables pour faire les produit-somme d'entier (LEA etc).
22/05/2011, 09h55
Invité

Citation:

Envoyé par Joel F

On peut aussi trivialement avoir des tableaux a index quelconque et semantiquement fort ( mes filtres FIR, j'aime bien quand ils sont indexés de -n/2 a n/2).

Les filtres, c'est le super jackpot... Pour eux (en fait pour toute matrice de Toeplitz, ou similaire, eg Hankel), la représentation de Iliffe permet de réduire le stockage de n^2 à 2n-1, sans perdre la contiguité.

Tu dois déjà connaitre ca, Joel, mais pour ceux que ca intéresse, l'idée est la suivante :

si on a une matrice du genre

a b c d
e a b c
f e a b
g f e a

on stocke le vecteur v(g,f,e,a,b,c,d), et, dans la représentation de Iliffe on fait pointer les pointeurs lignes sur &v[3], &v[2], &v[1] et &v[0]...

Notre matrice à 16 entrées est désormais stockée dans un tableau de 7 nombres, sans avoir à modifier les accès.

Une autre caratéristique sympathique des tableaux de Iliffe, plus liée au design, c'est qu'ils permettent la surcharge de l'opérateur [] pour chaque dimension.

Avec une représentation polynomiale classique, il est facile de surcharger [] pour transformer le tableau en un tableau "paresseux" (où chaque case se calcule lors de la première utilisation, et peut être invalidée en cours d'exécution). Avec Iliffe, on peut généraliser cela aux [] supérieurs, par exemple, quand les lignes du tableau se recalculent en bloc.

Je dis que c'est du design, parce que c'est typiquement le genre d'évolution qui intervient lors de la refonte d'un programme, quand on s'aperçoit que l'initialisation du tableau prend un temps énorme, et qu'on n'utilise qu'un petit nombre de ses termes... La surcharge d'opérateur évite ici la réécriture du tableau et des algorithmes qui l'utilisent.

Francois

Je vous remercie pour vos conseils !
J'ai choisi de créer une classe de façon a pouvoir utiliser un type Matrice.

Ici Matrice.C:
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 Matrice::Matrice(int dimX, int dimY) : m_dimX(dimX), m_dimY(dimY) { m_tab = new int*[m_dimX]; for(int i = 0 ; i < m_dimX ; ++i) { m_tab[i] = new int[m_dimY]; } } int Matrice::getDimX() { return m_dimX; } Matrice::~Matrice() { for(int i=0 ; i < m_dimX ; ++i) { delete [] m_tab[i]; } delete [] m_tab; }
Et le Matrice.h:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #ifndef DEF_MATRICE #define DEF_MATRICE class Matrice { public: Matrice(int dimX, int dimY); ~Matrice(); int getDimX(); private: int m_dimX; int m_dimY; int **m_tab; }; #endif
Ce que je veux, c'est avoir une matrice 2x2 avec une profondeur de 1 au début puis avoir une profondeur variable pour chaque case.
J'utilise ce code:

Code:

vector<Matrice> Tab(1,Matrice(2,2));

Je ne sais pas si c'est la bonne méthode, je ne trouve pas de doc dessus...
De plus j'obtiens une erreur du type "double free or corruption (out)" :aie:
Est-ce que ca vient de la création de la classe ou de la mauvaise utilisation de la déclaration de Tab ?

Merci pour vos suggestions !

23/05/2011, 10h24
Invité

Salut,

Quand tu définis une classe qui alloue des données dans le constructeur, il faut souvent définir un constructeur de copie et un opérateur d'affectation (operator=). C'est obligatoire dès que tu utilises des conteneurs de la STL, qui font des copies d'éléments.

En gros, quand tu crées ton vecteur, le compilateur va probablement créer une matrice temporaire, en appelant le constructeur, puis copier cet élément dans le vecteur, puis détruire la matrice. Si tu n'as pas surchargé l'opérateur d'affectation, tu alloues les données dans le constructeur, copie le pointeur dans le vecteur, et désalloue les données lors de la suppression du temporaire. Ca va forcément mal finir.

Francois

Merci fcharton !
Voila ce que j'obtiens apres avoir implemente le constructeur de copie et la surchage de l'operateur =
Matrice.h:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#ifndef DEF_MATRICE
#define DEF_MATRICE
 
class Matrice
{
    public:
     Matrice();
     Matrice(Matrice const& matriceCopie);
     Matrice(int dimX, int dimY);
    ~Matrice(); 
      int getDimX();
    private:
 
      int m_dimX;
      int m_dimY;
      int **m_tab;
};
Matrice operator=(Matrice const& a);
#endif

Matrice.C:

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
 
#include <stdio.h>
#include <stdlib.h>
#include "Matrice.h"
 
using namespace std;
 
Matrice::Matrice(Matrice const& matriceCopie) 
    : m_dimX(matriceCopie.m_dimX), m_dimY(matriceCopie.m_dimY)
{
    m_tab = new int*[matriceCopie.m_dimX];
    for(int i = 0 ; i < matriceCopie.m_dimX ; ++i)
    {
       m_tab[i] = new int[matriceCopie.m_dimY];
    }
} 
 
 
 
 
Matrice::Matrice(int dimX, int dimY) : m_dimX(dimX), m_dimY(dimY)
{
   m_tab = new int*[m_dimX];
   for(int i = 0 ; i < m_dimX ; ++i)
   {
       m_tab[i] = new int[m_dimY];
   } 
}
 
int Matrice::getDimX()
{
  return m_dimX;
}
 
Matrice::~Matrice()
{
   for(int i=0 ; i < m_dimX ; ++i) 
      {
        delete [] m_tab[i];
      }
 
   delete [] m_tab;
}
 
Matrice& Matrice::operator=(const Matrice  &matriceCopie) 
{
    if(this != &matriceCopie) 
    {
        m_dimX = matriceCopie.m_dimX;   
        m_dimY = matriceCopie.m_dimY;
        for(int i=0 ; i < matriceCopie.m_dimX ; ++i) 
        {
          delete [] m_tab[i];
        }    
          delete [] m_tab;
 
        m_tab = new int*[matriceCopie.m_dimX];
        for(int i = 0 ; i < matriceCopie.m_dimX ; ++i)
        {
           m_tab[i] = new int[matriceCopie.m_dimY];
        }
    }
 
    return *this; 
}

Est ce que je m'y prend de la bonne facon ou est ce qu'il y a mieux a faire ?
D'ailleurs j'ai une nouvelle erreur du type:

Matrice.C:44: error: definition of implicitly-declared ‘Matrice& Matrice::operator=(const Matrice&)’
Matrice.C:44: error: declaration of ‘Matrice& Matrice::operator=(const Matrice&)’ throws different exceptions
Matrice.h:5: error: from previous declaration ‘Matrice& Matrice::operator=(const Matrice&) throw ()’

Je ne comprends l'origine de mon erreur...
Auriez-vous des pistes ?

Merci !

23/05/2011, 14h53
Nhaps

ta méthode

Code:

Matrice &operator=(const Matrice const& a);

est en dehors de la classe, hors ici

Code:

Matrice& Matrice::operator=(const Matrice &matriceCopie)

tu dis qu'elle fait parti de celle ci.

Jo'
24/05/2011, 16h24
AirSounet

Merci Tooxx
Cela fonctionne maintenant ;)