Création d'une classe Tableau2d

Version imprimable

Bonjour,
Je dois créer une classe Tableau à 2D d'entiers (Array) divisée dans un fichier .h et un .cpp
Ma classe ressemblera donc à ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Array { int ** array; unsigned nbLig; unsigned nbCol; public: //Constructeurs Array(unsigned nbL=1, unsigned nbC=1, int valInit=0); Array(const Array & a); //Destructeur ~Array(); //Surcharge affectation Array & operator= (const Array & a); //Accesseurs unsigned getNbLig() const; unsigned getNbCol() const; };
J'ai un petit problème pour mon constructeur avec 3 paramètres: je dois donc créer un tableau dynamique interne à 2D et pouvoir utiliser dans les autres méthodes de la classe l'écriture: array[x][y] pour accéder aux entiers.

Voici mon constructeur, j'initialise nbLig et nbCol mais il me reste à créer le tableau et initialiser chaque case avec valInit... :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Array::Array(unsigned int nbL, unsigned int nbC, int valInt) { if(nbL==0) nbLig=1; else nbLig=nbL; if(nbC==0) nbCol=1; else nbCol=nbC; .........????????????............. }
Merci d'avance et bonne soirée.

Une double boucle for suffit pour initialiser chaque case du tableau
Code:

1 2 3 for( uint i = 0; i < nbLig; ++i) for( uint j = 0; j < nbCol; ++j) array[i][j] = valInt;

24/05/2011, 11h52
alex2746

Merci, cela semble aller.
Mais pour la création du tableau à 2D dynamique? Pouvez vous m'aider?

Merci d'avance.
24/05/2011, 13h12
Luc Hermitte

FAQ ?

Bonjour,

pour allouer ton tableau il faut d'abord allouer les pointeurs sur ligne, puis les colonnes. Cela donne ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
Array(unsigned nbL, unsigned nbC, int valInit)
{
    nbLig = nbL;
    nbCol = nbC;
    array = new int*[nbL]; // creation des lignes
    for (int i=0;i<nbL;++i)
    {
        array[i] = new int[nbC]; // création des colonnes
        for (int j=0;j<nbC;++j)
            array[i][j] = valInit;
    }
}

Cette écriture te permet de comprendre le principe de construction mais il est plus performant de passer par des listes d'initialisation comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
Array(unsigned nbL, unsigned nbC, int valInit)
    :nbLig(nbL),nbCol(nbC),array(new int*[nbL])
{
    for (int i=0;i<nbL;++i)
    {
        array[i] = new int[nbC]; // création des colonnes
        for (int j=0;j<nbC;++j)
            array[i][j] = valInit;
    }
}

24/05/2011, 13h41
Luc Hermitte

La version de la FAQ est robuste...
24/05/2011, 13h47
Aleph69

Le lien vers la version de la faq : http://cpp.developpez.com/faq/cpp/?p..._new_array_dim
24/05/2011, 13h52
3DArchi

Bonjour,
Si l'énoncé de ton exercice ne stipule pas explicitement qu'il faut faire un tableau de tableau, alors je proposerais de faire une seule allocation :nbrLigne*nbrColonne. Puis d'utiliser l'indexation (lig,col) => lig*NbrColonne + col

Parfait, merci.
Je devais également faire un constructeur par copie et la surcharge de certains opérateurs: = == ++(préincrémentation) () (fonction)
Pouvez vous me dire si c'est correct ce que j'ai fait?

Merci d'avance!

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
 
Array::~Array()
{
	for (unsigned i = 0 ; i<nbLig ; i++)
		delete [] array[i];
	delete [] array;
	array=0;
	nbLig=0;
	nbCol=0;
}
 
Array::Array(const Array & a) throw (int)
{
	if (a.nbCol==0 || a.nbLig==0)
	{
		array=0;
		nbCol=0;
		nbLig=0;
	}else{
		array=new int*[nbLig=a.nbLig];
		for (unsigned i = 0 ; i<nbLig ; i++)
			array[i]=new int[nbCol=a.nbCol];
		if(array==0)
			throw 6;
		for (unsigned i = 0 ; i<nbLig ; i++)
			for (unsigned j = 0 ; j<nbCol ; j++)
				array[i][j]=a.array[i][j];
	}
}
 
Array & Array::operator= (const Array & a) throw (int)
{
	if (this != &a)
	{
		this->~Array();
		if (a.nbLig != 0 && a.nbCol != 0){
			array=new int*[nbLig=a.nbLig];
			for (unsigned i=0 ; i<nbLig ; i++)
				array[i]=new int[nbCol=a.nbCol];
			if (array==0)
				throw 7;
			for (unsigned i = 0 ; i<nbLig ; i++)
				for (unsigned j = 0 ; j<nbCol ; j++)
					array[i][j]=a.array[i][j];
		}
	}
	return *this;
}
 
bool Array::operator==(const Array & a) const
{
	bool verif=true;
	if ((a.nbCol!=nbCol) || (a.nbLig!=nbLig))
		verif = false;
	else
		for (unsigned i=0 ; i<nbLig ; i++)
			for (unsigned j=0 ; j<nbCol ; j++){
				if (array[i][j]!=a.array[i][j])
					verif=false;
			}
	return verif;
}
 
Array & Array::operator++()
{
	for (unsigned i = 0 ; i<nbLig ; i++)
		for (unsigned j = 0 ; j<nbCol ; j++)
			array[i][j]++;
 
	return *this;
}

Il me reste juste l'oparateur fonction: () que je n'arrive pas à faire.
Il doit retourner une référence sur l'entier dont les numLig et numCol sont donnés en paramètre.

Merci d'avance pour votre aide!

24/05/2011, 16h34
Luc Hermitte

a- destructeur : les RAZ sont de moindre intérêt

b- ctr de copie
-> les spéc d'exception, c'est une arnaque => à bannir (on en parle peut-être dans la FAQ)
-> un new ne renverra jamais 0, pas depuis que les compilos suivent la norme de ... 98 (oui, c'est vieux) ; et à supposer qu'un 0 soit bien renvoyé, il y aurait eu une vilaine fuite de mémoire avec ton code.
-> bref, la méthode correcte est dans la FAQ (ter)

c- l'affectation. Ouille, ouille, ouille. Revend de suite ton bouquin de C++, ou garde le pour la cheminée cet hiver.
Je suis sérieux. Les circonstances où tu iras appeler explicitement un destructeur sont excessivement rares, et toutes liés à l'utilisation du new de placement -- tu n'y es pas encore.
De plus, tu utilises un anti-idiome avec le test pessimiste d'autoaffectation, qui ne règle pas le cas des levées d'exception.
Une fois de plus, je t'invite à consulter la FAQ.

d- test d'égalité : pas la peine de continuer dès qu'une différence est trouvée => return false (je n'aime pas le SESE -- single Entry single exit --, il est totalement déplacé et dépassé en C++)
(ce n'est pas une erreur, juste un truc optimisable)

e- l'incrémentation n'a aucun sens sur une matrice.
À moins que cela te soit imposé par un prof, c'est à ne pas faire (détourner une opérateur pour lui faire faire des trucs qui ne sont pas intuitifs à la lecture du code utilisateur)

f- pour ta question, réponse dans la FAQ C++ lite, de sûr.

Il y a deux operateurs () à implémenter :
Code:

1 2 int& operator()(int const,int const); // pour modifier un coefficient int const& operator()(int const,int const) const; // pour accéder à un coefficient
Ces deux fonctions se prêtent bien à l'expansion de code (inline) pour gagner en performances :
Code:

1 2 3 4 5 6 7 8 inline int& Array::operator()(int const numlig,int const numcol) { return array[numlig][numcol]; } inline int const& Array::operator()(int const numlig,int const numcol) const { return array[numlig][numcol]; }
Il faut lancer une exception dans le cas où numlig ou numcol n'est pas dans le bon range. Pour empêcher qu'ils soient négatifs, le plus simple est d'utiliser size_t plutôt que int dans la gestion des indices :
Code:

1 2 int& operator()(size_t const,size_t const); // pour modifier un coefficient int const& operator()(size_t const,size_t const) const; // pour accéder à un coefficient
Je crois me souvenir que size_t est défini dans cstddef.h. Il reste à traiter les cas ou numlib ou numcol sont supérieurs aux dimensions du tableau.

Pour les copies de tableau à tableau, tu peux utiliser la fonction memcpy qui est plus rapide.