Visual studio & 0xC0000005: Violation d'accès lors de la lecture de l'emplacement 0x00000000

[invite8a011b82]

Bonjour, lorsque je compile mon code j'ai cette erreur :

Exception non gérée à 0x00401027 dans accelerometre.exe*: 0xC0000005: Violation d'accès lors de la lecture de l'emplacement 0x00000000.

J'ai mis en commentaire l'endroit où ça s'arrête.

Merci pour votre aide.

voici mon code :

#include <stdio.h>
#include <stdlib.h>

# define colonne 3

int** remplir_tableau2D_dyn (int ligne)
{
int i, j, val=0;
int **tab= NULL;
/*************************************
* Saisies valeurs du tableau a 2D dyn*
**************************************/

for(i=0;i<ligne;i++)		// L'erreur apparait sur cette ligne
	{
	for(j=0;j<colonne;j++)
		{
		printf("Donnez les valeurs de tab, val tab num %d : ",j);
		scanf("%d", &val);
		tab[i][j]=val;
		}
	}
printf("\n");
return tab;
}

void affiche_tab_2D_dyn(int tab[][colonne], int ligne)
{
/*******************************
* Affichage du tableau a 2D dyn*
********************************/
int i, j;

for(i=0;i<ligne;i++)
	{
	for(j=0;j<colonne;j++)
		{
		printf("val tableau 2D dyn tab[i][j]= %d\t", tab[i][j]);
		}

	printf("\n");
	}

//Libération del a mémoire
for(i=0;i<ligne;i++)
	{
	free(tab[i]);
	}
free(tab);
}


int main (void)
{
int i, ligne;
int **tab= NULL;
printf("Donnez le nombre de ligne de tab: ");
	scanf("%d", &ligne);
//printf("Donnez le nombre de colonne de tab: ");
//	scanf("%d", &colonne);
/*********************************
* Déclaration du tableau a 2D dyn*
**********************************/
//tab=((int**)malloc(ligne * sizeof(*tab))); 
tab=((int**)malloc(ligne * sizeof(int*)));
        if(tab==NULL) 
        {
                printf("valeur inexistante\n");
	//			return NULL;
        }
	for(i=0;i<ligne;i++)
	//tab[i]=((int*)malloc( colonne * sizeof (**tab)));//tab[i]=((int**)malloc( colonne * sizeof (**tab)));		
	tab[i]=((int*) malloc(colonne * sizeof (int*)));
			if(tab[i]==NULL) 
					{
						for(i=i-1; i>=0; i--)
							free(tab[i]);
						free(tab);
						printf("valeur inexistante\n");
					}

remplir_tableau2D_dyn(ligne);
affiche_tab_2D_dyn(tab, ligne);
while (1){};
return 0;
}

-----

[whoami]

Bonjour,

Dans la fonction remplir_tableau2D_dyn, tu redéfinis int **tab= NULL;, et donc bingo memory access.

Au passage, ça te montre un problème de conception.

[bzh_nicolas]

+1 à whoami.
Et j'ajouterais que dans ton main tu as un gros problème dans cette partie (peut-être à cause de l'indentation qui est fausse):

tab=((int**)malloc(ligne * sizeof(int*)));
if(tab==NULL) 
{
	printf("valeur inexistante\n");

}
for(i=0;i<ligne;i++)
	tab[i]=(int*) malloc(colonne * sizeof (int*)));
        // tu tentes d'allouer la mémoire sur tab[i] sans savoir si l'allocation est réussie
        //car tu ne retestes pas tab et la boucle n'est pas dans le if
if(tab[i]==NULL)
//ici tu testes sur un seul élément
//et en plus ici i va être égal à ligne qui est plus grand que l'indice de ton tableau (de 0 à ligne-1)
{
	for(i=i-1; i>=0; i--)
        //si l'allocation d'un élément a raté tu les désalloues tous
        //ok mais es-tu sûr qu'ils sont alloués ?
		free(tab[i]);
	free(tab); //idem précédent tu désalloue sans savoir s'il est alloué
	printf("valeur inexistante\n");
}

Donc tu as de la chance que ton programme ne plante pas plus tôt que ça...
Il est inutile de désallouer de la mémoire si l'allocation est un échec.

[invite8a011b82]

Bonjour,
Je suis désolé mais je n'ai pas compris les explication de bhz_nicolas.

J'ai effectué des modifications dans mon code et maintenant j'ai un problème quand je libère l'espace mémoire.

Merci pour votre aide.

Voici mon code :

#include <stdio.h>
#include <stdlib.h>

# define colonne 3

int** remplir_tableau2D_dyn (int tab[][colonne], int ligne)
{
int i, j, val=0;

/*************************************
* Saisies valeurs du tableau a 2D dyn*
**************************************/

for(i=0;i<ligne;i++)
	{
	for(j=0;j<colonne;j++)
		{
		printf("Donnez les valeurs de tab, val tab num %d : ",j);
		scanf("%d", &val);
		tab[i][j]=val;
		}
	}
printf("\n");
return tab;
}

void affiche_tab_2D_dyn(int tab[][colonne], int ligne)
{
/*******************************
* Affichage du tableau a 2D dyn*
********************************/
int i, j;

for(i=0;i<ligne;i++)
	{
	for(j=0;j<colonne;j++)
		{
		printf("val tableau 2D dyn tab[i][j]= %d\t", tab[i][j]);
		}

	printf("\n");
	}

//Libération de la mémoire
for(i=0;i<ligne;i++)
	{
	free(tab[i]);
	}
free(tab);
}


int main (void)
{
int i, ligne;
int **tab= NULL;
printf("Donnez le nombre de ligne de tab: ");
	scanf("%d", &ligne);

/*********************************
* Déclaration du tableau a 2D dyn*
**********************************/

tab=((int**)malloc(ligne * sizeof(int*)));
        if(tab==NULL) 
        {
                printf("valeur inexistante\n");
				return NULL;
        }
	for(i=0;i<ligne;i++)
	tab[i]=((int*) malloc(colonne * sizeof (int*)));
			if(tab[i]==NULL) 
					{
						for(i=i-1; i>=0; i--)
							free(tab[i]);
						free(tab);
						printf("valeur inexistante\n");
					}

printf("\n**********tab 2D dyn**********\n");
remplir_tableau2D_dyn(tab,ligne);
affiche_tab_2D_dyn(tab, ligne);
while (1){};
return 0;
}

[A voir en vidéo sur Futura]

[invite8a011b82]

Bonjour,

J'ai crée un tableau à 2 dimensions dont on connait seulement le nombre de colonne (3) et j'ai une erreur au moment de libérer la mémoire je ne c'est pas ce qu'il faut faire.
Merci pour votre aide.

Voici le code :

//Libération de la mémoire
for(i=0;i<ligne;i++)
	free(tab[i]);
free(tab);
//ou
 free(tab);

Voici mon code complet :

#include <stdio.h>
#include <stdlib.h>


int remplir_tableau2D_dyn (int tab[][3], int ligne)
{
int i, j, val=0;

/*************************************
* Saisies valeurs du tableau a 2D dyn*
**************************************/

for(i=0;i<ligne;i++)
	{
	for(j=0;j<3;j++)
		{
		printf("Donnez les valeurs de tab, val tab num %d : ",j);
		scanf("%d", &val);
		tab[i][j]=val;
		}
	}
printf("\n");
return (*tab[3]);
}

void affiche_tab_2D_dyn(int tab[][3], int ligne)
{
/*******************************
* Affichage du tableau a 2D dyn*
********************************/
int i, j;

for(i=0;i<ligne;i++)
	{
	for(j=0;j<3;j++)
		{
		printf("val tableau 2D dyn tab[i][j]= %d\t", tab[i][j]);
		}

	printf("\n");
	}
}


int main (void)
{
int i, ligne;
int (*tab)[3]= NULL;
printf("Donnez le nombre de ligne de tab: ");
	scanf("%d", &ligne);

/*********************************
* Déclaration du tableau a 2D dyn*
**********************************/
tab=((int(*)[3])malloc(ligne * sizeof(int*)));
if(tab==NULL) //test obligatoire
        {
            free(tab);    
			printf("valeur inexistante\n");
        }

printf("\n**********tab 2D dyn**********\n");
remplir_tableau2D_dyn(tab,ligne);
affiche_tab_2D_dyn(tab, ligne);

//Libération de la mémoire
/********************
PROBLEME
*********************
for(i=0;i<ligne;i++)
	free(tab[i]);
free(tab);
ou
 free(tab);
********************/
while (1){};
return 0;
}

[Jack]

J'ai fusionné les 2 discussions.

Je rappelle qu'ouvrir 2 discussions identiques est interdit par la charte.

[bzh_nicolas]

Un conseil général déjà, au lieu de faire tab[][3], fais plutôt tab[3][] et inverse tes indices de parcours. Il est toujours plus facile de démarrer avec une valeur connue.
Au lieu d'allouer :
ligne tableaux à 1 dimension de 3 éléments
tu fais un tableau de 3 int* dont chaque élément contiendra un tableau de taille ligne (alloué dynamiquement).
ça sera plus simple à gérer au niveau de l'allocation et de la désallocation.
Tu déclares comme ceci :
int* tab[3];
Ensuite tu alloues, dynamiquement, pour chaque élément de tab, un nombre de ligne int.

if(tab==NULL) //test obligatoire
	{
		free(tab);    
		printf("valeur inexistante\n");
	}

Là ça ne marchera jamais, tu désalloues si l'allocation a raté (c'est ce que signifie le test tab==NULL)...

La version du message #4 était bien meilleure et plus facile à gérer.