Question d'implémentation

Salut !

Alors voilà je bloque complétement sur un projet que l'on m'a donné en m'imposant certains prototypes de fonctions. Je vais un peu simplifier les fonctions J'ai

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

typedef struct machin_s
{
    int blabla;
    ...
} machin;

int initialise(machin* m); // Alloue la mémoire, et initialise les valeurs
int modifie(machin m); // Qui modifie des champs dans la structure

//et disons que je veux les utiliser

int main()
{
   machin* m;
   initialise(m);
   modifie(*m);
   return 0;
}

Seulement je comprend pas comment il est possible de modifier les valeurs(avec la fonction modifie), sachant que si je lui envoie "son image", ce sera pas vraiment m qui sera modifier mais sa copie. Dans la logique des choses modifie(…) devrait prendre un type pointeur également et non pas "machin" directement.

Je sais pas si je suis très clair, mais si quelqu'un a une idée de comment modifier les valeurs de "m" sans utiliser un pointeur pour cela.

Merci

Lu'!

Le passage est fait par valeur … y compris pour les données internes. Donc si ta structure matrice contient un pointeur vers les données, dans ta fonction le pointeur indiquera le bon endroit dans la mémoire pour la modification :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <assert.h>

struct machin{
  int* something;
};

void assert_same_something(struct machin m, int* some){
  assert(m.something == some);
}

int main(){
  struct machin m;
  assert_same_something(m, m.something);
}

Oui mais si je modifie dans assert_same_something m.something, et puis que dans mon main j'affiche m.something il aura pas la nouvelle valeur.

Si tu veux faire une allocation dans initialise, c'est plutôt ** qu'il faut recevoir. Globalement une mauvaise idée.

Cela veut dire que tu vas devoir recevoir ainsi.

1
2

machin m;
initialise(&m); // il est impératif qu'initialise() reçoive un truc alloué quelque part!

Et si tu veux allouer machin en plus, rajoute plutôt un:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

machin * new_machin() {
   machin * m = malloc(sizeof(machin));
   if (m) initialise(m); // sinon => erreur plus de mémoire
   return m;
}
.....

machin * m = new_machin();
if (m) {
    modifie(m);
}
free(m); 
// on peut prévoir à la place un delete_machin() qui fait detruit(m) puis free(m).
// surtout si le initialise alloue des champs/ressources dans le machin.

Salut,

Comme l'a dit Ksass`Peuk, c'est impossible en C étant donné que les arguments sont passés par valeur et non par référence. Il y a certainement une erreur dans le prototype fourni ou alors c'est que le retour de la fonction modifie() doit être affecté par la suite à un champ de la structure.