Discussion :

[Invité]

Bonjour,

Voilà, je m'exerce actuellement à manipuler des matrices dynamiques.
Mais je suis confronté à un souci, les matrices à une dimension s'execute, s'affiche, etc ... très bien, mais ce n'est pas le cas des matrices à deux dimensions, qui elles au moment de leur allocation m'affiche un message d'erreur comme quoi elles ont voulu s'allouer à un espace memoire qui ne leur était pas adresser (Violation, etc ....)

Voici mon code source :

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
 
	int a=7;
	int b=3;
	int i=0;
	int j=0;
	int **T = NULL;
	T = (int**)malloc(a * sizeof(int *));
	for (i=0;i<a;i++)
	{
		T[i] = (int*) malloc(b * sizeof(int));
	}
 
	for(i=0;i<a;i++)
	{
		T[i]=0;
	}
 
	puts("");
for(j=0;j<b;j++)
{
	for(i=0;i<a;i++)
	{
		printf("%d",T[i][j]);
	}
}

j'ai verfier mon code source par rapport à deux tutos sur le sujet, et il parait bon dans la syntaxe et dans le fonctionnement.
Je ne comprend pas d'où vient le problème !
Cela pourrait il être mon compilateur ?
J'utilise Visual C++ 2008.
Merci de votre aide.
Skanner

[SofEvans]

Salut,

Je ne suis pas sur, mais je pense que le probleme vient d'ici :

Code :

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

1
2
3
4
5
 
	for(i=0;i<a;i++)
	{
		T[i]=0;
	}

En fait, la premiere dimension de T est un tableau de pointeur. Donc T[] contiendra des adresse.

En faisant T[i] = 0; je pense que le compilo prend ca comme une affectation d'adresse et te dit que l'adresse (0) est invalide (adresse systeme ou autre).

[Franck.H]

Ton problème pourrait venir de là:

Code :

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

1
2
3
4
5
6
7
for(j=0;j<b;j++)
{
	for(i=0;i<a;i++)
	{
		printf("%d",T[i][j]);
	}
}

Dans ces deux boucles, tu utilises respectivement j et mais dans le printf, tu utilises pour la première dimension la valeur de i et puis seulement après pour la seconde, j. Ton printf est juste en fait mais pas les boucles, la première boucle doit utiliser i (ainsi que a) et la seconde j (ainsi que b) car sinon tu n'utilises pas les bonnes valeur pour accèder au différents éléments de ton tableau de tableau et donc un dépassement de mémoire d'où la violation d'accès

[SofEvans]

Ton problème pourrait venir de là:

Code :

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

1
2
3
4
5
6
7
for(j=0;j<b;j++)
{
	for(i=0;i<a;i++)
	{
		printf("%d",T[i][j]);
	}
}

Dans ces deux boucles, tu utilises respectivement j et mais dans le printf, tu utilises pour la première dimension la valeur de i et puis seulement après pour la seconde, j. Ton printf est juste en fait mais pas les boucles, la première boucle doit utiliser i (ainsi que a) et la seconde j (ainsi que b) car sinon tu n'utilises pas les bonnes valeur pour accèder au différents éléments de ton tableau de tableau et donc un dépassement de mémoire d'où la violation d'accès

? Pourtant, 'j' a pour borne 'b' (le int qui definie la deuxieme dimension) et 'i' a pour borne 'a' (le int qui borne la premiere dimension). Donc sa boucle devrait fonctionner meme si on est plus habituellement a parcourir la matrice dans l'autre sens.

[Invité]

Merci à tous, c'est bon, j'ai suivi vos conseils et en fait le problème venait de ma boucle d'initialisation qui etait en simple boucle et pas en double, ce qui n'initialisai que le tableau de pointeur, voila le nouveau code source pour que vous puissiez comparer avec l'ancien :

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
 
//Création d'un tableau de dimension a*b
	int a=7;//taille dimension a
	int b=3;//taille dimension b
	int i=0;
	int j=0;
 
//==========Allocation Tableau a*b===================
	int **T = NULL;
	T = (int**)malloc(a * sizeof(int *));
	for (i=0;i<a;i++)
	{
		T[i] = (int*) malloc(b * sizeof(int));
	}
//===================================================
 
	for(j=0;j<b;j++)//Initialisation tableau
{
	for(i=0;i<a;i++)
	{
		T[i][j] = 0;
	}
}
 
	puts("");
for(j=0;j<b;j++)//Affichage tableau
{
	for(i=0;i<a;i++)
	{
		printf("%d",T[i][j]);
	}
}

En tout cas merci à tous !
Bonne journée !

[SofEvans]

Salut,

content que tu est pu trouver la source de ton probleme.

Voici une deuxime version de ton code, pour que tu puisse comparer les deux ecriture.

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
 
 
//Création d'un tableau de dimension a*b
	int a=7;//taille dimension a
	int b=3;//taille dimension b
 
        int i, j;
 
//==========Allocation Tableau a*b==============
 
	int **T = (int**)malloc(a * sizeof(int *));
	for (i=0;i<a;i++)
		T[i] = (int*) malloc(b * sizeof(int));
 
//=========== Initialisation tableau ==============
 
	for(j=0;j<b;j++)
		for(i=0;i<a;i++)
			T[i][j] = 0;
 
//============ Affichage tableau ===============	
 
	puts("");
	for(j=0;j<b;j++)
		for(i=0;i<a;i++)
			printf("%d",T[i][j]);

Le seul modification que j'ai apporté sont la suppression des accolade inutile et le fait de mettre directement la bonne adresse a T (au lieu de mettre NULL, qui dans ce cas ne sert a rien).
D'ailleurs, si on voudrait etre rigoureux, il faudrait tester si les mallocs se deroule bien, car ici, si ton malloc foire, tu continue quand meme et tu mettre des valeurs dans un espace non allouer -> acces violation/segment fault

[Franck.H]

? Pourtant, 'j' a pour borne 'b' (le int qui definie la deuxieme dimension) et 'i' a pour borne 'a' (le int qui borne la premiere dimension). Donc sa boucle devrait fonctionner meme si on est plus habituellement a parcourir la matrice dans l'autre sens.

J'ai jamais testé dans le sens inverse, j'ai toujours parcouru dans le sens de l'allocation

[Jerome Briot]

Au passage pour afficher ton tableau en 2D :

Code :

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

1
2
3
4
5
6
for(i = 0; i < a; i++)
{
    for(j = 0; j < b; j++)
        printf("%d ", T[i][j]);
    printf("\n");
}

[SofEvans]

J'ai jamais testé dans le sens inverse, j'ai toujours parcouru dans le sens de l'allocation

Pour les matrice, il faut parfois faire des transposé. C'est un des moyens de le faire.