对variable-sized object may not be initialized的一点理解

2019独角兽企业重金招聘Python工程师标准>>>

在看数据结构与算法分析-c语言描述时，队列的实现方式有指针还有数组，指针的方式很快就实现了，但是在使用数组方式的时候，还是犯错了，报错：variable-sized object may not be initialized 

具体的代码

#define MIN_QUEUE_SIZE 5  

struct QueueRecord {                                                                                                                                                                    
  int capacity;                                                                                                                                                                         
  int size;                                                                                                                                                                             
  int front;                                                                                                                                                                            
  int rear;                                                                                                                                                                             
  ElementType *array;                                                                                                                                                                   
}; 

Queue CreateQueue(int maxElements){                                                                                                                                                     
  if(maxElements < MIN_QUEUE_SIZE){                                                                                                                                                     
    fprintf(stderr, "#WARNING# The Queue size is less than %d, it will be use %d", MIN_QUEUE_SIZE, MIN_QUEUE_SIZE);                                                                     
    maxElements = MIN_QUEUE_SIZE;                                                                                                                                                       
  }                                                                                                                                                                         
                                                                                                                                                                                        
  Queue myQueue = (Queue)malloc(sizeof(struct QueueRecord));                                                                                                                            
  checkingMemory(myQueue);                                                                                                                                                              
                                                                                                                                                            
  ElementType arrary[maxElements]  = {0};                                             
  myQueue->array = array;                                                                                                                                                                                                                                                                                                                                             
  myQueue->capacity = maxElements;                                                                                                                                                      
  myQueue->size = 0;                                                                                                                                                                    
  myQueue->front = 0;                                                                                                                                                                   
  myQueue->rear = -1;                                                                                                                                                                   
                                                                                                                                                           
  return myQueue;                                                                                                                                                                       
}    

这里  ElementType arrary[maxElements]  = {0};  就是报错的原因，因为C语言规定了不能使用variable-sized的数组。

那为什么需要如此规定呢？

因为数组是连续的内存，如果在函数里动态的创建的话，那么就没有办法保证和检测到如此多的连续的内存空间。所以数组的空间是在程序启动时就已经分配好了。

请看汇编代码

array:                                                                                                                                                                                  
    .zero   400                                                                                                                                                                         
    .size   array, 400                                                                                                                                                                  
                                                                                                                                                                                        
    .type   .L.str,@object          # @.str                                                                                                                                             
    .section    .rodata.str1.1,"aMS",@progbits,1   

为什么这里大小为400，原因是int类型的长度是4byte，100个4byte，就是400了。如果长度很短的话，那么它会写成下面这样，更容易理解。

int arrary[9] = {7};


arrary:                                                                                                                                                                                 
    .long   7                       # 0x7                                                                                                                                               
    .long   0                       # 0x0                                                                                                                                               
    .long   0                       # 0x0                                                                                                                                               
    .long   0                       # 0x0                                                                                                                                               
    .long   0                       # 0x0                                                                                                                                               
    .long   0                       # 0x0                                                                                                                                               
    .long   0                       # 0x0                                                                                                                                               
    .long   0                       # 0x0                                                                                                                                               
    .long   0                       # 0x0                                                                                                                                               
    .size   arrary, 36                      

如果要动态的使用内存的话，那么指针就是不二选择。

下面是修改之后的代码

#define MIN_QUEUE_SIZE 5                                                                                                                                                                
#define MAX_QUEUE_SIZE 100 

struct QueueRecord {                                                                                                                                                                    
  int capacity;                                                                                                                                                                         
  int size;                                                                                                                                                                             
  int front;                                                                                                                                                                            
  int rear;                                                                                                                                                                             
  ElementType *array;                                                                                                                                                                   
};                                                                                                                                                                                      
                                                                                                                                                                                        
ElementType array[MAX_QUEUE_SIZE] = {0};    

Queue CreateQueue(int maxElements){                                                                                                                                                     
  if(maxElements < MIN_QUEUE_SIZE){                                                                                                                                                     
    fprintf(stderr, "#WARNING# The Queue size is less than %d, it will be use %d", MIN_QUEUE_SIZE, MIN_QUEUE_SIZE);                                                                     
    maxElements = MIN_QUEUE_SIZE;                                                                                                                                                       
  }else if(maxElements > MAX_QUEUE_SIZE){                                                                                                                                               
    fprintf(stderr, "#WARNING# The Queue size is greater than %d, it will be use %d", MAX_QUEUE_SIZE, MAX_QUEUE_SIZE);                                                                  
    maxElements = MAX_QUEUE_SIZE;                                                                                                                                                       
  }                                                                                                                                                                                     
                                                                                                                                                                                        
  Queue myQueue = (Queue)malloc(sizeof(struct QueueRecord));                                                                                                                            
  checkingMemory(myQueue);                                                                                                                                                                                                                                                         
  myQueue->array = array;                                                                                                                                                                                                                                                                                                                                          
  myQueue->capacity = maxElements;                                                                                                                                                      
  myQueue->size = 0;                                                                                                                                                                    
  myQueue->front = 0;                                                                                                                                                                   
  myQueue->rear = -1;                                                                                                                                                                   
                                                                                                                                                            
  return myQueue;                                                                                                                                                                       
} 

 

转载于:https://my.oschina.net/swuly302/blog/1836553