分配變量無效*到無效的C數組

Question

所以我有一個數組，無須提出任何具體類型：

void* buff = malloc(size*eltSize); 

而且我有一個功能，即有一個void *參數，我想將它分配給數組，像這樣：

void function(void* p1){ 
    buff[i] = p1; 
} 

我知道，這是不行的，但說我想讓它儘可能地通用，什麼是最好的辦法嗎？請記住，我不知道使用的類型（它應該接受任何可能的類型;即使結構）。 謝謝

Answer 1

你要通過的元件尺寸（和數組索引，就此而言）手動每次，類似於如何qsort作品。你必須給你的函數更改爲類似：

void function(void * buff, void * p1, size_t elt_size, size_t index){ 
    memcpy(((char *) buff) + index * elt_size, p1, elt_size); 
} 

，並調用它，如：

int array[] = {3, 1, 4, 1, 5, 9}; 
int n = 8; 
function(array, &n, sizeof(n), 5); // Equivalent to array[5] = n; 

一個完整的工作示例：

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

void function(void * buf, void * data, size_t elt_size, size_t index) 
{ 
    memcpy(((char *) buf) + index * elt_size, data, elt_size); 
} 

int main(void) 
{ 
    int narray[] = {3, 1, 4, 1, 5, 9}; 
    int n = 8; 
    function(narray, &n, sizeof(n), 5); // Equivalent to array[5] = n 
    for (size_t i = 0; i < sizeof(narray)/sizeof(narray[0]); ++i) { 
     printf("Value of element [%zu] is: %d\n", i, narray[i]); 
    } 

    char * sarray[] = {"The", "mome", "raths", "outgrabe"}; 
    char * p = "barked"; 
    function(sarray, &p, sizeof(p), 3); // Equivalent to sarray[3] = p 
    for (size_t i = 0; i < sizeof(sarray)/sizeof(sarray[0]); ++i) { 
     printf("Value of element [%zu] is: %s\n", i, sarray[i]); 
    } 

    return 0; 
} 

與輸出：

Paul@Pauls-iMac:~/Documents/src/sandbox$ ./generic2 
Value of element [0] is: 3 
Value of element [1] is: 1 
Value of element [2] is: 4 
Value of element [3] is: 1 
Value of element [4] is: 5 
Value of element [5] is: 8 
Value of element [0] is: The 
Value of element [1] is: mome 
Value of element [2] is: raths 
Value of element [3] is: barked 
Paul@Pauls-iMac:~/Documents/src/sandbox$ 

很明顯，它會工作得很好w ith動態分配malloc()的數組，因爲它將與本示例使用的常規數組一起使用。

，如果你創建一個struct到的數據與元件尺寸抱在一起，比如，你可以無需在每次將元素的大小：

struct generic_array { 
    void * data; 
    size_t elt_size; 
} 

當你傳遞一個指向這個struct到你的功能，它將能夠訪問元素的大小本身，既不需要你提供它，並消除由於你無意中通過錯誤的大小產生的整個類別的錯誤。如果添加第三個成員來存儲最初malloc() ed的元素數量，那麼也可以執行邊界檢查。這種做法的

全部工作示例：

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

struct generic_array { 
    void * data; 
    size_t elt_size; 
    size_t size; 
}; 

struct generic_array * generic_array_create(const size_t elt_size, 
              const size_t size) 
{ 
    struct generic_array * new_array = malloc(sizeof *new_array); 
    if (!new_array) { 
     perror("couldn't allocate memory for array"); 
     exit(EXIT_FAILURE); 
    } 

    void * data = malloc(size * elt_size); 
    if (!data) { 
     perror("couldn't allocate memory for array data"); 
     exit(EXIT_FAILURE); 
    } 

    new_array->data = data; 
    new_array->elt_size = elt_size; 
    new_array->size = size; 

    return new_array; 
} 

void generic_array_destroy(struct generic_array * array) 
{ 
    free(array->data); 
    free(array); 
} 

void generic_array_set(struct generic_array * array, void * elem, 
         const size_t index) 
{ 
    if (index >= array->size) { 
     fprintf(stderr, "Index %zu out of bounds of size %zu.\n", 
       index, array->size); 
     exit(EXIT_FAILURE); 
    } 

    memcpy(((char *)array->data) + index * array->elt_size, 
      elem, array->elt_size); 
} 


void generic_array_get(struct generic_array * array, void * elem, 
         const size_t index) 
{ 
    if (index >= array->size) { 
     fprintf(stderr, "Index %zu out of bounds of size %zu.\n", 
       index, array->size); 
     exit(EXIT_FAILURE); 
    } 

    memcpy(elem, ((char *)array->data) + index * array->elt_size, 
      array->elt_size); 
} 

int main(void) 
{ 
    int narray[] = {3, 1, 4, 1, 5, 9}; 
    const size_t nsize = sizeof(narray)/sizeof(narray[0]); 

    struct generic_array * garray = generic_array_create(sizeof(int), nsize); 

    for (size_t i = 0; i < nsize; ++i) { 
     generic_array_set(garray, &narray[i], i); 
    } 

    for (size_t i = 0; i < nsize; ++i) { 
     int n; 
     generic_array_get(garray, &n, i); 
     printf("Value of element %zu: %d\n", i, n); 
    } 

    generic_array_destroy(garray); 

    return 0; 
} 

Answer 2

既然你嘗試插入指向void類型元素buff，然後buff必須void**類型。

int i = 0; 
void* *buff = malloc(size * sizeof(void*)); 
if (buff == NULL) 
    // handle error 

void function(void* p1) { 
    buff[i] = p1; // now OK 
} 

Answer 3

如果您想記住通用數組中存儲的每個數據的相應類型，這是一個潛在的解決方案。我使用了一個固定大小的數組，並在枚舉中添加基本類型，以及如何在各自類型中取回數據的兩個例子。

如果你有更多的類型並且不想使用大量'if'語句，你可以使用函數指針。

#include <stdio.h> 

enum type { 
    INT, 
    FLOAT, 
    CHAR, 
    STRING 
}; 

struct gen_array { 
    enum type elm_type; 
    void *data; 
}; 

int  to_int(void *data) { 
    return ((int) data); 
} 

char *to_string(void *data) { 
    return ((char *) data); 
} 

void printer(struct gen_array *arr, size_t size) { 
    for (size_t i = 0; i < size; i++) { 

    if (arr[i].elm_type == STRING) 
     printf("%s\n", to_string(arr[i].data)); 

    if (arr[i].elm_type == INT) 
     printf("%d\n", to_int(arr[i].data)); 

    } 
} 

int  main(void) { 
    struct gen_array buff[2]; 

    struct gen_array elm_0; 
    elm_0.elm_type = INT; 
    elm_0.data = (void*)10; 

    buff[0] = elm_0; 

    struct gen_array elm_1; 
    elm_1.elm_type = STRING; 
    elm_1.data = (void*)"helloWorld!"; 

    buff[1] = elm_1; 

    printer(buff, 2); 

    return (0); 
} 

Answer 4

如果要複製的對象，你不知道它的類型，只是它的大小，您使用memcpy：

void* buff = malloc(size*eltSize); 


void function(void* p1) { 
    memcpy((char *)buff + i * eltSize, p1, eltSize); 
} 

由於您不知道類型，因此不能直接使用索引，而必須使用指針算術手動計算地址。