2016-12-02 3 views
0

J'ai 2 tableaux avec des coordonnées et je veux les copier dans un tableau. J'ai utilisé 2 pour les boucles et son fonctionnement, mais je veux savoir, si je pouvais le faire sans eux, je ne sais pas comment utiliser memcpy dans cette situation. Voici mon code:Comment concaténer deux tableaux en C en utilisant memcpy?

int *join(int *first, int *second,int num, int size) { 

int *path= NULL; 
int i = 0 , j = 0; 

path = (int*) malloc (2*size*sizeof(int)); 

    for(i = 0 ; i < num; i++) { 
     path[i * 2] = first[i * 2]; 
     path[i * 2 + 1] = first[i * 2 + 1]; 

    } 

    for(i = num; i < size ; i++) { 
     path[(i*2)] = second[(j+1)*2]; 
     path[(i*2)+1] = second[(j+1)*2 +1]; 
     j++; 
    } 
    return path; 
} 
+2

[S'il vous plaît voir cette discussion sur les raisons de ne pas jeter la valeur de retour de 'malloc()' et de la famille dans 'C'.] (http://stackoverflow.com/q/605845/2173917). –

+0

Ce 'chemin [(i * 2) +1]' écrit dans la mémoire invalide avec la dernière itération. – alk

+0

Votre allocation de mémoire n'utilise pas la bonne taille. Vous devriez utiliser '(size + num) * sizeof (int)', ne devriez-vous pas - ou s'il y a deux fois plus d'entrées dans chaque tableau que la valeur de 'size' ou' num', puis multiple par 2 aussi ? À l'heure actuelle, si le second tableau est plus petit que le premier, vous piétinez hors des limites; si le second tableau est plus grand que le premier, vous gaspillez de l'espace (ce qui est beaucoup moins un problème). Vous devriez vérifier que l'allocation a réussi avant d'utiliser le nouvel espace; les allocations de mémoire échouent. Si vous obtenez les bases correctement, alors 'memcpy (chemin, premier, 2 * num * sizeof (int));'. –

Répondre

3

Calculons Juste le nombre correct d'octets à copier et copier à partir de chaque origine du décalage correct:

int *join(int *first, int *second, int num, int size) { 
    // Compute bytes of first 
    const size_t sizeof_first = sizeof(*first) * 2U * num; 
    // Computes bytes of second as total size minus bytes of first 
    const size_t sizeof_second = sizeof(int) * 2U * size - sizeof_first; 

    int *path = malloc(sizeof(int) * 2U * size); 

    // Copy bytes of first 
    memcpy(path, first, sizeof_first); 
    // Copy bytes of second immediately following bytes of first 
    memcpy(&path[2U * num], second, sizeof_second); 
    return path; 
} 
+0

@chux: Oups, j'avais la déclaration correcte avant, mais lors de l'édition avant de poster j'ai perdu le type dans une erreur copy'n'paste. :-) Fixé. J'ai également déplacé le 'sizeof's comme suggéré; ça ne correspond pas à la commande de l'OP, mais pas de raison de ne pas le réparer pendant que je suis là. – ShadowRanger

+0

thnaks vous tous pour l'aide, cela a beaucoup aidé – mereth

+0

@chux: Heh. Je pensais à cela et j'ai décidé, pour être sûr, de rendre explicitement tous les littéraux de '2'' unsigned', ce qui garantirait que '& path [2U * num]' fonctionne. Et oui, je suis d'accord qu'utiliser 'size_t' de façon appropriée est la meilleure solution, mais je suis plus méfiant de peaufiner le prototype que de peaufiner les internes. – ShadowRanger