Discussion :

[AirSounet]

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 !

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

Sélectionner tout - Visualiser dans une fenêtre à part

vector<Type> nom (nb_case, valeur_par_default);

[AirSounet]

Merci Tooxx !

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Nhaps]

ouch un vector de vector de vector....

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

vector<Matrice> Tab;

tu crées tes objets Matrice comme tu veux.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Matrice m;

et tu peux quand même faire des push_bach

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Tab.push_back(m);

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

Jo'

[AirSounet]

Et oui un vector de vector de vector !

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 !

[dasycarpum]

Et oui un vector de vector de vector !

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;

[AirSounet]

Merci dasycarpum !

Par contre moi ce ne fonctionne pas... j'obtiens une erreur de segmentation
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.

[dasycarpum]

Merci dasycarpum !

Par contre moi ce ne fonctionne pas... j'obtiens une erreur de segmentation
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

[pyros]

Salut,

Pourquoi ne pas faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[r0d]

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 :

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

34
34
34


34
45
56


34
56
78


34
67
90


end

Hope it helps.

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

[r0d]

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

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)

[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

[Davidbrcz]

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 ?

[Invité]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[Invité]

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

[AirSounet]

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 :

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

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

Sélectionner tout - Visualiser dans une fenêtre à part

  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)"
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 !

[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

[AirSounet]

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

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

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
 
#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 !