Sujet Précédent Sujet Suivant

Problème réaffectation involontaire d'argv[1]

Résolu/Fermé
efelant Messages postés 15 Date d'inscription dimanche 3 février 2013 Statut Membre Dernière intervention 4 février 2013 - 3 févr. 2013 à 00:58
efelant Messages postés 15 Date d'inscription dimanche 3 février 2013 Statut Membre Dernière intervention 4 février 2013 - 3 févr. 2013 à 02:28
Bonjour,
J'aimerai bien savoir comment je peux faire pour déterminer où exactement, mon code réaffecte la variable argv[1]. J'ai pu remarquer que la fonction qui réaffectait la variable argv[1] est 

int** initTabContigu(int h, int * largeur){
	int **m ;
	int i;
  	m    = (int**)malloc( h * sizeof(int*) );
  	m[0] = (int*)malloc( h * largeur[0]*sizeof(int) );
  	for(i=1;i<h;i++)
		m[i] = m[i-1]+largeur[i];
  	return m;
}


C'est un morceau de code trouvé sur internet, pour créer un tableau de manière contigu en mémoire, que j'ai modifié selon mes besoins, puisque la taille des colonnes n'est pas fixe dans le tableau que je voulais créer mais contenu dans un tableau.

Je pense bien que c'est un des malloc qui cause le problème de réaffectation.
La variable argv[1] avant d'entrer dans cette fonction est correcte mais à la sortie ma console écrit des symboles illisibles.

Pouvez-vous m'expliquer pourquoi et/ou comment résoudre le problème ?

Merci d'avance.

5 réponses

Réponse 1 / 5
KX Messages postés 16754 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 25 novembre 2024 3 020
3 févr. 2013 à 01:05
C'est bizarre ce m[i] = m[i-1]+largeur[i];
Mais je ne vois pas le rapport avec argv... 

int** initTabContigu(int h, int * largeur)
{
    int** m = malloc(h*sizeof(int*));
    int i;
    for(i=0; i<h; i++)
        m[i] = malloc(largeur[i]*sizeof(int));
    return m;
}
0
KX Messages postés 16754 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 25 novembre 2024 3 020
3 févr. 2013 à 01:09
Remarque : pour la contiguïté, je me risquerais à dire ceci (à vérifier) 

int** initTabContigu(int h, int * largeur) 
{
    int i, n=0;
    for(i=0; i<h; i++)
        n+= largeur[i];
    
    int** m = malloc(n*sizeof(int));
    
    n=0;
    for(i=0; i<h; i++)
    {
        m[i] = m+n;
        n+largeur[i];
    }
    return m; 
}
0
efelant Messages postés 15 Date d'inscription dimanche 3 février 2013 Statut Membre Dernière intervention 4 février 2013
Modifié par efelant le 3/02/2013 à 01:23
à cette ligne : 
m[i] = m+n;

attention : assignment from incompatible pointer type [enabled by default]

Puis en regardant un peu plus le code , 
n+largeur[i];

n'est affecté à rien en fait... c'était n+= je suppose ?!
0
KX Messages postés 16754 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 25 novembre 2024 3 020
3 févr. 2013 à 01:40
Oui, c'était bien += auquel je pensais, cependant j'ai oublié un petit morceau car j'ai mis les pointeurs m[0], m[1], etc. sur le même espace que m[0][0], m[0][1]... D'où l'erreur du m+n qui devrait en fait être un m[0]+n, pour ne pas mélanger int** et int* comme je l'ai fais.

Bref, au risque de m'enfoncer encore un peu plus (toujours à vérifier) 

int** initTabContigu(int h, int* largeur) 
{
    int i, n=0;    
    int** m;
    
    for (i=0; i<h; i++)
        n = n+largeur[i];
    
    m = malloc(h*sizeof(int*)+n*sizeof(int)); // h int* suivis de n int
    
    n = 0;    
    for (i=0; i<h; i++)
    {
        m[i] = m[h] + n;
        n += largeur[i];
    }
    
    return m; 
}
0
efelant Messages postés 15 Date d'inscription dimanche 3 février 2013 Statut Membre Dernière intervention 4 février 2013
3 févr. 2013 à 01:47
Avec ce code j'obtiens comme avec fiddy, ma variable est "vide", enfin plus rien ne s'affiche.(avant j'avais des choses illisibles)
0
Réponse 2 / 5
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 844
3 févr. 2013 à 01:05
Je vois pas le rapport avec argv[1]...
Pourrais-tu nous montrer l'endroit dans ton code où tu utilises argv[1] ?
0
Réponse 3 / 5
efelant Messages postés 15 Date d'inscription dimanche 3 février 2013 Statut Membre Dernière intervention 4 février 2013
3 févr. 2013 à 01:15
En fait pour tester j'ai simplement fait ça : 
printf("FICHIER : %s\n", argv[1]);
g->tabAdjacence = initTabContigu(g->nbSommet, g->tabDegres);
printf("FICHIER : %s\n", argv[1]);


En fait j'ai remarqué l'erreur plus loin dans mon code, mais j'ai repéré que l'erreur venait de là. Comme je le disais dans mon premier message, l'affichage change entre le premier et le deuxième printf.

(je prends en compte le changement pour la fonction, mais je ne peux pas encore la tester)
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 844
Modifié par fiddy le 3/02/2013 à 01:46
Pourquoi as-tu besoin que tout soit contigu ?
0
efelant Messages postés 15 Date d'inscription dimanche 3 février 2013 Statut Membre Dernière intervention 4 février 2013
3 févr. 2013 à 01:45
Au lieu d'avoir des choses illisibles, plus rien ne s'affiche maintenant avec ce code ;-)

Et j'ai besoin d'utiliser un tableau contigu parce que c'est un devoir que je dois faire et il est conseillé d'en utiliser un.
0
Réponse 4 / 5
KX Messages postés 16754 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 25 novembre 2024 3 020
3 févr. 2013 à 01:50
Une question toute bête, quand je vois les différents codes, je me pose une question, ton "tableau" contigu, ressemble beaucoup à une matrice, et d'ailleurs ton code initial devait être un truc comme malloc(h*h*sizeof(int))

Si je comprends bien les modifications que tu as voulu faire, les différentes lignes n'ont pas toutes la même taille, elles sont conditionnées par largeur[i]

Je pense que l'erreur de départ est d'avoir mis dans le malloc h*largeur[0]*sizeof(int), alors que la bonne taille devrait être la somme des largeur[i], mais sans la remultiplier par h.

Dis nous déjà, si on comprends bien le principe de ton "tableau"
0
efelant Messages postés 15 Date d'inscription dimanche 3 février 2013 Statut Membre Dernière intervention 4 février 2013
Modifié par efelant le 3/02/2013 à 01:59
Hum... je dois avouer que ce n'est pas très clair pour moi cette histoire de tableau...
J'aimerai avoir un tableau de ce type là (c'est qu'un exemple) :
Donc un tableau de tableau : si le premier tableau contient 3 cases dont chaque case contient respectivement :
1 : [ ] [ ] [ ] [ ]
2 : [ ] [ ]
3 : [ ] [ ] [ ] [ ] [ ]

Mais le tableau contigu ferait que j'aurai les 11 cases à la suite :
[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]

Et qu'on saurait quand même où pointe chaque "ligne", la 1ère ligne sur la 1ère case, la 2ème ligne sur la 5ème case et la 3ème ligne sur la 7ème case...
0
KX Messages postés 16754 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 25 novembre 2024 3 020
3 févr. 2013 à 02:05
Sous réserve que je ne me sois pas trompé, mon dernier code (#7), fait ça : 

m = { m[0], m[1], m[2], m[0][0], m[0][1], m[0][2], m[0][3], m[1][0], m[1][1], m[2][0], m[2][1], m[2][2], m[2][3], m[2][4] }

Mais je ne vois toujours pas le rapport avec argv[1]... Oserais-je demander la valeur de argc ?
0
efelant Messages postés 15 Date d'inscription dimanche 3 février 2013 Statut Membre Dernière intervention 4 février 2013
Modifié par efelant le 3/02/2013 à 02:12
argc est encore correct :-)
C'est exactement ce que je voulais faire... mais la variable est modifiée quand même =S
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 5
efelant Messages postés 15 Date d'inscription dimanche 3 février 2013 Statut Membre Dernière intervention 4 février 2013
Modifié par efelant le 3/02/2013 à 02:25
Je pense avoir compris d'où venais le problème.
En fait mon programme se compose comme cela :

x->a = Fonc1; (1)
x ->b = Fonc2; (2)

Je remarque qu'après l'éxécution de (1), argv[0] a été modifié mais argv[1] est resté tel quel.
Et après l'éxécution de (2) , c'est au tour de argv[1] d'être modifié.

Donc peut être que ça viendrait de mon x, qui a mal été alloué ou quelque chose dans ce genre

Je viens de faire une vérification... le malloc de x n'était pas fait, donc au fur et à mesure que j'affectais, il écrasait...

Désolée !
Merci pour vos codes du tableau, ça va me pousser à la réflexion.
Et merci d'avoir réfléchi avec moi :-)
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 844
3 févr. 2013 à 02:25
Ah ok. C'est plus compréhensible avec ton explication sur les crochets.

Essaie le code : 
int** initTabContigu(int h, int * largeur){
    int **m;
    int i;
    int taille=0;
    for (i=0; i <h; i++) {
        taille+=largeur[i];
    }
    m = malloc(h * sizeof(int*));
    m[0] = malloc(taille * sizeof (int));
    for (i=1; i<h; i++)
        m[i] = m[i-1] + largeur[i-1];

    return m;
}

Et tout devrait rentrer dans l'ordre.
Effectivement, une allocation bancale peut écrire sur des cases mémoires et donc modifier des variables.
0
efelant Messages postés 15 Date d'inscription dimanche 3 février 2013 Statut Membre Dernière intervention 4 février 2013
3 févr. 2013 à 02:28
Oui c'était le problème... tout bête... même si c'est en faisant des erreurs qu'on apprend, j'aurai pu l'éviter...
Je garde vos codes. Je testerai à tête reposer.
Merci beaucoup.
0

Discussions similaires

manipulation involontaire
jeanine -
baladur13 -

3 réponses
mauvaise manipulation
SJB_7378 -
brucine -

1 réponse
Manipulation du SCU
james Gordini -
james Gordini -

2 réponses
Dégradé involontaire
2fray -
Phoenix186 -

3 réponses
Acquisition involontaire de pédoporno
Lovely+ -
graffx -

2 réponses