将变量void*指定给void C的数组
所以我有一个数组,没有任何指定的类型:将变量void*指定给void C的数组,c,arrays,dereference,C,Arrays,Dereference,所以我有一个数组,没有任何指定的类型: void* buff = malloc(size*eltSize); 我有一个函数,它有一个void*参数,我想把它赋给数组,类似这样: void function(void* p1){ buff[i] = p1; } 我知道这是行不通的,但如果我想让它尽可能通用,那么最好的方法是什么?记住,我不知道所使用的类型(它应该接受任何可能的类型;甚至是struct)。 谢谢因为您尝试将指向void type的指针作为元素插入buff,那么buff必须是
void* buff = malloc(size*eltSize);
我有一个函数,它有一个void*参数,我想把它赋给数组,类似这样:
void function(void* p1){
buff[i] = p1;
}
我知道这是行不通的,但如果我想让它尽可能通用,那么最好的方法是什么?记住,我不知道所使用的类型(它应该接受任何可能的类型;甚至是struct)。
谢谢因为您尝试将指向void type的指针作为元素插入
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
}
如果要记住存储在泛型数组中的每个数据的对应类型,这是一个潜在的解决方案。我使用了一个固定大小的数组,并在枚举中添加了基本类型,以及两个如何以各自的类型返回数据的示例 如果您有更多的类型并且不想使用太多的“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);
}
#包括
枚举类型{
INT,
浮动
烧焦
一串
};
结构gen_数组{
枚举类型elm_类型;
作废*数据;
};
int到_int(void*数据){
返回((int)数据);
}
字符*到字符串(无效*数据){
返回((字符*)数据);
}
无效打印机(结构生成数组*arr,大小){
对于(大小i=0;i
每次都必须手动传递元素大小(以及数组索引),类似于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;
}
显然,它与使用malloc()
动态分配的数组一样,也适用于本例使用的常规数组
如果创建一个struct
将数据和元素大小保存在一起,则无需每次传递元素大小,例如:
struct generic_array {
void * data;
size_t elt_size;
}
当您将指向此结构的指针传递给您的函数时,它将能够访问元素大小本身,既消除了您提供它的需要,也消除了由于您无意中传递了错误大小而导致的一系列错误。如果添加第三个成员来存储最初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;
}
#包括
#包括
#包括
结构泛型数组{
作废*数据;
大小;
大小;
};
结构通用数组*通用数组创建(常量大小),
常数大小(单位大小)
{
结构泛型数组*新数组=malloc(sizeof*新数组);
如果(!新建_数组){
perror(“无法为数组分配内存”);
退出(退出失败);
}
void*data=malloc(尺寸*elt\u尺寸);
如果(!数据){
perror(“无法为数组数据分配内存”);
退出(退出失败);
}
新建_数组->数据=数据;
新建数组->elt\U大小=elt\U大小;
新建_数组->大小=大小;
返回新的_数组;
}
无效泛型数组销毁(结构泛型数组*数组)
{
自由(数组->数据);
自由(数组);
}
无效泛型数组集(结构泛型数组*数组,无效*元素,
常量大小(索引)
{
如果(索引>=数组->大小){
fprintf(stderr,“索引%zu超出大小%zu的界限。\n”,
索引,数组->大小);
退出(退出失败);
}
memcpy(((char*)数组->数据)+索引*数组->elt_大小,
元素、数组->elt_大小);
}
void generic_array_get(结构generic_array*array,void*elem,
常量大小(索引)
{
如果(索引>=数组->大小){
fprintf(stderr,“索引%zu超出大小%zu的界限。\n”,
索引,数组->大小);
退出(退出失败);
}
memcpy(elem,((char*)数组->数据)+索引*数组->elt_大小,
数组->elt\u大小);
}
内部主(空)
{
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);
对于(大小i=0;i
如果要复制对象,但不知道其类型,只知道其大小,请使用memcpy:
void* buff = malloc(size*eltSize);
void function(void* p1) {
memcpy((char *)buff + i * eltSize, p1, eltSize);
}
由于您不知道类型,因此不能直接使用索引,而必须使用指针算法手动计算地址。将buf
声明为void**
。您能更详细地描述计划的数组结构吗?通过阅读您的帖子,我认为您需要一个包含大小eltSize
元素的连续数组,但其他读者似乎认为您需要一个pointers@M.M当然,更正了。谢谢(我想OP想根据他给我们的示例代码来存储泛型指针)。也许吧,但这样就不清楚eltSize
应该代表什么了。我同意。可能是元素的大小。我不知道我怎么会忘记memcpy(..)。谢谢你的回答。
void* buff = malloc(size*eltSize);
void function(void* p1) {
memcpy((char *)buff + i * eltSize, p1, eltSize);
}