C 将另一条记录添加到动态内存数据库时出错

我的任务是用一些数据初始化头中的结构。然后使用指针，通过对较大/较小的数据块进行malloc处理并复制数据来添加/删除数据

目前，我的addRecord功能不起作用，因为它似乎总是添加相同的垃圾（记录编号1的一部分）：

姓名=

火灾编号=阿坦（似乎是曼哈顿的一部分）

街道=ork（似乎是纽约的一部分）

City=cret（似乎是秘密的一部分）

州=棕褐色（似乎是曼哈顿的一部分）

我做错了什么

我的标题：

#include <stdio.h>
#include <stdlib.h>

struct structPointer{
    char name[51];
    char fireNumber[11];
    char street[26];
    char city[26];
    char state[26];
};

#包括
#包括
结构指针{
字符名[51]；
煤焦火号[11]；
查街[26];；
查尔城[26]；
半焦态[26]；
};

我的c文件：

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include "myData.h"

struct structInit *sP;
struct structInit *sSP;
int recordNumber = 0;
int numberOfAccesses = 0;

int main(void) {
    sP = (struct structInit *) malloc(5 * sizeof(struct structInit));
    sSP = sP;

    memcpy(sP->name,"Adam Baum",51);
    memcpy(sP->fireNumber,"N1234",11);
    memcpy(sP->street,"Top Secret",26);
    memcpy(sP->city,"Manhattan",26);
    memcpy(sP->state,"New York",26);
    sP++;
    recordNumber++;
    memcpy(sP->name,"Adam Zapel",51);
    memcpy(sP->fireNumber,"S4321",11);
    memcpy(sP->street,"Throat",26);
    memcpy(sP->city,"Manhattan",26);
    memcpy(sP->state,"New York",26);
    sP++;
    recordNumber++;
    memcpy(sP->name,"Al Bino",51);
    memcpy(sP->fireNumber,"W1234",11);
    memcpy(sP->street,"White",26);
    memcpy(sP->city,"Anchorage",26);
    memcpy(sP->state,"Alaska",26);
    sP++;
    recordNumber++;
    memcpy(sP->name,"Anne Teak",51);
    memcpy(sP->fireNumber,"E4321",11);
    memcpy(sP->street,"Oak",26);
    memcpy(sP->city,"Woodville",26);
    memcpy(sP->state,"Wisconsin",26);
    sP++;
    recordNumber++;
    memcpy(sP->name,"Barb Dwyer",51);
    memcpy(sP->fireNumber,"N1234",11);
    memcpy(sP->street,"Keepout",26);
    memcpy(sP->city,"Kilgore",26);
    memcpy(sP->state,"Texas",26);
    recordNumber++;
    sP = sSP;

    int sel;
    while (1){
    printf("MENU\n");
    printf("=====\n");
    printf("1. Print All Records\n");
    printf("2. Print Number of Records\n");
    printf("3. Print Size of Database\n");
    printf("4. Add Record\n");
    printf("5. Delete Record\n");
    printf("6. Print Number of Accesses to Database\n");
    printf("7. Exit\n");
    printf("=====\n");
    printf("Enter selection: ");
    scanf("%d", &sel);
    printf("\n");
        switch(sel){
            case 1:
                numberOfAccesses++;
                printAllRecords(sP);
                break;
            case 2:
                numberOfAccesses++;
                fprintf(stderr,"There are a Total of %d records.\n\n", recordNumber);
                break;
            case 3:
                numberOfAccesses++;
                printSizeOfDatabase(sP);
                break;
            case 4:
                numberOfAccesses++;
                sP = sSP;
                addRecord(sP);
                break;
            case 5:
                numberOfAccesses++;
                deleteRecord(sP);
                break;
            case 6:
                numberOfAccesses++;
                fprintf(stderr,"The total number of Accesses is %d\n\n", numberOfAccesses);
                break;
            case 7:
                exit(0);
            default:
                printf("Error: Input was not a valid selection.\n\n");
                break;
        }
    }
return 0;
}

int printAllRecords(struct structInit *structPointer){
    int i;
    structPointer = sSP;
    printf("All Records: \n");
    for(i=1;i<=recordNumber;i++){
    printf("Record Number: %d\n", i);
    fprintf(stderr, "Name = \%s\n", structPointer-> name);
        fprintf(stderr, "Fire Number = \%s\n", structPointer-> fireNumber);
        fprintf(stderr, "Street = \%s\n", structPointer-> street);
        fprintf(stderr, "City = \%s\n", structPointer-> city);
        fprintf(stderr, "State = \%s\n\n", structPointer-> state);
        structPointer++;
    }
    return 1;
}

int printSizeOfDatabase(struct structInit *structPointer) {
    int size = 0;
    int i;
    for (i=1;i<=recordNumber;i++) {
    size += sizeof(structPointer->name);
    size += sizeof(structPointer->fireNumber); 
    size += sizeof(structPointer->street);
    size += sizeof(structPointer->city);
    size += sizeof(structPointer->state);
    structPointer++;
        }
    fprintf(stderr, "The size of the database is %d bytes.\n\n", size);
    return size;
}

int addRecord(struct structInit *structPointer){
    char entryName;
    char entryFireNumber;
    char entryStreet;
    char entryCity;
    char entryState;
    recordNumber++;
    struct structInit *theStruct;
    theStruct = (struct structInit *) malloc ((recordNumber+1) * sizeof(struct structInit));
    int i;
    for (i=1;i<recordNumber;i++){
        memcpy(theStruct->name,structPointer->name,51);
        memcpy(theStruct->fireNumber,structPointer->fireNumber,11);
        memcpy(theStruct->street,structPointer->street,26);
        memcpy(theStruct->city,structPointer->city,26);
        memcpy(theStruct->state,structPointer->state,26);
        /*if(i==recordNumber){
            theStruct++;}
        else{
            theStruct++;
            structPointer++;}*/
    theStruct++;
    structPointer++;
    }
    theStruct++;

    printf("Enter the Name of the New Record: \n");
    scanf("%s",&entryName);
    memcpy(theStruct->name,&entryName,51);
    printf("Enter the Fire Number of the New Record: \n");
    scanf("%s",&entryFireNumber);
    memcpy(theStruct->fireNumber,&entryFireNumber,11);
    printf("Enter the Street of the New Record: \n");
    scanf("%s",&entryStreet);
    memcpy(theStruct->street,&entryStreet,26);
    printf("Enter the City of the New Record: \n");
    scanf("%s",&entryCity);
    memcpy(theStruct->city,&entryCity,26);
    printf("Enter the State of the New Record: \n");
    scanf("%s",&entryState);
    memcpy(theStruct->state,&entryState,26);
    structPointer=theStruct;
    printf("Record has been added.\n\n");
    return 0;
}

int deleteRecord(struct structInit *structPointer){
    struct structInit *anotherStruct;
    anotherStruct = (struct structInit *) malloc ((recordNumber+1) * sizeof(struct structInit));
    int i;
    for(i=0;i<5;i++){
    memcpy(anotherStruct->name,structPointer->name,51);
    memcpy(anotherStruct->fireNumber,structPointer->fireNumber,11);
    memcpy(anotherStruct->street,structPointer->street,26);
    memcpy(anotherStruct->city,structPointer->city,26);
    memcpy(anotherStruct->state,structPointer->state,26);
    structPointer++;
    }
    structPointer=anotherStruct;
    recordNumber--;
    printf("Record has been deleted.\n\n");
    return 0;
}

#包括
#包括
#包括
#包括
#包括“myData.h”
struct structInit*sP；
struct structInit*sSP；
int recordNumber=0；
int numberofaccess=0；
内部主（空）{
sP=（struct structInit*）malloc（5*sizeof（struct structInit））；
sSP=sP；
memcpy（sP->name，“Adam Baum”，51岁）；
memcpy（sP->fireNumber，“N1234”，11）；
memcpy（sP->street，“绝密”，26）；
memcpy（sP->city，“曼哈顿”，26岁）；
memcpy（sP->state，“纽约”，26）；
sP++；
recordNumber++；
memcpy（sP->name，“Adam Zapel”，51岁）；
memcpy（sP->fireNumber，“S4321”，11）；
memcpy（sP->街道，“咽喉”，26）；
memcpy（sP->city，“曼哈顿”，26岁）；
memcpy（sP->state，“纽约”，26）；
sP++；
recordNumber++；
memcpy（sP->name，“Al Bino”，51）；
memcpy（sP->fireNumber，“W1234”，11）；
memcpy（sP->street，“White”，26）；
memcpy（sP->city，“Anchorage”，26）；
memcpy（sP->州，“阿拉斯加”，26）；
sP++；
recordNumber++；
memcpy（sP->名称，“安妮柚木”，51）；
memcpy（sP->fireNumber，“E4321”，11）；
memcpy（sP->street，“Oak”，26）；
memcpy（sP->city，“Woodville”，26岁）；
memcpy（sP->state，“威斯康星州”，26）；
sP++；
recordNumber++；
memcpy（sP->name，“Barb Dwyer”，51）；
memcpy（sP->fireNumber，“N1234”，11）；
memcpy（sP->街道，“禁止通行”，26）；
memcpy（sP->city，“Kilgore”，26）；
memcpy（sP->德克萨斯州，26）；
recordNumber++；
sP=sSP；
内特塞尔；
而(1){
printf（“菜单\n”）；
printf（“=======\n”）；
printf（“1.打印所有记录\n”）；
printf（“2.打印记录数\n”）；
printf（“3.数据库的打印大小\n”）；
printf（“4.添加记录\n”）；
printf（“5.删除记录\n”）；
printf（“6.打印访问数据库的次数\n”）；
printf（“7.退出\n”）；
printf（“=======\n”）；
printf（“输入选择：”）；
scanf（“%d”和&sel）；
printf（“\n”）；
开关（sel）{
案例1：
numberofaccess++；
打印所有记录（sP）；
打破
案例2：
numberofaccess++；
fprintf（stderr，“总共有%d条记录。\n\n”，recordNumber）；
打破
案例3：
numberofaccess++；
printSizeOfDatabase（sP）；
打破
案例4：
numberofaccess++；
sP=sSP；
addRecord（sP）；
打破
案例5：
numberofaccess++；
删除记录（sP）；
打破
案例6：
numberofaccess++；
fprintf（stderr，“总访问次数为%d\n\n”，numberofaccess）；
打破
案例7：
出口（0）；
违约：
printf（“错误：输入不是有效的选择。\n\n”）；
打破
}
}
返回0；
}
int printAllRecords（struct structInit*structPointer）{
int i；
structPointer=sSP；
printf（“所有记录：\n”）；
对于（i=1；i名称）；
fprintf（标准，“火灾编号=\%s\n”，结构指针->火灾编号）；
fprintf（标准，“街道=\%s\n”，结构指针->街道）；
fprintf（标准，“城市=\%s\n”，结构指针->城市）；
fprintf（stderr，“State=\%s\n\n”，structPointer->State）；
structPointer++；
}
返回1；
}
int printSizeOfDatabase（struct structInit*structPointer）{
int size=0；
int i；
for（i=1；iname）；
size+=sizeof（结构指针->火号）；
尺寸+=sizeof（structPointer->street）；
size+=sizeof（结构指针->城市）；
size+=sizeof（结构指针->状态）；
structPointer++；
}
fprintf（stderr，“数据库大小为%d字节。\n\n”，大小）；
返回大小；
}
int addRecord（struct structInit*structPointer）{
字符入口名；
字符入口火号；
Charentrystreet；
字符入口；
字符入口状态；
recordNumber++；
struct structInit*结构；
结构=（struct structInit*）malloc（（记录编号+1）*sizeof（struct structInit））；
int i；
对于（i=1；iname，structPointer->name，51）；
memcpy（结构->火号，结构指针->火号，11）；
memcpy（建筑->街道，建筑指针->街道，26）；
memcpy（结构->城市，结构指针->城市，26）；
memcpy（结构->状态，结构指针->状态，26）；
/*if（i==记录编号）{
结构+++；}
否则{
结构++；
structPointer++；}*/
结构++；
structPointer++；
}
结构++；
printf（“输入新记录的名称：\n”）；
scanf（“%s”、&entryName）；
memcpy（结构->名称和入口名称，51）；
printf（“输入新记录的火灾编号：\n”）；
scanf（“%s”、&entryFireNumber）；
memcpy（结构->消防编号和入口消防编号，11）；
printf（“输入新记录的街道：\n”）；
scanf（“%s”和入口街）；
memcpy（建筑->街和入口街，26）；
printf（“输入新记录所在城市：\n”）；
scanf（“%s”、&entryCity）；
memcpy（建筑->城市和入口城市，26）；
printf（“输入新记录的状态：\n”）；
scanf（“%s”&入口状态）；
memcpy（结构->状态和入口状态，26）；
结构指针=结构；
printf（“已添加记录。\n\n”）；
  typedef struct structPointer structInit;

char entryName[51];
/* ... */
printf("Enter the Name of the New Record: \n");
scanf("%s", entryName);

int addRecord(struct structInit **structPointer)
{
   /* ... */
   *structPointer = theStruct;
   /* ... */
}

struct structInit a = /* ... */;
struct structInit b = /* ... */;
a = b; /* OK */

int printSizeOfDatabase() {
    int size = recordNumber * sizeof(struct structInit);
    fprintf(stderr, "The size of the database is %d bytes.\n\n", size);
    return size;
}