Discussion :

[sim_mmm]

Bonjour,

Je dois parcourir les colonnes ou rangées d'un tableau à deux dimensions pour trouver la valeur maximale d'une colonne ou rangée et je me demande qu'elle serait la meilleur façon de le faire. Actuellement, j'ai écrit une fonction qui parcours une rangee ou une colonne spécifique en fonction d'un paramètre :

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
 
int parcours(..., int type, int *rangee, int *colonne)
{
            ...
 
 
	for(int i = 0; i < DIMENSION; ++i)
	{
		switch(type)
		{
			case RANGEE :
				*colonne = i;
				break;
 
			case COLONNE :
				*rangee = i;
				break;
		}
		...
	}
 
...
}

Mais je trouve cela lourd... Existe-t-il une meilleur façon de procéder? Peut-être à l'aide des pointeurs?

P.S je dois absolument utiliser un tableau à deux dimensions...

Merci beaucoup...

[koala01]

Salut,

Sais tu qu'il n'y a rien de plus proche d'un tableau à deux dimensions qu'un tableau à une seule contenant ligne*colone éléments

[sim_mmm]

Bonjour,

Effectivement, mais je dois absolument utiliser un tableau à deux dimension alloué dynamiquement....

[koala01]

Mais rien ne t'empêche d'allouer dynamiquement un tableau à une seule dimension qui fonctionne de la même manière qu'un tableau à plusieurs dimensions...:

Que tu travailles sous une forme proche de

Code :

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

1
2
3
4
5
int **tab;
tab=new int*[20];
for(size_t i=0;i<20;i++)
    tab[i]=new int[30];
/*...*/

ou sous la forme de

Code :

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

1
2
3
int *tab;
tab=new int[20*30];
/*...*/

cela reviendra au final au même...

La seule différence sera que, d'un coté tu accédera à l'élément sous la forme de

Code :

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

1
2
 
int elem=tab[3][5];

et que de l'autre coté, tu y accédera sous la forme de

Code :

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

int elem=tab[3*30+5];

Mais le gros avantage résidera dans l'utilisation courante

• tu ne dois pas utiliser un pointeur de pointeur pour disposer de ta matrice
• l'allocation et la libération des ressources se font en une seule fois
• ...

En effet, le fait de devoir gérer réellement les deux dimensions séparément pose un problème dés l'allocation de la mémoire

Code :

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

1
2
3
4
5
6
7
8
 
int **tab;
tab= new *int[ligne];
for( size_t i=0;i<ligne;i++)
{
    tab[i]=new int[colone];
    /* que va-t-il se passer si l'allocation échoue ??? */
}

et on retrouve le problème de devoir gérer la libération des colones avant celle de la matrice:

Code :

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

1
2
3
4
5
6
7
8
 
/* obligatoire pour éviter les fuites mémoire */
for(size_t i=0;i<ligne;i++)
{
    delete[] tab[i];
}
/* pour enfin libérer la mémoire allouée à la matrice */
delete [] tab;

alors que le fait de gérer sa matrice comme si elle était qu'un vecteur tout simple permet de tout faire en une seule passe (tant que la mémoire est suffisante):

Code :

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

1
2
3
4
5
6
7
 
int *tab;
/* allocation en une seule passe */
tab=new int[ligne*colone];
/*...*/
/* libération en une seule passe */
delete [] tab;

[Alp]

Et l'utilisation de std::vector, tu en dis quoi ?

[sim_mmm]

Je ne peux utiliser la classe vector....


J'aime bien l'idée de koala01, je vais vérifier si je peux utiliser un tableau à une seule dimension...

Merci beaucoup...

[sim_mmm]

J'ai regardé le tout mais je reviens au problème initiale, comment structurer mon code pour faire mes traitements sur les lignes et les colonnes....

Est-ce préférable de faire une fonction avec un paramètre COLONNE/RANGEE ou écrire deux fonctions similaires; une travaillant les lignes l'autre les colonnes?

Merci encore une fois...

[koala01]

Le mieux reste quand même toujours de créer une fonction pour chaque chose...

Ainsi, l'idéal serait:

• une fonction qui calcule le max sur les colones
• une fonction qui calcule le max sur la ligne

*Idéalement* il serait d'ailleurs pas si mal de créer une classe avec tout cela

Sans orientation objet, cela donnerait un code ressemblant à

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
 
/* Fonction qui calcule la valeur maximale d'une colone donnée
 * @ in: - vecteur dans lequel rechercher
 *       - nombre de colones du vecteur
 *       - nombre de lignes du vecteur
 * @ out: valeur maximale trouvée
 */
int MaxCol( int *mat, int nbcol, int nbligne, int col)
{
    int max=0;/* le plus petit max possible :D */
    for(size_t i=0;i<nbligne;i++)
    {
        if(mat[i*nbcol+col]>max)
        {
            max=mat[i*nbcol+col];
        }
    }
    return max;
}
 
/* Fonction qui calcule la valeur maximale d'une ligne donnée
 * @ in: - vecteur dans lequel rechercher
 *       - nombre de colones du vecteur
 *       - nombre de lignes du vecteur
 * @ out: valeur maximale trouvée
 */
int MaxLigne( int *mat, int nbcol, int nbligne, int ligne)
{
    int max=0;/* le plus petit max possible :D */
    for(size_t i=0;i<nbcol;i++)
    {
        if(mat[ligne*nbcol+i]>max)
        {
            max=mat[ligne*nbcol+i];
        }
    }
    return max;
}

Avec orientation objet, cela deviendrait:

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
class Matrice
{
    public:
        /* le constructeur */
        Matrice(int nbligne,int nbcol):nbligne(nbligne),nbcol(nbcol)
        {
            /*il nous faut au minimum une ligne et une colone :D */
            assert(nbligne>0);
            assert(nbcol>0);
            tab=new[nbligne*nbcol];
        }
        /* le destructeur */
        ~Matrice()
        {
             delete [] tab;
        }
        int MaxLigne(int ligne)
        {
            /* même principe que la version non OO ... Si ce n'est
             * que les différentes données sont des membres */
            int max=0;/* le plus petit max possible :D */
            for(size_t i=0;i<nbcol;i++)
            {
                if(mat[ligne*nbcol+i]>max)
                {
                    max=mat[ligne*nbcol+i];
                }
            }
            return max;
        }
        int MaxColone(int col)
        {
            /* même principe que la version non OO ... Si ce n'est
             * que les différentes données sont des membres */
            int max=0;/* le plus petit max possible :D */
            for(size_t i=0;i<nbligne;i++)
            {
                if(mat[i*nbcol+col]>max)
                {
                    max=mat[i*nbcol+col];
                }
            }
            return max;
        }
    private:
        int *tab;
        int nbligne;
        int nbcol;
};

[sim_mmm]

Merci encore une fois je vais y aller avec des fonctions séparées pour plus de lisibilité!