静态链表……为什么打印不出来啊？


#include 
#define maxSize 7
typedef struct {    //单个节点的内容
    char data;
    int cur;
}component; //组成成分

//初始化备用链表
void reverseArr(component *array){
    for(int i=1;i<=maxSize;i++){
        array[i-1].cur=i;
        array[i-1].data=-1;//-1表示没有值
    }
    array[maxSize-1].cur=0;//链表性质:最后一个节点游标为0
}

//提取分配空间并重置备用链表
int mallocArr(component*array){
    int i=array[0].cur;
    if(i){
        return i;
        array[0].cur=array[i].cur;//重置备用链表
    }
    return i;//提取分配空间
}

//初始化链表(存data)*******
int initArr(component*array){
    reverseArr(array);
    int body=mallocArr(array);//(body=1)
    int tempBody=body;//遍历节点指向原来的数据尾节点
    for(int i=1;i<5;i++){ //写入abcd
        int j=mallocArr(array);//从第三个开始填入数据
       array[tempBody].cur=j;
        array[j].data='a'+(i-1);
        tempBody=j;
    }
    array[tempBody].cur=0;//数据链表尾节点游标为0
    return body;
}

//打印链表
void displayArr(component*array,int body){
    int tempBody=body;
    while(array[tempBody].cur){
        printf("%c,%d",array[tempBody].data,array[tempBody].cur);
        tempBody=array[tempBody].cur;
    }
}

int main(){
component array[maxSize];
int body=initArr(array);
displayArr(array,body);
}

提取分配空间并重置备用链表 int mallocArr(component* array) ，这个函数是实现什么目的？
整体修改如下，供参考:

#include <stdio.h>
#define maxSize 7
typedef struct { //单个节点的内容
    char data;
    int  cur;
}component; //组成成分

//初始化备用链表
void reverseArr(component* array) {
    for (int i = 1; i <= maxSize; i++) {  
        array[i - 1].cur = i;
        array[i - 1].data = 0;//0表示没有值
    }
    array[maxSize - 1].cur = 0;//链表性质:最后一个节点游标为0
}

//打印链表
void displayArr(component* array) {
    int tempBody; 
    for (tempBody = 0; array[tempBody].cur != 0; tempBody = array[tempBody].cur)
        printf("[%c,%d]", array[tempBody].data, array[tempBody].cur);
    printf("[%c,%d]\n", array[tempBody].data, array[tempBody].cur);
}
//初始化链表(存data)*******
void initArr(component* array) {
    reverseArr(array);
    //displayArr(array);
    int tempBody = 0; 
    for (int i = 1; i < 8; i++) { //写入abcdefg
        array[tempBody].data = 'a' + (i - 1);
        tempBody = array[tempBody].cur;
        if (!tempBody)   break;   //如果写入数据长度大于链表长度，跳出
    }
    if (tempBody)  //如果写入数据长度小于链表长度
        array[tempBody - 1].cur = 0;//数据链表尾节点游标为0
}

int main() {
    component array[maxSize];
    initArr(array);
    displayArr(array);
}


//提取分配空间并重置备用链表
int mallocArr(component* array) {
    int i = array[0].cur;
    if (i) {
        return i;
        array[0].cur = array[i].cur;//重置备用链表
    }
    return i;//提取分配空间
}

帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/740844
这篇博客你也可以参考下：什么是异常？为什么要抛出异常？
除此之外, 这篇博客: 结构体的理解中的 为什么存在内存对齐？ 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
从两个方面来说：
1、平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2、性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
比如说：32位平台，一次性只能读取四个字节的数据；
```
struct S
{
char a;
int i;
};
```
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：
让占用空间小的成员尽量集中在一起。