Quelqu'un peut-il expliquer pourquoi je reçois cette erreur avec les types?

Question

Je suis plus ou moins nouveau en utilisant des pointeurs en C, donc désolé si je fais des erreurs horribles! Dans ce cas, j'essaie simplement de copier tous les éléments d'un vecteur flottant dans un autre.

je le morceau de code suivant dans mon fichier main.c, qui fonctionne très bien:

/* NOTE: hash_list is a global variable*/ 
void insertDataIntoOurHashList(int dia, int delay, char *aeO, char *aeD){ 
    unsigned int numHash; 
    ListData *listData; 

    numHash = getHashValue(aeO); 

    /* If there's no list yet in this position, then... */ 
    if (hash_list[numHash] == NULL) { 
     hash_list[numHash] = malloc(sizeof(List)); 
     initList(hash_list[numHash]); 
     listData = malloc(sizeof(ListData)); 
     listData->key = malloc(sizeof(char*)*strlen(aeD)+1); 
     strcpy(listData->key, aeD); 
     listData->key_sec = malloc(sizeof(char*)*strlen(aeO)+1); 
     strcpy(listData->key_sec, aeO); 
     listData->numTimes = 1; 
     listData->retrasos = (float*) malloc(sizeof(float)*7); 
     listData->retrasos[dia-1] = delay; 
     insertList(hash_list[numHash], listData); 
    } 
    else { 
     listData = findList2(hash_list[numHash],aeD,aeO); 

     /* If already exists a data with both equals keys, then... */ 
     if (listData != NULL) { 
      listData->numTimes++; // We add in one the counter of the list 
      listData->retrasos[dia-1] = listData->retrasos[dia-1] + delay/2; 
     } 
     /* If exists a data with the same aeD as primary key but not with the aeO as secundary key, then... */ 
     else { 
      listData = malloc(sizeof(ListData)); 
      listData->key = malloc(sizeof(char*)*strlen(aeD)+1); 
      strcpy(listData->key, aeD); 
      listData->key_sec = malloc(sizeof(char*)*strlen(aeO)+1); 
      strcpy(listData->key_sec, aeO); 
      listData->numTimes = 1; 
      listData->retrasos = (float*) malloc(sizeof(float)*7); 
      listData->retrasos[dia-1] = delay; 
      insertList(hash_list[numHash], listData); 
     } 
    } 
    free(aeO); 
    free(aeD); 
} 

ListData * listData est un pointeur qui pointe vers une structure définie dans mon lié-liste.h fichier, et _hash_list_ est un vecteur de pointeurs de type Liste où chacun des points à une liste de type Liste, défini dans le même fichier:

/** 
* 
* The TYPE_LIST_KEY is used to define the type of the primary 
* key used to index data in the list. 
* 
*/ 

#define TYPE_LIST_KEY char* 

/** 
* 
* This structure holds the information to be stored at each list item. Change 
* this structure according to your needs. In order to make this library work, 
* you also need to adapt the functions compEQ and freeListData. For the 
* current implementation the "key" member is used search within the list. 
* 
*/ 

typedef struct ListData_ { 
    // The variable used to index the list has to be called "key". 
    TYPE_LIST_KEY key; 
    char *key_sec; 
    // This is the additional information that will be stored 
    // within the structure. This additional information is associated 
    // to the key. You may include any field you may need useful. 
    float *retrasos; 
    int numTimes; 
} ListData; 

/** 
* 
* The item structure 
* 
*/ 

typedef struct ListItem_ { 
    ListData *data; 
    struct ListItem_ *next; 
} ListItem; 

/** 
* 
* The list structure 
* 
*/ 

typedef struct List_ { 
    int numItems; 
    ListItem *first; 
} List; 

Puis, dans mon main.c fichier, je boucle à travers tous les cellule dans mon _hash_list_, en passant la liste que pointe le pointeur de cette cellule à une fonction qui prend les données de la liste et les transmettre à une autre fonction, je veux dire:

void insertInHash(){ 
    int i; 

    for(i = 0; i < HASH_SIZE; i++){ 
    if (hash_list[i] != NULL) { 
     dumpList2(hash_list[i]); 
    } 

    } 
} 

/* This function is called for every cell while looping the hash_list */ 
void dumpList2(List *l){ 
    ListItem *current; 

    current = l->first; 

    while (current != NULL) 
    { 
    insertDataIntoOurTree(current->data->key_sec, current->data->key, current->data->retrasos); 
    current = current->next; 
    } 

} 


void insertDataIntoOurTree(char *aeO, char *aeD, float *delays){ 
    List *list; 
    ListData *listData; 
    int i; 

    /* Case when the node exists! */ 
    if (treeData != NULL) { 
    treeData->num++; // We add in one the counter of treeData 
    listData = findList(treeData->list, aeD); // We check if the new destination airport is inside the list of the node... 

    /* If the destination is inside the list... */ 
    if(listData != NULL) 
     listData->numTimes++; // We add in one the counter of the list 

    /* If the destination isn't inside... */ 
    else { 
     /* We create and initialize the new item the list of the node will contain! */ 
     listData = malloc(sizeof(ListData)); 
     listData->key = malloc(sizeof(char*)*strlen(aeD)+1); // Counting with the final '\0' byte! 
     strcpy(listData->key, aeD); // Remember the case as above with aeO and aeD 
     listData->numTimes = 1; 
     listData->retrasos = (float*) malloc(sizeof(float)*7); 
     //listData->retrasos[dia-1] = delay; // minus one cos we don't want to be out of bound! ;) 
     //copyDelays(listData->retrasos, delays); 
     for (i = 0; i < 7; i++) { 
     listData->retrasos[i] = 0.0; 
     } 
     copyDelays(listData->retrasos, delays); 

     insertList(treeData->list, listData); 
    } 
    } 
    /* THERE ARE MORE CASES DOWN HERE, BUT THEY DON'T MATTER NOW... */ 

} 

La fonction copyDelays est défini dans mon lié-list.c fichier:

void copyDelays(float *delaysToCopy, float *delays){ 
    int i; 

    for (i = 0; i < 7; i++) { 
    if (delaysToCopy[i] == 0.0) { 
     memcpy(delaysToCopy[i], delays[i], sizeof(float)); 
    } 
    } 
} 

Et enfin, quand je tente de compiler tous mes fichiers, je reçois cette erreur Je ne comprends pas:

linked-list.c:234:14: error: passing 'float' to parameter of incompatible type 'const void *' 
     memcpy(delaysToCopy[i], delays[i], sizeof(float*)); 
     ^~~~~~~~~~~~~~~ 
/usr/include/secure/_string.h:65:59: note: expanded from macro 'memcpy' 
    __builtin___memcpy_chk (dest, src, len, __darwin_obsz0 (dest)) 
                 ^~~~ 
/usr/include/secure/_common.h:38:55: note: expanded from macro '__darwin_obsz0' 
#define __darwin_obsz0(object) __builtin_object_size (object, 0) 
                ^~~~~~ 
1 error generated. 
make: *** [linked-list.o] Error 1 

Answer 1

Le problème est que les arguments que vous avez transmis à la fonction memcpy() ne pas ma tch avec la signature de la fonction. signature de la fonction memcpy() est la suivante: (http://www.cplusplus.com/reference/cstring/memcpy/)

void * memcpy (void * destination, const void * source, size_t num); 

Comme vous le voyez, il prend des pointeurs comme arguments premier et deuxième, alors que delaysToCopy[i] et delays[i] ne sont pas des pointeurs flottent juste.

Il devrait résoudre votre problème si vous utilisez signe esperluette pour obtenir leurs adresses, comme indiqué ci-dessous:

memcpy(&delaysToCopy[i], &delays[i], sizeof(float));