सी प्रोग्रामिंग। एक संरचना की गहरी प्रतिलिपि कैसे करें?

Question

मेरे पास निम्नलिखित दो structs हैं जहां "बाल संरचना" में एक तत्व के रूप में "rusage struct" है।

तो मैं के प्रकार के "बच्चा" दो structs बनाने के लिए उन्हें कॉल बच्चे और childB

मैं कैसे बच्चे से childB करने के लिए सिर्फ rusage struct नकल करते हैं?

typedef struct{       
     int numb; 
     char *name; 
     pid_t pid; 
     long userT; 
     long systemT; 
     struct rusage usage; 
}child; 


typedef struct{ 
    struct timeval ru_utime; /* user time used */ 
    struct timeval ru_stime; /* system time used */ 
    long ru_maxrss;  /* maximum resident set size */ 
    long ru_ixrss;   /* integral shared memory size */ 
    long ru_idrss;   /* integral unshared data size */ 
    long ru_isrss;   /* integral unshared stack size */ 
    long ru_minflt;  /* page reclaims */ 
    long ru_majflt;  /* page faults */ 
    long ru_nswap;   /* swaps */ 
    long ru_inblock;  /* block input operations */ 
    long ru_oublock;  /* block output operations */ 
    long ru_msgsnd;  /* messages sent */ 
    long ru_msgrcv;  /* messages received */ 
    long ru_nsignals;  /* signals received */ 
    long ru_nvcsw;   /* voluntary context switches */ 
    long ru_nivcsw;  /* involuntary context switches */ 

}rusage; 

मैं निम्नलिखित किया था, लेकिन मैं इसे प्रतियां स्मृति स्थान लगता है, क्योंकि यदि मैं बच्चे में उपयोग के मूल्य बदल गया है, यह भी childB में बदल जाता है।

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

मुझे पता है कि बच्चे को बच्चे से सभी मूल्य मिलते हैं। मैंने पहले ही बच्चे के अन्य क्षेत्रों की देखभाल की है, मुझे सिर्फ "बच्चे" संरचना में रहने वाले उपयोग नामक रूजेज संरचना की प्रतिलिपि बनाने में सक्षम होना चाहिए।

Answer 1

सीधे शब्दों में

:

childB.usage = childA.usage; 

Answer 2

यह हो नहीं करना चाहिए:

memcpy(&(childB.usage), &(childA.usage), sizeof(rusage)) 

Answer 3

पहले, सही कोड,

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

पीछे नहीं है यह मान, असीस के लिए बहुत की प्रतिलिपि बनाएगा उन सभी लंबे और समय के structs यह सुरक्षित होगा, लेकिन आपके पास * char * नाम पैरामीटर होगा पॉइंटर एक ही मूल मूल्य के लिए।

Answer 4

childB.usage = childA.usage

जब से तुम बच्चे संरचना के भीतर पूरी संरचना है, साधारण कॉपी पर्याप्त होता। यदि आपके पास बाल संरचना के अंदर रूजेज संरचना के लिए सूचक था, तो यह एक समस्या हो सकती थी। उस स्थिति में, आपको childB.usage के लिए स्मृति आवंटित करनी पड़ती थी और फिर एक memcpy करते हैं ताकि अगर कोई बच्चे को संशोधित/हटा देता है, तो बच्चे बी को बेकार कर दिया जाएगा।

Answer 5

आप दो तरीकों से दो तरीकों से कर सकते हैं, जैसा कि अन्य ने उल्लेख किया है।

1) childB.usage = childA.usage;
2) memcpy (& childB.usage, & childA.usage, sizeof (rusage));

memcpy का पहला तर्क गंतव्य है, दूसरा स्रोत है और तीसरा एक लंबाई है (आप कितने बाइट कॉपी करना चाहते हैं)। आपके द्वारा पोस्ट किए गए कोड से, आप पूरे बच्चे को बच्चे को कॉपी करने की कोशिश कर रहे थे, जो वास्तव में आप नहीं चाहते थे।

Answer 6

इस फ़ाइल में

मैं Destinazione को origine, जो पहले कार्य केवल का उपयोग करने और strcpy के सदस्यों की नकल है, तो, मैं origine memres को कॉपी, केवल 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; 
} 

Answer 7

संपादित करें का उपयोग कर: ठीक है, मैं प्रश्न पढ़ने में भूलना , आप केवल उपयोग क्षेत्र की प्रतिलिपि बनाना चाहते थे; तो मेरा जवाब थोड़ा असंबंधित है। मैं इसे हटा नहीं देता क्योंकि यह पॉइंटर्स युक्त संरचना को असाइन या डुप्लिकेट करते समय संभावित एलियासिंग समस्या के शुरुआती लोगों को याद दिला सकता है।

memcpy या अन्य उत्तरों का असाइनमेंट निश्चित रूप से काम करेगा। आपके ढांचे में एकमात्र खतरा पॉइंटर से नाम तक आता है।यदि आप एक स्ट्रक्चर को दूसरी ओर कॉपी करते हैं तो आपके पास समान पॉइंटर और एक ही मेमोरी को इंगित करने वाली दोनों संरचनाएं होंगी। आपने उपनाम बनाया इसका मतलब है कि यदि आवंटित स्थान में नाम बदल जाता है, तो यह अन्य संरचना से दिखाई देगा। इसके अलावा, यदि आप अपनी संरचना को मानक मुक्त फ़ंक्शन पर पास करते हैं तो डबल free का खतरा होता है। बनाने के struct के एक असली नकली आप ऐसा कुछ करना चाहिए:

memcpy(&childA,&childB, sizeof(rusage));  
if(childB.name) 
    childA.name = strdup(childB.name); 

या वैकल्पिक रूप से

childA = childB; 
if(childB.name) 
    childA.name = strdup(childB.name);