C Programmation. Comment faire une copie en profondeur une structure?

Simplement:

childB.usage = childA.usage;

ne devrait-il pas être: xxx

Premièrement, le code correct est

memcpy(&childA,&childB, sizeof(child));

Childb.Usage = Enfonda.Unage

Puisque vous avez la structure entière à l'intérieur de la structure de l'enfant, une copie simple suffit. Si vous aviez un pointeur à la structure de rusion dans la structure de l'enfant, cela aurait pu être un problème. Dans ce cas, vous auriez dû allouer la mémoire pour mailled.Usage et ensuite faire un memcpy de sorte que si quelqu'un modifie / supprime l'enfant, la petite taille sera indemne.

Vous pourriez deux que de deux manières, comme d'autres l'ont mentionné.

1) Childb.Usage = Enfonda.Usage;
2) memcpy (& couled.Unsage, & encadré.Unage, taille de (rusion));

Premier argument de MEMCY est la destination, la seconde est la source et que la troisième est la longueur (combien d'octets que vous souhaitez copier). Du code que vous avez affiché, vous essayiez de copier tout l'enfant à Enfile, ce qui n'est vraiment pas que vous vouliez.

Dans ce fichier, je copie les membres de l'origine à Destinazione, en utilisant d'abord des affectations et Strcpy, puis je copie l'origine des MEMRES, en utilisant uniquement MemcPY

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct inner
{
    char *parola;
    int n;
} interna;

typedef struct outer
{
    struct inner *ptr;
    int numeroesterno;
} esterna;


struct another
{
    struct inner *ptr;
    int numero;
};    //never forget ; here

int main(void)
{
    esterna *origine; //ptr to structs
    struct another *destinazione;
    struct another *memres;

    char *tmpParola;
    tmpParola = malloc(30*sizeof(char));
    strcpy(tmpParola, "AAAAA");

    interna *tmp;  //remember the TYPEDEF, and don't use struct interna
    tmp = (interna *)malloc(sizeof(struct inner));
    // if you use struct interna in sizeof you get
    //  error: invalid application of ‘sizeof’ to incomplete type ‘struct interna’ 

    tmp->n = 500;
    tmp->parola = tmpParola;

    origine = (esterna *)malloc(sizeof(struct outer));

    origine->numeroesterno = 2;
    origine->ptr = tmp;  //the data structer pointed by tmp has already been allocated and set

    // now I have the structure allocated and set, I want to copy this on destinazione
    destinazione = (struct another *)malloc(sizeof(struct another));

    destinazione->numero = origine->numeroesterno;

    //destinazione->ptr = tmp;  //in this case you don't copy struct inner, it's just a reference

    destinazione->ptr = (interna *)malloc(sizeof(struct inner));
    destinazione->ptr->parola = malloc(sizeof(char)*30);
    strcpy(destinazione->ptr->parola, origine->ptr->parola);
    destinazione->ptr->n = 111;

    //modify origine

    origine->numeroesterno = 9999;
    strcpy(origine->ptr->parola, "parola modificata in origine");

    //print destinazione

    printf("\nparola in destinazione :%s\n", destinazione->ptr->parola);
    printf("\nparola in origine :%s\n", origine->ptr->parola);

    //you can see that destinazione is a copy, because mofifying origine, destinazione deosn't change

    //now we play with memcpy

    memres = (struct another *)malloc(sizeof(struct another));

    memcpy(memres, destinazione, sizeof(destinazione)); //till here, is AAAAA
    strcpy(destinazione->ptr->parola, "parola modificata in destinazione");

    printf("\nmemcpy, numero %d\n", memres->numero);
    printf("\nmemcpy, parola :%s\n", memres->ptr->parola);

    //as you can see from the output, memcpy doesn't make a copy of destinazione:
    //modifying destinazione->ptr->parola after the assignment affects what memres carries with it
    //So from the idea that I got, memcpy just creates the pointers to the originary structure

    free(origine->ptr->parola);
    free(origine->ptr);
    return 0;
}

EDIT: OK, j'ai mal interprété la question, vous ne vouliez que copier le champ d'utilisation; Donc, ma réponse est un peu non liée. Je ne le supprime pas car il peut encore rappeler les débutants du problème d'aliose potentiel lors de l'attribution ou du double de la structure contenant des pointeurs contenant de la structure.

memcpy ou attribution des autres réponses fonctionnera , bien sûr. Le seul danger de votre structure vient du pointeur à nommer. Si vous copiez une structure à l'autre, vous aurez les deux structures contenant le pointeur le même et la pointe de la même mémoire. Vous avez créé un alias. Cela signifie que si vous changez le nom dans l'espace alloué, il sera visible de l'autre structure. De plus, il y a le danger d'un double gratuit si vous passez votre structure à la fonction libre standard. Pour faire un vrai duplicata de la struct, vous devez faire quelque chose comme ça: xxx

ou alternativement xxx