Discussion :

[alex2746]

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 :

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

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

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.

[Nhaps]

Une double boucle for suffit pour initialiser chaque case du tableau

Code :

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

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

[alex2746]

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

Merci d'avance.

[Luc Hermitte]

FAQ ?

[Aleph69]

Bonjour,

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

Code :

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

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 :

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

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;
    }
}

[Luc Hermitte]

La version de la FAQ est robuste...

[Aleph69]

Le lien vers la version de la faq : http://cpp.developpez.com/faq/cpp/?p..._new_array_dim

[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

[alex2746]

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 :

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

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

[Aleph69]

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

Code :

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

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 :

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

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 :

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

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.