Assign variable void* to array of void C - c

Question

So I have an array, without any specified type:
void* buff = malloc(size*eltSize);
And I have a function, that has a void* parameter, and I want to assign it to the array, something like this:
void function(void* p1){
buff[i] = p1;
}
I know that this doesn't work, but say I want to make it as generic as possible, what's the best way to do? Remember, I have no idea about the types used (It should accept any type possible; even struct).
Thank you

Answer 1

You have to pass the element size (and the array index, for that matter) manually each time, similar to how qsort works. You'd have to change your function to something like:
void function(void * buff, void * p1, size_t elt_size, size_t index){
memcpy(((char *) buff) + index * elt_size, p1, elt_size);
}
and call it such as:
int array[] = {3, 1, 4, 1, 5, 9};
int n = 8;
function(array, &n, sizeof(n), 5); // Equivalent to array[5] = n;
A full working example:
#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;
}
with output:
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$
Obviously it will work just as well with arrays dynamically allocated with malloc() as it will with the regular arrays that this example uses.
You can eliminate the need to pass the element size every time if you create a struct to hold the data and the element size together, for instance:
struct generic_array {
void * data;
size_t elt_size;
}
When you pass a pointer to this struct to your function, it'll be able to access the element size itself, both eliminating the need for you to provide it, and eliminating a whole category of bugs arising from you inadvertently passing the wrong size. If you add a third member to store the number of elements you initially malloc()ed, then you can do bounds-checking, too.
Full working example of that approach:
#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

If you want to copy an object, and you don't know its type, only its size, you use memcpy:
void* buff = malloc(size*eltSize);
void function(void* p1) {
memcpy((char *)buff + i * eltSize, p1, eltSize);
}
Since you don't know the type, you can't use indexing directly, but rather have to manually calculate the address with pointer arithmetic.

Answer 3

Since you try to insert pointer to void type as element to buff, then buff must be of void** type.
int i = 0;
void* *buff = malloc(size * sizeof(void*));
if (buff == NULL)
// handle error
void function(void* p1) {
buff[i] = p1; // now OK
}

Answer 4

This is a potential solution if you want to remember the corresponding type of each data stored in your generic array. I used a fixed size array, and add basic type in the enum and just two exemple of how to get back your data in their respective type.
You could use function pointers if you have more type and don't want to use a lot the 'if' statements.
#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);
}