Copie totale de structures

Version imprimable

Copie *totale* de structures

Bonjour.

Je n'arrive pas à faire une copie *complète* de structure. Les cas rencontrés dans
les FAQs que j'ai lues ne traitaient que du cas simple d'une copie sans "profondeur"
et sans pointeur.
Lorsque j'utilise "memcopy" les résultats sont identiques.
Faut-il passer par "malloc" ?

Je vous fournis un code (artificiel, juste pour illustrer mon problème).

Je crée donc une voiture "car1" qui me sert de modèle pour créer une
autre, "car2". Dans mon cas réel j'ai beaucoup plus de champs dans
mes structures.
Un point à noter : dans la structure "Car" je veux un *pointeur*
sur la structure "Engine", parce qu'il pourra se faire que la voiture
n'aie pas de moteur (donc p_engine = NULL).

En dessous du code figure ce que j'obtiens dans ma console.

Je débute en C. Merci.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 #inclut <stdio.h> struct Engine { int displacement; }; struct Car { int mass; struct Engine * p_engine; }; void copy_engine(struct Engine * p_engine_src, struct Engine * p_engine_dest) { p_engine_dest->displacement = p_engine_src->displacement; return; } void copy_car(struct Car * p_car_src, struct Car * p_car_dest) { p_car_dest->mass = p_car_src->mass; copy_engine(p_car_src->p_engine, p_car_dest->p_engine); return; } void build_engine(struct Engine * p_engine) { p_engine->displacement = 1400; return; } void build_car(struct Car * p_car) { struct Engine engine; build_engine(&engine); p_car->mass = 1200; return; } void print_car(struct Car * p_car) { printf("car:%p\n", (void *) p_car); printf(" car.mass:%d\n", p_car->mass); printf(" car.p_engine:%p\n", (void *) p_car->p_engine); printf(" car.p_engine.displacement:%d\n", p_car->p_engine->displacement); return; } int main (int argc, char *argv[]) { struct Car car1; struct Car car2; build_car(&car1); copy_car(&car1, &car2); print_car(&car1); print_car(&car2); return 0; }
Code:

1 2 3 4 5 6 7 8 9 car:0xbff75a3c car.mass:1200 car.p_engine:0xb7dcdc8c car.p_engine.displacement:18589 car:0xbff75a34 car.mass:1200 car.p_engine:0xbff75a58 car.p_engine.displacement:18589

Citation:

Envoyé par bourba

Je vous fournis un code (artificiel, juste pour illustrer mon problème).

Merci de vérifier le code avant de le poster ...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 -------------- Build: Debug in hello --------------- Compiling: main.c Linking console executable: bin\Debug\hello.exe C:\dev\hello\main.c:1:2: invalid preprocessing directive #inclut C:\dev\hello\main.c: In function `print_car': C:\dev\hello\main.c:46: warning: implicit declaration of function `printf' C:\dev\hello\main.c: At top level: C:\dev\hello\main.c:54: warning: unused parameter 'argc' C:\dev\hello\main.c:54: warning: unused parameter 'argv' Process terminated with status 1 (0 minutes, 0 seconds) 1 errors, 3 warnings
La première question à se poser est "ai-je vraiment besoin de copier une structure ?"

Ensuite, si tu y tiens, pour une structure linéaire, il suffit d'utiliser l'opérateur d'affectation '='.

Si la structure n'est pas linéaire (pointeurs), c'est plus compliqué. Il faut écrire une fonction qui recrée une nouvelle structure. Certaines parties pointées sont peut être statiques, d'autre dynamiques. Il faut le savoir à coup sur, quitte à ajouter un flag...

C'est relativement complexe, et encore une fois, est-ce bien nécessaire ?

Dans ton code, la fonction qui crée la structure est incorrecte.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 #include <stdio.h> struct Engine { int displacement; }; struct Car { int mass; struct Engine *p_engine; }; static void build_engine (struct Engine *p_engine) { p_engine->displacement = 1400; return; } static void build_car (struct Car *p_car) { struct Engine engine; build_engine (&engine); p_car->mass = 1200; return; } static void print_car (struct Car *p_car) { printf ("car:%p\n", (void *) p_car); printf (" car.mass:%d\n", p_car->mass); printf (" car.p_engine:%p\n", (void *) p_car->p_engine); printf (" car.p_engine.displacement:%d\n", p_car->p_engine->displacement); return; } int main (void) { struct Car car1; build_car (&car1); print_car (&car1); return 0; }
car1.p_engine n'est jamais initialisé.

Attention, il doit l'être avec une adresse valide pendant l'exécution, c'est à dire statique ou dynamique. Elle ne peut être locale, que si elle provient du plus haut niveau (main()). A éviter.

18/03/2009, 10h52
bourba

Désolé ! J'avais évidemment bien "#include" dans ma source,
j'ai dû substituer par erreur dans le correcteur orthographique... ;)

Sur le fond...
J'ai déjà lu qu'il était inhabituel de copier des structures. Ça me
surprend un peu.
Imaginons que mon application crée et manipule des voitures, je
peux donc créer une pile stockant les adresses de chaque
structure "Car" créée au fur et à mesure.
Imaginons que l'on souhaite ensuite se servir d'une voiture comme
*modèle* pour en créer une autre. Je fournirai donc l'adresse de
la struct Car source et celle de la structure Car destination, en
modifiant éventuellement des champs de la deuxième par la suite.
J'aurai donc, sans rentrer dans le détail de l'implémentation :

Une liste chaînée :

all_cars = ( 0xab0... : adresse N°1 d'une structure Car,
0xdb1... : adresse N°2 d'une structure Car, ... )

Une fonction de création :

void copy_car(struct Car * p_car_src, struct Car * p_car_dest) { ... }

Dans une application réelle j'aurais probablement beaucoup de champs
dans "Car", l'idée de copie me semblait extrêmement naturelle.
Je n'arrive pas à voir ce qu'il y a de non conforme dans l'esprit
du C dans une copie de structure.
18/03/2009, 10h56
Emmanuel Delahaye

Citation:

Envoyé par bourba

J'ai déjà lu qu'il était inhabituel de copier des structures. Ça me
surprend un peu.
Imaginons que mon application crée et manipule des voitures, je
peux donc créer une pile stockant les adresses de chaque
structure "Car" créée au fur et à mesure.
Imaginons que l'on souhaite ensuite se servir d'une voiture comme
*modèle* pour en créer une autre.

Voilà. C'est à peu près le seul cas 'réel' que je connaisse.

Mais il y a déjà des erreurs dans la code de base. Tu as une correction à me proposer ?

Ce code fonctionne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
#include <stdio.h>
 
struct Engine {
    int displacement;
};
 
struct Car {
    int mass;
    struct Engine * p_engine;
};
 
void copy_engine(struct Engine * p_engine_src, struct Engine * p_engine_dest) {
 
    p_engine_dest->displacement = p_engine_src->displacement;
 
    return;
}
 
void copy_car(struct Car * p_car_src, struct Car * p_car_dest) {
 
    p_car_dest->mass = p_car_src->mass;
    copy_engine(p_car_src->p_engine, p_car_dest->p_engine);
 
    return;
}
 
void build_engine(struct Engine * p_engine) {
 
    p_engine->displacement = 1400;
 
    return;
}
 
void build_car(struct Car * p_car, struct Engine * p_engine) {
 
    build_engine(p_engine);
    p_car->p_engine = p_engine;
    p_car->mass = 1200;
 
    return;
}
 
void print_car(struct Car * p_car) {
 
    printf("car:%p\n", (void *) p_car);
    printf("  car.mass:%d\n", p_car->mass);
    printf("  car.p_engine:%p\n", (void *) p_car->p_engine);
    printf("  car.p_engine.displacement:%d\n", p_car->p_engine->displacement);
 
    return;
}
 
int main (int argc, char *argv[]) {
 
    struct Car car1;
    struct Car car2;
    struct Engine engine1;
 
    build_car(&car1, &engine1);
    copy_car(&car1, &car2);
    car2.p_engine->displacement = 1600;
 
    print_car(&car1);
    print_car(&car2);
 
    return 0;
}

Retour console :

car:0xbfd4601c
car.mass:1200
car.p_engine:0xbfd46010
car.p_engine.displacement:1400
car:0xbfd46014
car.mass:1200
car.p_engine:0xbfd46038
car.p_engine.displacement:1600

18/03/2009, 11h16
bourba

C'est étonnant ce que tu me dis, "cloner" des structures est une opération qui m'a très souvent parue être nécessaire ! Je dois manquer de recul en programmation C ;)
Ou un début d'intoxication par la POO ?

Citation:

Envoyé par bourba

Ce code fonctionne :

par hasard uniquement. Chez moi, c'est le crash :

Code:

1
2
3
4
5
6
7
8
 
car:0022FF38
  car.mass:1200
  car.p_engine:0022FF44
  car.p_engine.displacement:1400
 
Process returned -1073741819 (0xC0000005)   execution time : 4.282 s
Press any key to continue.

le p_engine de la deuxième structure n'est pas initialisé. Tu le déréférences : le comportement est indéfini.

Pour éviter les comportements hasardeux, je conseille d'initialiser les structures avant usage :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
#include <stdio.h>
 
struct Engine
{
   int displacement;
};
 
struct Car
{
   int mass;
   struct Engine *p_engine;
};
 
static void copy_engine (struct Engine *p_engine_src,
                         struct Engine *p_engine_dest)
{
   p_engine_dest->displacement = p_engine_src->displacement;
}
 
static void copy_car (struct Car *p_car_src, struct Car *p_car_dest)
{
   p_car_dest->mass = p_car_src->mass;
   copy_engine (p_car_src->p_engine, p_car_dest->p_engine);
}
 
static void build_engine (struct Engine *p_engine)
{
   p_engine->displacement = 1400;
}
 
static void build_car (struct Car *p_car, struct Engine *p_engine)
{
   build_engine (p_engine);
   p_car->p_engine = p_engine;
   p_car->mass = 1200;
 
}
 
static void print_car (struct Car const *p_car)
{
   printf ("car:%p\n", (void *) p_car);
   printf ("  car.mass:%d\n", p_car->mass);
   printf ("  car.p_engine:%p\n", (void *) p_car->p_engine);
   printf ("  car.p_engine.displacement:%d\n", p_car->p_engine->displacement);
 
}
 
int main (void)
{
   struct Car car1 = {0};
   struct Engine engine1 = {0};
 
   build_car (&car1, &engine1);
   print_car (&car1);
 
   {
      struct Car car2 = {0};
      copy_car (&car1, &car2);
      car2.p_engine->displacement = 1600;
      print_car (&car2);
   }
   return 0;
}

18/03/2009, 12h32
bourba

Chez moi aucun problème avec :

gcc -pedantic -Wall -o test src.c

Mon compilateur est, en tapant "gcc -v" :

Using built-in specs.
Target: i486-linux-gnu
Configured with: ../src/configure -v --enable-languages=c,c++,fortran,objc,obj-c++,treelang --prefix=/usr --enable-shared --with-system-zlib --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --enable-nls --program-suffix=-4.1 --enable-__cxa_atexit --enable-clocale=gnu --enable-libstdcxx-debug --enable-mpfr --with-tune=i686 --enable-checking=release i486-linux-gnu
Thread model: posix
gcc version 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)

Donc si ça plante chez toi, ça dépasse mes modestes compétences... Je ne connais pas l'investigation à mener dans ce cas.
18/03/2009, 12h34
bourba

Arg.... je regarde mon code...

[EDIT] Ok merci beaucoup pour ton aide, j'ai saisi le truc.