个人帐簿管理系统(c)

904阅读　0评论2011-07-28　高傲的活着
分类：C/C++

  1. #include "stdio.h"
  2. #include "stdlib.h"
  3. #include "string.h"
  4. #include "conio.h" //包含这个getch()方法
  5. #define M 50
  6. typedef struct
  7. {
  8.    char name[20]; /*姓名*/
  9.    char ***[10]; /*性别*/
  10.    char birth[15]; /*出生年月*/
  11.    char units[30]; /*工作单位*/
  12.    char studylevel[20]; /*学历*/
  13.    char officenumber[15]; /*办公电话*/
  14.    char homenumber[15]; /*住宅电话*/
  15.    char homeaddress[30]; /*家庭住址*/
  16. }ADDRESS;

  18. /*显示指定的一条记录*/
  19. void mprint(ADDRESS temp)
  20. {
  21.    printf("\n****************************************************************************\n");
  22.    printf(" 姓名 性别 出生年月 工作单位 学历 办公电话 住宅电话 家庭住址\n");
  23.    printf("----------------------------------------------------------------------------\n");
  24.    printf("%-8s%4s%13s%8s%7s%12s%12s%8s\n",temp.name,temp.***,temp.birth,temp.units,
  25.           temp.studylevel,temp.officenumber,temp.homenumber,temp.homeaddress);
  26.    printf("*********************************end****************************************\n");
  27. }

  29. /*输入记录，形参为结构体数组，函数值返回类型为整型表示记录长度*/
  30. int enter(ADDRESS t[])
  31. {
  32.    int i,n;
  33.    system("cls");
  34.    printf("********************************************************************************\n");
  35.    printf("请确定您要输入的记录数\n"); /*提示信息*/
  36.    scanf("%d",&n); /*输入记录数*/
  37.    if(n>0)
  38.    {
  39.         printf("请输入您的通讯录记录\n\n"); /*提示输入记录*/
  40.        printf(" 姓名 性别 出生年月 工作单位 学历 办公电话 住宅电话 家庭住址\n");
  41.        printf("--------------------------------------------------------------------------\n");
  42.        for(i=0;i<n;i++)
  43.         {
  44.         scanf("%s%s%s%s%s%s%s%s",t[i].name,t[i].***,t[i].birth,t[i].units,
  45.           t[i].studylevel,t[i].officenumber,t[i].homenumber,t[i].homeaddress); /*输入记录*/
  46.         printf("-------------------------------------------------------------------------\n");
  47.         }
  48.        printf("信息录入成功!");
  49.        return n; /*返回记录条数*/
  50.    }
  51.    if(n<=0) printf("对不起，您输入的记录数不正确\n");exit(0);
  52. }

  54. /*显示记录，参数为记录数组和记录条数*/
  55. void list(ADDRESS t[],int n)
  56. {
  57.     int i;
  58.    system("cls");
  59.    printf("\n*********************************通讯录***********************************\n");
  60.    printf(" 总共有%d 条记录 \n",n);
  61.    printf(" 姓名 性别 出生年月 工作单位 学历 办公电话 住宅电话 家庭住址\n");
  62.    printf("--------------------------------------------------------------------------\n");
  63.    for(i=0;i<n;i++)
  64.    {
  65.          printf("%-8s%4s%13s%8s%7s%12s%12s%8s\n",t[i].name,t[i].***,t[i].birth,t[i].units,
  66.           t[i].studylevel,t[i].officenumber,t[i].homenumber,t[i].homeaddress);
  67.          if((i+1)%10==0)
  68.          {
  69.               printf("请输入任意键继续....\n");
  70.               getchar();
  71.          }
  72.    }
  73.    printf("**********************************结束************************************\n");
  74. }

  76. /*按姓名查找函数，参数为记录数组和记录条数以及姓名s */
  77. int namefind(ADDRESS t[],int n,char *s)
  78. {
  79.    int i;
  80.    for(i=0;i<n;i++)/*从第一条记录开始，直到最后一条*/
  81.    {
  82.       if(strcmp(s,t[i].name)==0) /*记录中的姓名和待比较的姓名是否相等*/
  83.        return i; /*相等，则返回该记录的下标号，程序提前结结束*/
  84.    }
  85.    return i; /*返回i值*/
  86. }

  88. /*按办公电话查找函数，参数为记录数组和记录条数以及办公电话s */
  89. int officenumberfind(ADDRESS t[],int n,char *s)
  90. {
  91.    int i;
  92.    for(i=0;i<n;i++)/*从第一条记录开始，直到最后一条*/
  93.    {
  94.       if(strcmp(s,t[i].officenumber)==0) /*记录中的办公电话和待比较的办公电话是否相等*/
  95.        return i; /*相等，则返回该记录的下标号，程序提前结结束*/
  96.    }
  97.    return i; /*返回i值*/
  98. }
  99. /*按住宅电话查找函数，参数为记录数组和记录条数以及住宅电话s */
  100. int homenumberfind(ADDRESS t[],int n,char *s)
  101. {
  102.    int i;
  103.    for(i=0;i<n;i++)/*从第一条记录开始，直到最后一条*/
  104.    {
  105.       if(strcmp(s,t[i].homenumber)==0) /*记录中的住宅电话和待比较的住宅电话是否相等*/
  106.        return i; /*相等，则返回该记录的下标号，程序提前结结束*/
  107.    }
  108.    return i; /*返回i值*/
  109. }

  111. /*删除记录函数，参数为记录数组和记录条数*/
  112. int delet(ADDRESS t[],int n)
  113. {
  114.    char s[20]; /*要删除记录的姓名*/
  115.    int ch=0;
  116.    int i,j;
  117.    printf("请输入您要删除的记录的姓名\n"); /*提示信息*/
  118.    scanf("%s",s);/*输入姓名*/
  119.    i=namefind(t,n,s); /*调用namefind函数*/
  120.    if(i>n-1) /*如果i>n-1超过了数组的长度*/
  121.       printf("对不起，没有找到要删除的记录！\n"); /*显示没找到要删除的记录*/
  122.    else
  123.    {
  124.       mprint(t[i]); /*调用输出函数显示该条记录信息*/
  125.       printf("您确认要删除该条记录么？(1.是/0.否)\n"); /*确认是否要删除*/
  126.       scanf("%d",&ch); /*输入一个整数或*/
  127.       if(ch==1) /*如果确认删除整数*/
  128.       {
  129.       for(j=i+1;j<n;j++) /*删除该记录，实际后续记录前移*/
  130.       {
  131.          strcpy(t[j-1].name,t[j].name); /*将后一条记录的姓名拷贝到前一条*/
  132.          strcpy(t[j-1].***,t[j].***); /*将后一条记录的性别拷贝到前一条*/
  133.          strcpy(t[j-1].birth,t[j].birth); /*将后一条记录的生日拷贝到前一条*/
  134.          strcpy(t[j-1].units,t[j].units); /*将后一条记录的工作单位拷贝到前一条*/
  135.          strcpy(t[j-1].studylevel,t[j].studylevel); /*将后一条记录的学历拷贝到前一条*/
  136.          strcpy(t[j-1].officenumber,t[j].officenumber); /*将后一条记录的办公电话拷贝到前一条*/
  137.          strcpy(t[j-1].homenumber,t[j].homenumber); /*将后一条记录的住宅电话拷贝到前一条*/
  138.          strcpy(t[j-1].homeaddress,t[j].homeaddress); /*将后一条记录的家庭地址拷贝到前一条*/
  139.       }
  140.       n--; /*记录数减*/
  141.       printf("记录删除成功!\n");
  142.       }
  143.    }
  144.    return n; /*返回记录数*/
  145. }

  147. /*修改记录函数，参数为记录数组和记录条数*/
  148. void rewrite(ADDRESS t[],int n)
  149. {
  150.    char s[20]; /*要修改记录的姓名*/
  151.    int ch=0;
  152.    int i;
  153.    printf("请输入您要修改的通讯录的姓名:\n"); /*提示信息*/
  154.    scanf("%s",s);/*输入姓名*/
  155.    i=namefind(t,n,s); /*调用namefind函数*/
  156.    if(i>n-1) /*如果i>n-1超过了数组的长度*/
  157.       printf("对不起，没有找到要修改的记录！\n"); /*显示没找到要修改的记录*/
  158.    else
  159.    {
  160.       mprint(t[i]); /*调用输出函数显示该条记录信息*/
  161.       printf("您确定要修改这条记录么？(1.是/0.否)\n"); /*确认是否要修改*/
  162.       scanf("%d",&ch); /*输入一个整数或*/
  163.       if(ch==1) /*如果确认修改整数为*/
  164.        {
  165.            printf("请输入新的记录\n");
  166.           printf("***************************************************************************\n");
  167.           printf(" 姓名 性别 出生年月 工作单位 学历 办公电话 住宅电话 家庭住址\n");
  168.           printf("---------------------------------------------------------------------------\n");
  169.           scanf("%s%s%s%s%s%s%s%s",t[i].name,t[i].***,t[i].birth,t[i].units,
  170.                 t[i].studylevel,t[i].officenumber,t[i].homenumber,t[i].homeaddress); /*输入修改信息*/
  171.           printf("---------------------------------------------------------------------------\n");
  172.            printf("记录修改成功!\n");
  173.        }
  174.    }
  175. }

  177. /*插入记录函数，参数为结构体数组和记录数*/
  178. int add(ADDRESS t[],int n) /*插入函数，参数为结构体数组和记录数*/
  179. {
  180.    ADDRESS temp; /*新插入记录信息*/
  181.    int i,j;
  182.    char s[20]; /*确定插入在哪个记录之前*/
  183.    printf("请输入您要插入的记录\n");
  184.    printf("***************************************************************************\n");
  185.    printf(" 姓名 性别 出生年月 工作单位 学历 办公电话 住宅电话 家庭住址\n");
  186.    printf("---------------------------------------------------------------------------\n");
  187.    scanf("%s%s%s%s%s%s%s%s",temp.name,temp.***,temp.birth,temp.units,
  188.           temp.studylevel,temp.officenumber,temp.homenumber,temp.homeaddress); /*输入插入信息*/
  189.    printf("---------------------------------------------------------------------------\n");
  190.    printf("请输入您要插入位置的姓名\n");
  191.    scanf("%s",s); /*输入插入位置的姓名*/
  192.    i=namefind(t,n,s); /*调用namefind，确定插入位置*/
  193.   
  194.    for(j=n-1;j>=i;j--) /*从最后一个结点开始向后移动一条*/
  195.    {
  196.       strcpy(t[j+1].name,t[j].name); /*当前记录的姓名拷贝到后一条*/
  197.       strcpy(t[j+1].***,t[j].***); /*当前记录的性别拷贝到后一条*/
  198.       strcpy(t[j+1].birth,t[j].birth); /*当前记录的出生年月拷贝到后一条*/
  199.       strcpy(t[j+1].units,t[j].units); /*当前记录的单位拷贝到后一条*/
  200.       strcpy(t[j+1].studylevel,t[j].studylevel); /*当前记录的出生年月拷贝到后一条*/
  201.       strcpy(t[j+1].officenumber,t[j].officenumber); /*当前记录的办公电话拷贝到后一条*/
  202.       strcpy(t[j+1].homenumber,t[j].homenumber); /*当前记录的住宅电话拷贝到后一条*/
  203.       strcpy(t[j+1].homeaddress,t[j].homeaddress); /*当前记录的家庭地址拷贝到后一条*/
  204.    }
  205.       strcpy(t[j].name,temp.name); /*将新插入记录的姓名拷贝到第i个位置*/
  206.       strcpy(t[j].***,temp.***); /*将新插入记录的性别拷贝到第i个位置*/
  207.       strcpy(t[j].birth,temp.birth);/*将新插入记录的出生年月拷贝到第i个位置*/
  208.       strcpy(t[j].units,temp.units); /*将新插入记录的单位拷贝到第i个位置*/
  209.       strcpy(t[j].studylevel,temp.studylevel);/*将新插入记录的学历拷贝到第i个位置*/
  210.       strcpy(t[j].officenumber,temp.officenumber);/*将新插入记录的办公电话拷贝到第i个位置*/
  211.       strcpy(t[j].homenumber,temp.homenumber);/*将新插入记录的住宅电话拷贝到第i个位置*/
  212.       strcpy(t->homeaddress,temp.homeaddress);/*将新插入记录的家庭地址拷贝到第i个位置*/
  213.       n++; /*记录数加*/
  214.       printf("记录插入成功!\n");
  215.        return n; /*返回记录数*/
  216. }

  218. /*保存函数，参数为结构体数组和记录数*/
  219. void save(ADDRESS t[],int n)
  220. {
  221.    int i;
  222.    FILE *fp; /*指向文件的指针*/
  223.    if((fp=fopen("record.txt","wb"))==NULL) /*打开文件，并判断打开是否正常*/
  224.    {
  225.       printf("文件不能打开！\n");/*没打开*/
  226.       exit(1); /*退出*/
  227.    }
  228.    fprintf(fp,"%d",n); /*将记录数写入文件*/
  229.    fprintf(fp,"\r\n"); /*将换行符号写入文件*/
  230.    for(i=0;i<n;i++)
  231.    {
  232.       fprintf(fp,"%-8s%4s%13s%8s%7s%12s%12s%8s",t[i].name,t[i].***,t[i].birth,t[i].units,
  233.           t[i].studylevel,t[i].officenumber,t[i].homenumber,t[i].homeaddress);/*格式写入记录*/
  234.       fprintf(fp,"\r\n"); /*将换行符号写入文件*/
  235.    }
  236.    fclose(fp);/*关闭文件*/
  237. }

  239. /*读入函数，参数为结构体数组*/
  240. int load(ADDRESS t[])
  241. {
  242.    int i,n;
  243.    FILE *fp; /*指向文件的指针*/
  244.    if((fp=fopen("record.txt","rb"))==NULL)/*打开文件*/
  245.    {
  246.       printf("对不起，不能打开文件！\n"); /*不能打开*/
  247.       exit(1); /*退出*/
  248.    }
  249.    fscanf(fp,"%d",&n); /*读入记录数*/
  250.    for(i=0;i<n;i++)
  251.       fscanf(fp,"%s%s%s%s%s%s%s%s",t[i].name,t[i].***,t[i].birth,t[i].units,
  252.           t[i].studylevel,t[i].officenumber,t[i].homenumber,t[i].homeaddress); /*按格式读入记录*/
  253.    fclose(fp); /*关闭文件*/
  254.    return n; /*返回记录数*/
  255. }

  257. /*按序号显示记录函数*/
  258. void display(ADDRESS t[])
  259. {
  260.    int id,n=0;
  261.    FILE *fp; /*指向文件的指针*/
  262.    if((fp=fopen("record.txt","rb"))==NULL) /*打开文件*/
  263.    {
  264.       printf("对不起，不能打开文件！\n"); /*不能打开文件*/
  265.       exit(1); /*退出*/
  266.    }
  267.    printf("请输入您要查找的序号...\n"); /*显示信息*/
  268.    scanf("%d",&id); /*输入序号*/
  269.    fscanf(fp,"%d",&n); /*从文件读入记录数*/
  270.    if((id>=0)&&(id<n)) /*判断序号是否在记录范围内*/
  271.    {
  272.       fseek(fp,(id-1)*sizeof(ADDRESS),1); /*移动文件指针到该记录位置*/
  273.       mprint(t[id]); /*调用输出函数显示该记录*/
  274.       printf("\r\n");
  275.    }
  276.    else
  277.       printf("对不起，你要查询的序号不存在!\n通讯录内共有%d 条记录!\n ",id); /*如果序号不合理显示信息*/
  278.    fclose(fp); /*关闭文件*/
  279. }

  281. /*按姓名排序函数，参数为结构体数组和记录数*/
  282. void namesort(ADDRESS t[],int n)
  283. {
  284.    int i,j,flag;
  285.    ADDRESS temp; /*临时变量做交换数据用*/
  286.    for(i=0;i<n;i++)
  287.    {
  288.       flag=0; /*设标志判断是否发生过交换*/
  289.       for(j=0;j<n-1;j++)
  290.       if((strcmp(t[j].name,t[j+1].name))>0) /*比较大小*/
  291.       {
  292.       flag=1;
  293.       strcpy(temp.name,t[j].name); /*交换记录*/
  294.       strcpy(temp.***,t[j].***);
  295.       strcpy(temp.birth,t[j].birth);
  296.       strcpy(temp.units,t[j].units);
  297.       strcpy(temp.studylevel,t[j].studylevel);
  298.       strcpy(temp.officenumber,t[j].officenumber);
  299.       strcpy(temp.homenumber,t[j].homenumber);
  300.       strcpy(temp.homeaddress,t[j].homeaddress);
  301.       strcpy(t[j].name,t[j+1].name);
  302.       strcpy(t[j].***,t[j+1].***);
  303.       strcpy(t[j].birth,t[j+1].birth);
  304.       strcpy(t[j].units,t[j+1].units);
  305.       strcpy(t[j].studylevel,t[j+1].studylevel);
  306.       strcpy(t[j].officenumber,t[j+1].officenumber);
  307.       strcpy(t[j].homenumber,t[j+1].homenumber);
  308.       strcpy(t[j].homeaddress,t[j+1].homeaddress);
  309.       strcpy(t[j+1].name,temp.name);
  310.       strcpy(t[j+1].***,temp.***);
  311.       strcpy(t[j+1].birth,temp.birth);
  312.       strcpy(t[j+1].units,temp.units);
  313.       strcpy(t[j+1].studylevel,temp.studylevel);
  314.       strcpy(t[j+1].officenumber,temp.officenumber);
  315.       strcpy(t[j+1].homenumber,temp.homenumber);
  316.       strcpy(t[j+1].homeaddress,temp.homeaddress);
  317.       }
  318.       if(flag==0)break; /*如果标志为，说明没有发生过交换循环结束*/
  319.    }
  320.    printf("按姓名排序成功!\n"); /*显示排序成功*/
  321. }

  323. /*按工作单位排序函数，参数为结构体数组和记录数*/
  324. void unitssort(ADDRESS t[],int n)
  325. {
  326.    int i,j,flag;
  327.    ADDRESS temp; /*临时变量做交换数据用*/
  328.    for(i=0;i<n;i++)
  329.    {
  330.       flag=0; /*设标志判断是否发生过交换*/
  331.       for(j=0;j<n-1;j++)
  332.       if((strcmp(t[j].units,t[j+1].units))>0) /*比较大小*/
  333.       {
  334.       flag=1;
  335.       strcpy(temp.name,t[j].name); /*交换记录*/
  336.       strcpy(temp.***,t[j].***);
  337.       strcpy(temp.birth,t[j].birth);
  338.       strcpy(temp.units,t[j].units);
  339.       strcpy(temp.studylevel,t[j].studylevel);
  340.       strcpy(temp.officenumber,t[j].officenumber);
  341.       strcpy(temp.homenumber,t[j].homenumber);
  342.       strcpy(temp.homeaddress,t[j].homeaddress);
  343.       strcpy(t[j].name,t[j+1].name);
  344.       strcpy(t[j].***,t[j+1].***);
  345.       strcpy(t[j].birth,t[j+1].birth);
  346.       strcpy(t[j].units,t[j+1].units);
  347.       strcpy(t[j].studylevel,t[j+1].studylevel);
  348.       strcpy(t[j].officenumber,t[j+1].officenumber);
  349.       strcpy(t[j].homenumber,t[j+1].homenumber);
  350.       strcpy(t[j].homeaddress,t[j+1].homeaddress);
  351.       strcpy(t[j+1].name,temp.name);
  352.       strcpy(t[j+1].***,temp.***);
  353.       strcpy(t[j+1].birth,temp.birth);
  354.       strcpy(t[j+1].units,temp.units);
  355.       strcpy(t[j+1].studylevel,temp.studylevel);
  356.       strcpy(t[j+1].officenumber,temp.officenumber);
  357.       strcpy(t[j+1].homenumber,temp.homenumber);
  358.       strcpy(t[j+1].homeaddress,temp.homeaddress);
  359.       }
  360.       if(flag==0)break; /*如果标志为，说明没有发生过交换循环结束*/
  361.    }
  362.    printf("按工作单位排序成功！\n"); /*显示排序成功*/
  363. }

  365. /*复制文件*/
  366. void copy()
  367. {
  368.    char outfile[20]; /*目标文件名*/
  369.    int i,n;
  370.    ADDRESS t[1024]; /*定义临时变量*/
  371.    FILE *sfp,*tfp; /*定义指向文件的指针*/
  372.    if((sfp=fopen("record.txt","rb"))==NULL) /*打开记录文件*/
  373.    {
  374.       printf("对不起，不能打开您所需要的文件！\n"); /*显示不能打开文件信息*/
  375.       exit(1); /*退出*/
  376.    }
  377.    printf("请输入目标文件名，例如：c:\\f1\\te.txt:\n"); /*提示信息*/
  378.    scanf("%s",outfile); /*输入目标文件名*/
  379.    if((tfp=fopen(outfile,"wb"))==NULL) /*打开目标文件*/
  380.    {
  381.       printf("对不起，不能打开您所需要的文件!\n"); /*显示不能打开文件信息*/
  382.       exit(1); /*退出*/
  383.    }
  384.    fscanf(sfp,"%d",&n); /*读出文件记录数*/
  385.    fprintf(tfp,"%d",n);/*写入目标文件数*/
  386.    fprintf(tfp,"\r\n"); /*写入换行符*/
  387.    for(i=0;i<n;i++)
  388.    {
  389.       fscanf(sfp,"%s%s%s%s%s%s%s%s",t[i].name,t[i].***,t[i].birth,t[i].units,
  390.          t[i].studylevel,t[i].officenumber,t[i].homenumber,t[i].homeaddress); /*读入记录*/
  391.       fprintf(tfp,"%-8s%4s%13s%8s%7s%12s%12s%8s",t[i].name,t[i].***,t[i].birth,t[i].units,
  392.           t[i].studylevel,t[i].officenumber,t[i].homenumber,t[i].homeaddress); /*写入记录*/
  393.       fprintf(tfp,"\r\n"); /*写入换行符*/
  394.    }
  395.    fclose(sfp); /*关闭源文件*/
  396.    fclose(tfp); /*关闭目标文件*/
  397. }

  399. /*按姓名查找记录*/
  400. void namesearch(ADDRESS t[],int n)
  401. {
  402.   char s[20]; /*保存待查找姓名字符串*/
  403.   int i; /*保存查找到结点的序号*/
  404.   printf("请输入您要查找的姓名\n");
  405.   scanf("%s",s); /*输入待查找姓名*/
  406.   for(i=0;i<n;i++)
  407.   {
  408.        if(strcmp(s,t[i].name)==0)
  409.        {
  410.        if(i==n)
  411.          printf("对不起，没有找到您所需要的记录！\n");
  412.       else
  413.            mprint(t[i]); /*找到，调用显示函数显示记录*/
  414.        }
  415.   }
  416. }

  418. /*按工作单位查找记录*/
  419. void unitssearch(ADDRESS t[],int n)
  420. {
  421.   char s[30]; /*保存待查找工作单位字符串*/
  422.   int i; /*保存查找到结点的序号*/
  423.   printf("请输入您要查找的工作单位\n");
  424.   scanf("%s",s); /*输入待查找工作单位*/
  425.   for(i=0;i<n;i++)
  426.   {
  427.        if(strcmp(s,t[i].units)==0)
  428.        {
  429.        if(i==n)
  430.          printf("对不起，没有找到您所需要的记录！\n");
  431.       else
  432.            mprint(t[i]); /*找到，调用显示函数显示记录*/
  433.        }
  434.   }
  435. }

  437. /*按办公电话电话查找记录*/
  438. void officenumbersearch(ADDRESS t[],int n)
  439. {
  440.   char s[15]; /*保存待查找办公电话字符串*/
  441.   int i; /*保存查找到结点的序号*/
  442.   printf("请输入您要查找的办公电话\n");
  443.   scanf("%s",s); /*输入待查找办公电话*/
  444.   i=officenumberfind(t,n,s);/* 调用officenumberfind函数，得到一个整数*/
  445.   if(i==n)
  446.       printf("对不起，没有找到您需要的记录！\n");
  447.   else
  448.       mprint(t[i]); /*找到，调用显示函数显示记录*/
  449. }

  451. /*按住宅电话电话查找记录*/
  452. void homenumbersearch(ADDRESS t[],int n)
  453. {
  454.   char s[15]; /*保存待查找住宅电话字符串*/
  455.   int i; /*保存查找到结点的序号*/
  456.   printf("请输入您要查找的住宅电话\n");
  457.   scanf("%s",s); /*输入待查找住宅电话*/
  458.   i=homenumberfind(t,n,s);/* 调用homenumberfind函数，得到一个整数*/
  459. if(i==n)
  460.       printf("对不起，没有找到您需要的记录！\n");
  461. else
  462.       mprint(t[i]); /*找到，调用显示函数显示记录*/
  463. }

  465. /*通讯录信息浏览及排序功能*/
  466. void showpaixu(ADDRESS adr[],int length)
  467. {
  468.     int choice;
  469. menu1:
  470.    system("cls");
  471.    printf("\n\n\n\n *************************通讯录信息管理系统*************************\n\n");
  472.    printf(" 1. 全部显示通讯录信息\n\n");
  473.    printf(" 2. 按序号显示通讯录信息\n\n");
  474.    printf(" 3. 按姓名排序\n\n");
  475.    printf(" 4. 按工作单位排序\n\n");
  476.    printf(" 0. 返回上一级菜单\n\n");
  477.    printf(" ********************************************************************\n");
  478.    printf(" 请选择(0~4)\n ");
  479.    scanf("%d",&choice);
  480.    switch(choice)
  481.    {
  482.      case 1: length=load(adr);
  483.              list(adr,length);
  484.               printf(" 请按任意键返回...\n");
  485.             getch();
  486.             break; /*显示全部记录*/
  487.      case 2: length=load(adr);
  488.              display(adr);
  489.               printf(" 请按任意键返回...\n");
  490.             getch();break; /*按序号显示记录*/
  491.      case 3: length=load(adr);
  492.              namesort(adr,length);
  493.               save(adr,length);
  494.               printf(" 请按任意键返回...\n");
  495.             getch();
  496.               break; /*按姓名排序*/
  497.      case 4: length=load(adr);
  498.              unitssort(adr,length);
  499.              save(adr,length);
  500.               printf(" 请按任意键返回...\n");
  501.             getch();
  502.              break; /*按工作单位排序*/
  503.      case 0: return;
  504.    }
  505.    goto menu1;
  506. }

  508. /*通讯录信息查找功能*/
  509. void chazhao(ADDRESS adr[],int length)
  510. {
  511.     int choice;
  512. menu2:
  513.    system("cls");
  514.    printf("\n\n\n\n *************************通讯录信息管理系统*************************\n\n");
  515.    printf(" 1. 通过姓名查找\n\n");
  516.    printf(" 2. 通过工作单位查找\n\n");
  517.    printf(" 3. 通过办公电话查找\n\n");
  518.    printf(" 4. 通过家庭电话查找\n\n");
  519.    printf(" 0. 返回上一级菜单\n\n");
  520.    printf(" ********************************************************************\n");
  521.    printf(" 请选择(0~4)\n ");
  522.    scanf("%d",&choice);
  523.    switch(choice)
  524.    {
  525.      case 1: length=load(adr);
  526.              namesearch(adr,length);
  527.               printf(" 请按任意键返回...\n");
  528.             getch();
  529.               break; /*按姓名查找记录*/
  530.      case 2: length=load(adr);
  531.               unitssearch(adr,length);
  532.               printf(" 请按任意键返回...\n");
  533.             getch();
  534.              break; /*按工作单位查找记录*/
  535.      case 3: length=load(adr);
  536.              officenumbersearch(adr,length);
  537.               printf(" 请按任意键返回...\n");
  538.             getch();
  539.               break; /*按办公电话查找记录*/
  540.      case 4: length=load(adr);
  541.              homenumbersearch(adr,length);
  542.               printf(" 请按任意键返回...\n");
  543.             getch();
  544.               break; /*按住宅电话查找记录*/
  545.      case 0: return;
  546.    }
  547.    goto menu2;
  548. }

  550. /*通讯录信息变更功能*/
  551. void biangeng(ADDRESS adr[],int length)
  552. {
  553.      int choice;
  554. menu3:
  555.    system("cls");
  556.    printf("\n\n\n\n *************************通讯录信息管理系统*************************\n\n");
  557.    printf(" 1. 删除记录\n\n");
  558.    printf(" 2. 修改记录\n\n");
  559.    printf(" 3. 添加记录\n\n");
  560.    printf(" 0. 返回上一级菜单\n\n");
  561.    printf(" ********************************************************************\n");
  562.    printf(" 请选择(0~3)\n ");
  563.    scanf("%d",&choice);
  564.    switch(choice)
  565.    {
  566.      case 1: length=load(adr);
  567.              length=delet(adr,length);
  568.               save(adr,length);
  569.               printf(" 请按任意键返回...\n");
  570.             getch();
  571.               break; /*删除记录*/
  572.      case 2: length=load(adr);
  573.              rewrite(adr,length);
  574.               save(adr,length);
  575.               printf(" 请按任意键返回...\n");
  576.             getch();
  577.               break; /*修改记录*/
  578.      case 3: length=load(adr);
  579.              length=add(adr,length);
  580.               save(adr,length);
  581.               printf(" 请按任意键返回...\n");
  582.             getch();
  583.               break; /*插入记录*/
  584.      case 0: return;
  585.    }
  586.    goto menu3;
  587. }

  589. /*通讯录及文件操作功能*/
  590. void wenjian(ADDRESS adr[],int length)
  591. {
  592.      int choice;
  593. menu4:
  594.    system("cls");
  595.    printf("\n\n\n\n *************************通讯录信息管理系统*************************\n\n");
  596.    printf(" 1. 导入文件到通讯录\n\n");
  597.    printf(" 2. 把当前文件复制到新文件上\n\n");
  598.    printf(" 0. 返回上一级菜单\n\n");
  599.    printf(" ********************************************************************\n");
  600.    printf(" 请选择(0~2)\n ");
  601.    scanf("%d",&choice);
  602.    switch(choice)
  603.    {
  604.      case 1: length=load(adr);
  605.              printf("您已经成功的导入文件到通讯录!\n");
  606.             printf(" 请按任意键返回...\n");
  607.             getch();break;
  608.      case 2: copy();
  609.              printf("复制成功！\n");
  610.             printf(" 请按任意键返回...\n");
  611.             getch();break;
  612.      case 0: return;
  613.    }
  614.    goto menu4;
  615. }

  617. /*关于*/
  618. void about()
  619. {
  620.      system("color 87");
  621.      system("cls");
  622.      printf("\n\n\n\n 《通讯录信息管理系统》\n\n\n");
  623.      printf(" *****************************************\n\n\n");
  624.      printf(" 版权所有(C) 2008-2009 DIY软件\n\n\n");
  625.      printf(" 制作人：朱学健、张玮、薛昌萍\n\n\n");
  626.      printf(" *****************************************\n\n\n");
  627.      printf(" 请按任意键返回主菜单...");
  628.      getch();
  629. }

  631. /******主函数开始*******/
  632. void main()
  633. {
  634.     int choice;
  635.     int length; /*保存记录长度*/
  636.     ADDRESS adr[1024]; /*定义结构体数组*/
  637. menu:
  638.      system("color f9");
  639.      system("cls");
  640.       printf("\n\n\n\n *************************通讯录信息管理系统*************************\n\n");
  641.       printf(" 请选择以下通讯录管理功能:\n\n");
  642.       printf(" 1. 通讯录信息输入\n\n");
  643.       printf(" 2. 通讯录信息浏览及排序\n\n");
  644.       printf(" 3. 通讯录信息查询\n\n");
  645.       printf(" 4. 通讯录信息更改\n\n");
  646.       printf(" 5. 通讯录及文件操作\n\n");
  647.       printf(" 6. 关于通讯录信息管理系统\n\n");
  648.       printf(" 0. 退出通讯录管理系统\n\n");
  649.       printf(" ********************************************************************\n");
  650.       printf(" 请选择(0~6)\n ");
  651.       scanf("%d",&choice);
  652.       switch(choice)
  653.       {
  654.         case 1: length=enter(adr);
  655.                 save(adr,length);
  656.                 printf("\n 请按任意键返回...\n");
  657.                getch();break;/*输入记录*/
  658.         case 2: showpaixu(adr,length);break;
  659.         case 3: chazhao(adr,length);break;
  660.         case 4: biangeng(adr,length);break;
  661.         case 5: wenjian(adr,length);break;
  662.         case 6: about();break;/*关于*/
  663.         case 0: return;exit(0); /*如返回值为则程序结束*/
  664.       }
  665.       goto menu;
  666. }
上一篇：通讯录管理系统(C)
下一篇：歌唱比赛评分问题