Piège d'abandon: 6, en utilisant memcpy pour copier un tableau

Question

J'essaie d'apprendre à copier un espace dans la mémoire qui a été alloué avec malloc. Je suppose que la meilleure façon d'y arriver serait d'utiliser memcpy.

Je suis plus familier avec Python. L'équivalent de ce que j'essaie de faire en Python serait:

import copy 

foo = [0, 1, 2] 
bar = copy.copy(foo) 

Voici où je suis allé jusqu'à présent.

/* Copy a memory space 
* */ 

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

int main(){ 
    // initialize a pointer to an array of spaces in mem 
    int *foo = malloc(3 * sizeof(int)); 
    int i; 

    // give each space a value from 0 - 2 
    for(i = 0; i < 3; i++) 
     foo[i] = i; 

    for(i = 0; i < 3; i++) 
     printf("foo[%d]: %d\n", i, foo[i]); 

    // here I'm trying to copy the array of elements into 
    // another space in mem 
    // ie copy foo into bar 
    int *bar; 
    memcpy(&bar, foo, 3 * sizeof(int)); 

    for(i = 0; i < 3; i++) 
     printf("bar[%d]: %d\n", i, bar[i]); 

    return 0; 
} 

La sortie de ce script est la suivante:

foo[0]: 0 
foo[1]: 1 
foo[2]: 2 
Abort trap: 6 

Je compile le script avec gcc -o foo foo.c. Je suis sur un Macbook Pro 2015.

Mes questions sont les suivantes:

1. Est-ce la meilleure façon de copier un tableau qui a été créé avec malloc?
2. Que signifie Abort trap: 6? Je ne comprends pas ce que fait memcpy ou comment l'utiliser?

Cordialement,

Marcus Shepherd

Answer 1

La bar variable n'a pas la mémoire allouée à elle, il est juste un pointeur uninitialised.

Vous devriez faire comme vous le faisiez avec foo plus tôt

int *bar = malloc(3 * sizeof(int)); 

Et alors vous devez laisser tomber l'& adresse de l'opérateur comme

memcpy(bar, foo, 3 * sizeof(int));