Question d'implémentation

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

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 :)

+0 -0

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);
}

First : Always RTFM - "Tout devrait être rendu aussi simple que possible, mais pas plus." A.Einstein

+0 -0
Auteur du sujet

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);
}

Ksass`Peuk

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.

+0 -0

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.

Édité par lmghs

+0 -0
Staff

Salut,

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.

Tick

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.

Édité par Taurre

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte