C 二维阵列获得不需要的附加元素

这是我的第一篇文章，但我已经使用这个网站一段时间了，非常有用

我正在编写一个内存池实现，但遇到了一个奇怪的问题。现在我有2个内存池，有一个奇怪的问题，每当我初始化这两个内存池时，第一个数组将比它应该拥有的多1个元素。对于我在第一个池之外添加的每个池，它将获得一个额外的元素。这是不应该的，我也不知道为什么

在我的代码中，第一个池有32个元素（0-31），工作正常，但是当我初始化第二个池时，它显示为有33个元素（0-32）

这是我的密码：

#include <stdio.h>
typedef struct memoryBlock {
    /* Pointer to array */
    int *Address;                                                
    struct memoryBlock *Next;
}memoryBlock;


/* Small Pool */
#define BLOCKNUM_POOL_S 32 //number of blocks
#define BLOCKSIZE_POOL_S 8 //ints per block

static memoryBlock *Pool_Head_S;
static memoryBlock *Pool_Tail_S;

 /* The memory that will be dynamically allocated will be stored in this array */
static int Pool_Block_S[BLOCKNUM_POOL_S-1][BLOCKSIZE_POOL_S+sizeof(memoryBlock)/sizeof(int)];       

/* This is a free list containing only pointers to free blocks in this pool */
static int Pool_Free_S[BLOCKNUM_POOL_S-1][sizeof(memoryBlock)/sizeof(int)]; 


/* Medium Pool */
#define BLOCKNUM_POOL_M 16 //number of blocks
#define BLOCKSIZE_POOL_M 16 //words per block

static memoryBlock *Pool_Head_M;
static memoryBlock *Pool_Tail_M;

/* The memory that will be dynamically allocated will be stored in this array */
static int Pool_Block_M[BLOCKNUM_POOL_M-1][BLOCKSIZE_POOL_M+sizeof(memoryBlock)/sizeof(int)];           

/* This is a free list containing only pointers to free blocks in this pool */
static int Pool_Free_M[BLOCKNUM_POOL_M-1][sizeof(memoryBlock)/sizeof(int)];


void printS();
void printM();
void initPool_S();
void initPool_M();

void main(){

  initPool_S();
  initPool_M();

  printS();
  printM();

}

void initPool_S(){
   int i;  
   Pool_Tail_S = NULL;
   Pool_Head_S = NULL;
   for(i=0;i<BLOCKNUM_POOL_S;i++){  
      //for each block setup the memory block and pointers
      if(Pool_Tail_S){          
          Pool_Tail_S->Next = (memoryBlock *)&Pool_Free_S[i][0];
          Pool_Tail_S->Next->Address = &Pool_Block_S[i][0];
          Pool_Tail_S = Pool_Tail_S->Next;
          Pool_Tail_S->Next = NULL;
      /* There is nothing in this list yet */
      }else{
          Pool_Head_S = (memoryBlock *)&Pool_Free_S[i][0];
          Pool_Head_S->Address = (int *)&Pool_Block_S[i][0];
          Pool_Head_S->Next = NULL;
          Pool_Tail_S = Pool_Head_S;
      }
   }
}

void initPool_M(){
   int i;
   Pool_Tail_M = NULL;
   Pool_Head_M = NULL;
   for(i=0;i<BLOCKNUM_POOL_M;i++){
        //for each block setup the memory block and pointers
        if(Pool_Tail_M){
            Pool_Tail_M->Next = (memoryBlock *)&Pool_Free_M[i][0];
            Pool_Tail_M->Next->Address = (int *)&Pool_Block_M[i][0];
            Pool_Tail_M = Pool_Tail_M->Next;
            Pool_Tail_M->Next = NULL;
        /* There is nothing in this list yet */
        }else{
            Pool_Head_M = (memoryBlock *)&Pool_Free_M[i][0];
            Pool_Head_M->Address = (int *)&Pool_Block_M[i][0];
            Pool_Head_M->Next = NULL;
            Pool_Tail_M = Pool_Head_M; 
        }      
   }
}

void printM(){
    memoryBlock *tmpPtr2;
    tmpPtr2 = Pool_Head_M;
    int j=0;
    while(tmpPtr2){
        printf(">-------------------------------------------------<\n");
        printf("%d\n",j);
        printf("Pool_Med_Free: %d\n",tmpPtr2);
        printf("Pool_Med_Free->Address: %d\n",tmpPtr2->Address);
        printf("Pool_Med_Free->Next: %d\n",tmpPtr2->Next);
        tmpPtr2 = tmpPtr2->Next;
        j++;
    }
}

void printS(){
  memoryBlock *tmpPtr1;
  tmpPtr1 = Pool_Head_S;
  int j=0;
  while(tmpPtr1){
      printf(">-------------------------------------------------<\n");
      printf("%d\n",j);
      printf("Pool_Small_Free: %d\n",tmpPtr1);
      printf("Pool_Small_Free->Address: %d\n",tmpPtr1->Address);
      printf("Pool_Small_Free->Next: %d\n",tmpPtr1->Next);
      tmpPtr1 = tmpPtr1->Next;
      j++;
  }
}

#包括
类型定义结构内存块{
/*指向数组的指针*/
int*地址；
结构memoryBlock*下一步；
}记忆块；
/*小水池*/
#定义BLOCKNUM\u POOL\u S 32//块数
#定义块大小\u池\u S每个块8//整数
静态内存块*池头；
静态内存块*Pool\u Tail\S；
/*将动态分配的内存将存储在此阵列中*/
静态int-Pool_-Block_-S[BLOCKNUM_-Pool_-S-1][BLOCKSIZE_-Pool_-S+sizeof（memoryBlock）/sizeof（int）]；
/*这是一个空闲列表，仅包含指向此池中空闲块的指针*/
静态int-Pool_-Free_-S[BLOCKNUM_-Pool_-S-1][sizeof（memoryBlock）/sizeof（int）]；
/*中池*/
#定义BLOCKNUM\u POOL\u M 16//块数
#定义块大小\u池\u M 16//每个块的字数
静态内存块*Pool\u Head\M；
静态内存块*Pool\u Tail\M；
/*将动态分配的内存将存储在此阵列中*/
静态int-Pool_-Block_-M[BLOCKNUM_-Pool_-M-1][BLOCKSIZE_-Pool_-M+sizeof（memoryBlock）/sizeof（int）]；
/*这是一个空闲列表，仅包含指向此池中空闲块的指针*/
静态int Pool_Free_M[BLOCKNUM_Pool_M-1][sizeof（memoryBlock）/sizeof（int）]；
无效打印（）；
void printM（）；
void initPool_S（）；
void initPool_M（）；
void main（）{
initPool_S（）；
initPool_M（）；
印刷品（）；
printM（）；
}
void initPool_S（）{
int i；
Pool_Tail_S=NULL；
池头=空；
对于（i=0；inxt=（memoryBlock*）和Pool_Free_S[i][0]；
池尾->下一步->地址=&池块[i][0]；
池尾=池尾->下一步；
池尾->下一步=NULL；
/*这张单子上还没有*/
}否则{
Pool_Head_S=（memoryBlock*）和Pool_Free_S[i][0]；
池头->地址=（int*）和池块[i][0]；
池头->下一步=NULL；
池尾=池头；
}
}
}
void initPool_M（）{
int i；
Pool_Tail_M=NULL；
池头=NULL；
对于（i=0；inxt=（memoryBlock*）和Pool_Free_M[i][0]；
Pool_Tail_M->Next->Address=（int*）和Pool_Block_M[i][0]；
Pool\u Tail\u M=Pool\u Tail\u M->Next；
Pool\u Tail\u M->Next=NULL；
/*这张单子上还没有*/
}否则{
Pool_Head_M=（memoryBlock*）和Pool_Free_M[i][0]；
Pool_Head_M->Address=（int*）和Pool_Block_M[i][0]；
池头->下一步=NULL；
池尾=池头；
}      
}
}
void printM（）{
内存块*tmpPtr2；
tmpPtr2=池头；
int j=0；
while（tmpPtr2）{
printf（“>------------------------------------地址：%d\n”，tmpPtr2->地址）；
printf（“Pool\u Med\u Free->Next:%d\n”，tmpPtr2->Next）；
tmpPtr2=tmpPtr2->Next；
j++；
}
}
作废印刷品（）{
memoryBlock*tmpPtr1；
tmpPtr1=池头；
int j=0；
while（tmpPtr1）{
printf（“>------------------------------------地址：%d\n”，tmpPtr1->地址）；
printf（“Pool\u Small\u Free->Next:%d\n”，tmpPtr1->Next）；
tmpPtr1=tmpPtr1->Next；
j++；
}
}

我使用的编译器也是minGW

---

我对C还是有点陌生，所以这可能是一个愚蠢的错误，但我似乎无法解决它。任何帮助都将不胜感激，谢谢！

Pool\u Block\u S[BLOCKNUM\u Pool\u S-1]只有31个元素。

数组[n]

中的n是元素数，而不是最后一个元素的索引。这就是问题的根源

---

sizeof（memoryBlock）/sizeof（int）

的含义是什么？它看起来不正确。

Pool\u Block\S[BLOCKNUM\u Pool\u S-1]

只有31个元素。

array[n]

中的n是不是最后一个元素索引的元素数。这就是问题的根源

---

sizeof（memoryBlock）/sizeof（int）

的含义是什么？它看起来不正确。

谢谢你的回答，sizeof（memoryBlock）/sizeof（int）意思是：memoryBlock的大小（以字节为单位）/1 int的大小（以字节为单位）。在我的机器上，结构是8字节，而int是4。这意味着需要8/4=2 int的内存来保存数组中的结构。还感谢您指出它解决了我的问题的元素数的问题：）谢谢您的回答，sizeof（memoryBlock）/sizeof（int）的意思是：memoryBlock的大小（以字节为单位）/1 int的大小（以字节为单位）。在我的机器上，结构是8字节，int是4。这意味着需要8/4=2 int的内存来保存数组中的结构。还感谢您指出关于元素数量的问题，它解决了我的问题：）