Posez votre question Signaler

Matrice en argument d'une fonction! [Résolu]

karludwig 6Messages postés 17 janvier 2009Date d'inscription - Dernière réponse le 18 janv. 2009 à 18:30
Bonjour!
Je vous explique mon problème :
Je code un programme en c, qui gère une matrice de caractères de taille variable.
Donc je crée dans le main un pointeur char **matrice , fais un malloc avec la taille n de la matrice que l'utilisateur a entrée plus haut dans le programme et je voudrais pouvoir avoir une sous-fonction du type :
void modifie_la_matrice (char** matrice, n)
{
        m[2,6]='A';
}

et qu'après exécution de cette fonction, ma matrice ait bien de façon accessible dans le main :
char B = matrice[2][6];

Je cherche du coté des pointeurs mais je ne vois vraiment pas comment faire ça!
Merci d'avance!
Lire la suite 

Matrice en argument d'une fonction »

14 réponses
Réponse
+0
moins plus
rien pigé
karludwig- 17 janv. 2009 à 19:04
!!!

et bien :

void modifie_la_matrice (char **matrice, int n)
{
      matrice[2][6] = 'A';
}

int main ()
{
     int n = 8;
     char** matrice = (char **) malloc(n*n*sizeof(char))
     free matrice;  // etc pour libérer l'espace...
 
    modifie_la_matrice (matrice, n);

     printf("%c", matrice[2][6]);


     return 0;

}


C'est plus clair comme ça?
loupius - 17 janv. 2009 à 19:16
Ah oui c'est beaucoup plus clair ;=)
Là on est sûr que ça va planter ;=))
Pourquoi ?
Tout simplement qu'après le 'free' il ne faut plus toucher à la variable libérée.
Ajouter un commentaire
Réponse
+0
moins plus
en clair qu'est ce que tu veut faire??
karludwig- 17 janv. 2009 à 19:33
Pffff... de quoi j'ai l'air!

Tout d'abord : merci!
J'ai rectifié, j'ai bien mis le free à la toute fin du programme et comme ça le petit programme d'exemple tourne sans problème...

Donc mon problème est ailleurs :

En fait j'ai une fonction qui modifie la matrice, et une qui l'affiche.

et quand je fais dans le main:
affiche (matrice);
modifie(matrice);
affiche(matrice);

La matrice est affichée deux fois de façon identique... sniif
Serait-ce le compilateur qui me remplace dans la fonction affiche(matrice), les matice[i][j] par leurs valeurs?

Le but est de programmer un arbitrage d'othello (pour l'instant 'B' pour blanc et 'N' pour noir dans la matrice qui est le plateau de jeu).

Encore merci!
Ajouter un commentaire
Réponse
+0
moins plus
Salut,
Comme dit précédemment, ton free devrait se situer à la fin. Et en plus la déclaration de ton tableau est fausse.
Tu dois plutôt faire :
//allocation
matrice=malloc(N);
for(int i=0;i<N;i++)
    matrice[i]=malloc(N);

//désallocation
for(int i=0;i<N;i++)
    free(matrice[i]);
free(matrice);

N'oublie pas de tester si l'allocation échoue ou pas, en testant si le pointeur vaut NULL ou pas afin d'éviter des segfaults bêtes.
Ajouter un commentaire
Réponse
+0
moins plus
Donc après modification voilà mon allocation :

char** m = (char**) malloc(n * n * sizeof(char));
            for (i = 0; i < n; i++)
                    m[i] = (char*) malloc(n * sizeof(char));


et la désallocation :
for (i = 0; i < n; i++)
        free(m[i]);
free(m);


Mais, rien ne bouge au niveau de mon affichage...!
Ajouter un commentaire
Réponse
+0
moins plus
char** m = (char**) malloc(n * n * sizeof(char));
Il faut mettre malloc(n*sizeof(char*)) (pas malloc(n*n)). Sinon ça te fait un tableau n*n lignes, n colonnes.

Sinon, mets ton programme avec ta fonction affichage qu'on puisse voir d'où vient l'erreur.
Ajouter un commentaire
Réponse
+0
moins plus
Si je change malloc(n*n*sizeof(char)) par malloc(n*sizeof(char)), il plante à l'exécution...

J'ai testé ma fonction d'affichage qui apparemment marche parfaitement, ce doit être ma fonction de modification de la matrice qui plante. Je la relis une n ième fois, et je retourne vers vous si je continue à bloquer!
fiddy- 17 janv. 2009 à 20:46
En fait, j'ai fait une erreur d'inattention.
Il faut faire :
matrice=malloc(n*sizeof(char*));
for(int i=0;i<n;i++)
   matrice[i]=malloc(n);

Mais ça ne corrigera pas ton erreur par rapport à ton n*n*sizeof... Jusque ça allouerait la bonne quantité.
Ajouter un commentaire
Réponse
+0
moins plus
J'ai rectifié, j'ai bien mis le free à la toute fin du programme et comme ça le petit programme d'exemple tourne sans problème. J'ai du mal à le croire. Ton allocation est un non sens.
Celle de fiddy est correcte, sauf qu'il a oublié de tenir compte de la taille des variables :

char** m = (char**) malloc(n *  sizeof(char *));
            for (i = 0; i < n; i++)
                    m[i] = (char*) malloc(n * sizeof(char));
fiddy- 17 janv. 2009 à 20:56
Je n'ai rien oublié ;), on la même version (post 10). ^^.
toto - 17 janv. 2009 à 21:02
pardon, j'ai mis longtemps à écrire le message et je n'ai pas vérifié au moment de poster que tu avais déjà rectifié.
Ajouter un commentaire
Réponse
+0
moins plus
Merci beaucoup pour votre aide à propos de l'allocation de la mémoire!
Il subsistait un bug dans la fonction de modification de la matrice (une règle du jeu mal formalisée) et il est maintenant réparé!
Merci à tous pour votre aide précieuse!
Ajouter un commentaire
Ce document intitulé « Matrice en argument d'une fonction! » issu de CommentCaMarche (www.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.
Dossier à la une
Passage au tout numérique : quel coût pour les particuliers ?