C语言中具有动态大小的用户定义类型

我想定义一个新的数据类型，它由一个数组组成，数组的大小由用户输入。例如，如果用户输入128，那么我的程序应该创建一个新类型，它基本上是一个16字节的数组。这个结构的定义需要是全局的，因为我将在以后的程序中使用该类型。这个结构需要有一个动态的大小，因为我最终会有一个由这种类型的变量填充的大型数据库

我现在掌握的代码是：

struct user_defined_integer;
.
.
.
void def_type(int num_bits)
{
    extern struct user_defined_integer 
    {
             int val[num_bits/sizeof(int)];
    };

return;

}

（不起作用）

我发现，最接近我的问题是： （这是没有帮助的）

有没有办法做到这一点，以便在整个文件中识别我的结构？

试试这种方法-

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
struct user_defined_integer
{
        int *val;
}user_int;
void memory_allocate(int num_bit)
{
        int result;
        result = (num_bit+CHAR_BIT-1)/CHAR_BIT; // since 8 bit =1 byte
        user_int.val=malloc(result*sizeof(int));
        if(user_int.val == NULL){
        printf("Failed to allocate memory\n");
        return ;
        }
        else
        printf("Allocated %d bytes for val\n",result);
}
int main()
{
        int num_bit;
        printf("Enter the number of bits\n");
        scanf("%d",&num_bit);
        memory_allocate(num_bit);
        // do your stuff here

        free(user_int.val); // free the memory at the end;
        return 0;
}

#包括
#包括
#包括
结构用户定义的整数
{
int*val；
}用户界面；
无效内存分配（整数位）
{
int结果；
结果=（num\u bit+CHAR\u bit-1）/CHAR\u bit；//因为8位=1字节
user_int.val=malloc（结果*sizeof（int））；
if（user_int.val==NULL）{
printf（“分配内存失败\n”）；
返回；
}
其他的
printf（“为val\n分配了%d字节”，结果）；
}
int main（）
{
整数位；
printf（“输入位数\n”）；
scanf（“%d”、&num_位）；
内存分配（num\u位）；
//在这里做你的事
free（user_int.val）；//最后释放内存；
返回0；
}

执行以下操作时：

extern struct user_defined_integer 
{
         int val[num_bits/sizeof(int)];
};

你应该得到警告：

warning: useless storage class specifier in empty declaration 

因为你有一个空的声明

extern

不适用于

user\u defined\u integer

，而是应用于它后面的变量。其次，这无论如何都不会起作用，因为包含可变长度数组的结构不能有任何链接

error: object with variably modified type must have no linkage

即使如此，可变长度数组也会在声明时分配存储。您应该选择动态内存

#include <stdlib.h>

typedef struct
{
    int num_bits;
    int* val;
} user_defined_integer;

void set_val(user_defined_integer* udi, int num_bits)
{
    udi->num_bits = num_bits;
    udi->val = malloc(num_bits/sizeof(int));
}

#包括
类型定义结构
{
int num_位；
int*val；
}用户定义的整数；
无效集合值（用户定义的整数*udi，整数位）
{
udi->num\u bits=num\u bits；
udi->val=malloc（num_bits/sizeof（int））；
}

您需要的是一名VLA成员，正如被问及的那样。基本上，您可以声明一个

struct

，其中包含一个大小字段和一个元素的存储量作为最后一个成员，并对其进行过度分配

从该问题引出：

typedef struct Bitmapset {
    int nwords;
    uint32 words[1];
} Bitmapset;

Bitmapset *allocate(int n) {
    Bitmapset *p = malloc(offsetof(Bitmapset, words) + n * sizeof *p->words);
    p->nwords = n;
    return p;
}

我想定义一个新的数据类型，它由一个数组组成，数组的大小由用户输入。例如，如果用户输入128，那么我的程序应该创建一个新类型，它基本上是一个16字节的数组

这在C中是不可能的，因为C类型是编译时的东西，在运行时根本不存在

但是，对于符合C99的编译器，您可以使用灵活的数组成员。您需要一个

结构

，其中包含一些成员，并以一个没有任何给定维度的数组结尾，例如

struct my_flex_st {
   unsigned size;
   int arr[]; // of size elements
};

以下是一种分配方法：

struct my_flex_st *make_flex(unsigned siz) {
  struct my_flex_st* ptr 
    = malloc(sizeof(struct my_flex_st) + siz * sizeof(int));
  if (!ptr) { perror("malloc my_flex_st"); exit(EXIT_FAILURE); };
  ptr->size = siz;
  memset (ptr->arr, 0, siz*sizeof(int));
  return ptr;
}

一旦你不再使用它，别忘了释放它

当然，您需要在代码中使用指针。如果您真的想拥有一个全局变量，请将其声明为

extern struct my_flex_st* my_glob_ptr;

---

上面的代码无法编译，函数中定义的结构具有局部作用域；没用的，没用的。使用malloc和长度字段。请注意，您需要对除法结果进行四舍五入，或者确保

num_bits

可被

sizeof（int）

整除，否则您将没有空间存储最后一个位如果

malloc

返回NULL，此程序将崩溃…；）添加

\include

并将

8

替换为

CHAR\u-BIT

。将

num\u-BIT/CHAR\u-BIT

更改为

（num\u-BIT+CHAR\u-BIT-1）/CHAR\u-BIT

，以支持非

CHAR\u-BIT

多位（例如，13位）。您现在可以删除

，因为8位=1字节

注释。但是将

int*val

更改为

char*val

，并在调用

malloc

时删除该

sizeof（int）

。灵活的数组成员是一种更干净的方法。在C99中，是的。在此之前，您别无选择，只能溢出一个长度为1的数组。