Question

当Set_a不包含Set_a时，我想将Set_b的元素插入到Set_a列表中。我的意思是那样{1,2,3}∪{3,4,5} = {1,2， 3,4,5}。

typedef struct
{
   ElemType data[MAXSIZE];
   int length;
}SqList;

但首先，当我想创建一个新列表时，我遇到了一个编译警告：赋值在没有强制转换的情况下从指针生成整数：

 void CreateList(SqList *L)
{


   L->data[0] = (int*)(ElemType*)malloc(sizeof(int)*20);

   L->length = 0;
}

我尝试将L->data[0]更改为其他人，但却变成了错误。

Answer 1

已分配def perform_action(request, data): """ Do something `request` is included for completeness in case it's necessary, but the data normally read from `request.data` should be read instead from the `data` argument. """ serializer = ActionSerializer(data=data) if serializer.is_valid(): ... # Whatever your action should be, goes here @api_view(http_method_names=['POST']) @permission_classes([AllowAny]) def action(request) perform_action(request, request.data) return Response() # 200, no content @api_view(http_method_names=['POST']) @permission_classes([AllowAny]) def dispatch(request): """ Dispatch a request to a sibling endpoint. """ routing_table = { 'action': perform_action, # etc... } serializer = DispatchSerializer(data=request.data) if serializer.is_valid(raise_exception=True): to = serializer.validated_data['to'] try: view = routing_table[to] except KeyError: raise Http404() view(request, serializer.validated_data['payload']) return Response()的空格。你可能想做这样的事情：

data

然后执行内存分配：

typedef struct
{
   ElemType *data;
   int length;
}SqList;

实际上，无需将L->data = (ElemType*)malloc(sizeof(ElemType)*20);的返回值转换为malloc()。以下陈述将：

ElemType *

动态扩展内存

您可以定义由两部分组成的结构来存储数据：

L->data = malloc(sizeof(ElemType)*20);的数组。固定尺寸。无需动态内存分配。 ElemType的所有实例都可以包含最多SqList个元素，而无需动态分配内存。
指向INITIAL_SIZE的指针。它提供了增加运行时可以存储的元素数量的可能性。
```
ElemType
```

每当您需要在typedef struct { ElemType data[INITIAL_SIZE]; // always allocated ElemType *ext; // it's up to you whether allocate this or not size_t length; } SqList;上分配更多内存时，您可以使用以下函数：

SqList

Answer 2

您无需进行多级内存分配。这非常适合flexible array member：

的使用

typedef struct
{
   unsigned length;
   ElemType data[];
} SqList;

要分配，请使用以下内容：

SqList *allocateList( unsigned length )
{
    SqList *list = malloc( sizeof(*list) + length * sizeof(list->data[0]));
    if ( list )
    {
        list->length = length;
    }

    return( list );
}

重新分配到新尺寸：

SqList *reallocateList( SqList *origList, unsigned newLen )
{
    unsigned origLen = origList->length;
    SqList *newList = realloc( origList,
        sizeof(*newList) + newLen * sizeof(newList->data[0]));
    if ( newList )
    {
        newList->length = newLength;

        // initialize new elements - origLen
        // is already at the start of any 
        // new data elements
        for ( ; origLen < newLen; origLen++ )
        {
            newList->data[ origLen ] = -1;
        }
    }

    return( newList );
}

免费列表：

free( list );

<强>解释

具有灵活数组成员的结构被分配为单个可变大小的内存块。分配的内存的第一个元素是固定的，就像在普通结构中一样。最后一个“灵活”元素是一个可变大小的数组。因此，结构及其可变数量的实际数据都是一次分配的。

相反，包含指向可变大小数组的指针的结构必须分两步分配 - 一个用于结构本身，另一个用于数据数组。

使用动态分配时，灵活的数组成员可以实现更简单的代码。缺点是使用具有灵活数组成员的结构，因为“正常”局部变量存在问题。例如，给定

typedef struct
{
   unsigned length;
   ElemType data[];
} SqList;

此代码存在问题：

void someFunc( void )
{
    SqList list;
       .
       .
       .
}

数据元素在哪里？它实际上并不存在，并且在给定示例代码的情况下，没有办法为这样的结构分配数据元素。您可以将alloca()用于包括数据元素在内的整个结构，但如果代码处于循环中，则会导致问题。

警告：赋值在没有强制转换的情况下从指针生成

2 个答案:

动态扩展内存