Лаба-курсовик   Работает с динамической памятью+ файлы+указатели.Зацените (Шульс (С))
Авторемонтные мастерские:номер, марка, мощность и цвет автомобиля, ФИО и квалификация механика, тип работ
(извиняйте за коментарии-глюки с кодировкой)

#include <malloc.h>
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>

int func_print();      /* ”г­ЄжЁп ЇҐз вЁ бЇЁбЄ  */
int func_input();      /* ”г­ЄжЁп ўў®¤  бЇЁбЄ  */
int func_add();        /* „®Ў ў«Ґ­ЁҐ н«Ґ¬Ґ­в  ў бЇЁб®Є */
int func_delete();     /* “­Ёз⮦Ґ­ЁҐ н«Ґ¬Ґ­в  бЇЁбЄ  */
int func_change();     /* €§¬Ґ­Ґ­ЁҐ §­ зҐ­Ёп Ї®«Ґ© н«Ґ¬Ґ­в  бЇЁбЄ  */
int func_sort();       /* ”г­ЄжЁп б®авЁа®ўЄЁ бЇЁбЄ  */
int func_save();       /* ”г­ЄжЁп б®еа ­Ґ­Ёп бЇЁбЄ  ­  ¤ЁбЄҐ */
int func_restore();    /* ЏҐаҐ§ ЇЁбм бЇЁбЄ  Ё§ д ©«  ў ¤Ё­ ¬ЁзҐбЄго Ї ¬пвм */
void func_free_list(); /* ”г­ЄжЁп ®бў®Ў®¦¤Ґ­Ёп ¤Ё­ ¬ЁзҐбЄ®© Ї ¬пвЁ*/
int get_sort_index();  /* ”г­ЄжЁп ўлЎ®а  бЇ®б®Ў  б®авЁа®ўЄЁ */

#define SCREEN_LEN 3
#define FIELD_LEN 24
#define FIELD_NUM 7
char FILE_NAME[80]="";

char *field_name[]={
"Car number",
"Model",
"Power",
"Color",
"Mechanic name",
"Qualification",
"Type of works"
};

/* „«п б®Єа йҐ­Ёп § ЇЁбЁ вЁЇ  бвагЄвгал ўўҐ¤Ґ¬ ­®ўл© вЁЇ */
typedef struct _serv serv;

/* ЋЇЁб ­ЁҐ бвагЄвгал */
struct _serv {
   char data[FIELD_NUM][FIELD_LEN+1];
   serv *next; /* “Є § вҐ«м ­  б«Ґ¤гойЁ© н«Ґ¬Ґ­в */
   };

serv *servh = NULL; /* Ќ з «® бЇЁбЄ  */

void main()
{
int i;
/* ‘вагЄвга  ¬Ґ­о */
struct{
      int op; /* Ќ®¬Ґа ®ЇҐа жЁЁ */
      int (*opf)(); /* ”г­ЄжЁп ®Ўа Ў®вЄЁ */
      }
      m[9] = {
    {'1',func_print},
    {'2',func_input},
    {'3',func_add},
    {'4',func_delete},
    {'5',func_change},
    {'6',func_sort},
    {'7',func_save},
    {'8',func_restore},
    {'0',NULL}
      };
int opcode; /* Љ®¤ ®ЇҐа жЁЁ */
int show_mes=0;
char c;
for ( ; ; )
{   
    if(show_mes==1)
    {
    printf("\n\nPress any key to continue...");
    fflush(stdin);
    getch();
    }
    clrscr();       
    printf("========== Dmytro Shylga. Lab 3. =======");
    printf("\n1. Print\n");  /* ‚лў®¤ Їг­Єв®ў ¬Ґ­о ­  нЄа ­ */
    printf("2. Input\n");
    printf("3. Add\n");
    printf("4. Delete\n");
    printf("5. Change\n");
    printf("6. Sort\n");
    printf("7. Save\n");
    printf("8. Restore\n");
    printf("0. Quit\n");
    printf("========================================\n");
    printf("Enter operation code > "); /* ‡ Їа®б ­  ўў®¤ ­®¬Ґа 
                        Їг­Єв  ¤«п ўлЇ®«­Ґ­Ёп */
    fflush(stdin);
    opcode=getchar(); /* ‚ў®¤ ­®¬Ґа  Їг­Єв  */
    if (opcode=='0')
    {            /* ўл室 Ё§ Їа®Ја ¬¬л, Ґб«Ё ўлЎа ­ QUIT Ё Ґбвм Ї®¤вўҐа¦¤Ґ­ЁҐ */
    printf("Do you want to quit? (y/n) ");
    fflush(stdin);
    c=getch();
    if(c=='Y' || c=='y')
    {
        func_free_list();
        exit(0);
    }
    show_mes=0;
    continue;
    }
    for (i=0; i<10;i++)
    {
    if (opcode==m[i].op)
    {
        m[i].opf();
        show_mes=1;
    }
    }
}
}

/****************************************************************/
/**************** ”г­ЄжЁп ўлў®¤  бЇЁбЄ  ­  нЄа ­ ****************/
/****************************************************************/
int func_print()
{
serv *ptr;
int i, j;

if (servh==NULL)
    {
    printf("\n============ List is empty =============\n");
    return 0;
    }

    for (ptr = servh, i=1; ptr != NULL; ptr = ptr->next, i++)
    {
    char num[3];
    sprintf(num, "%-2d" , i);
    for (j = 0; j < FIELD_NUM; j++)
    {
    printf("%s %-13s> %s\n", j==0?num:"  ", field_name[j], ptr->data[j]);
    }
    if ( (i%SCREEN_LEN)==0)
    {
    printf("Press any key for continue...\n");
    fflush(stdin);
    getch();
    }
    }
    printf("\n============ End of list ===============\n");
return 0;
}

/****************************************************************/
/*********** ”г­ЄжЁп ўў®¤  н«Ґ¬Ґ­в®ў бЇЁбЄ  *********************/
/****************************************************************/
int func_input()
{
int cc;
do
{
    printf("\nEnter '*' for end of stream\n");
}
while ( !(cc = func_add()) ); /* ‚맮ў дг­ЄжЁЁ ¤®Ў ў«Ґ­Ёп */
return 0;
}

/****************************************************************/
/************* „®Ў ў«Ґ­ЁҐ н«Ґ¬Ґ­в  ў бЇЁб®Є *********************/
/****************************************************************/
int func_add()
{
serv *a, *b;
char symbol=0;
int i=1,j;

if (servh != NULL)
    for (i++,a=servh; a->next!=NULL; a=a->next,i++);

if(!(b=(serv *)malloc(sizeof(serv))))
{
    printf("Not enough dynamic space\n");
    return 1;
}
memset((void*)b, 0, sizeof(serv));
for (i=0; i<FIELD_NUM; i++)
{
    printf("%-13s > ",field_name[i]);
    fflush(stdin);
    for (j=0; j<FIELD_LEN; j++)
    {
    if((symbol=getchar()) == '\n')
        break;
    if(j==0 && symbol=='*')
    {
        free(b);
        return 2;
    }
    b->data[i][j]=symbol;
    }
}
/* ќ«Ґ¬Ґ­в ўбв ў«пҐвбп ў Є®­Ґж бЇЁбЄ  Ё«Ё ў ­ з «®,
Ґб«Ё бЇЁб®Є Їгбв®© */
if (servh==NULL) servh=b;
else a->next=b;
return 0;
}

/*****************************************************************/
/************ ”г­ЄжЁп б®еа ­Ґ­Ёп бЇЁбЄ  ­  ¤ЁбЄҐ *****************/
/*****************************************************************/
int func_save()
{
FILE *fd;
serv *ptr;

printf("Enter filename > ");
fflush(stdout);
scanf("%s",FILE_NAME);
/* ЋвЄалвЁҐ д ©«  ­  § ЇЁбм */
if((fd=fopen(FILE_NAME,"w"))==NULL)
{
    printf("Can't save %s file\n", FILE_NAME);
    fflush(stdout);
    return 0;
}
/* ‡ ЇЁбм ў д ©« */
for (ptr=servh; ptr!=NULL; ptr=ptr->next)
{
    fwrite(ptr->data, FIELD_NUM, FIELD_LEN+1, fd);
}
printf("\n============= File saved ============\n");
fclose(fd);        /* ‡ ЄалвЁҐ д ©«  */
return 0;
}

/****************************************************************/
/****** ЏҐаҐ§ ЇЁбм бЇЁбЄ  Ё§ д ©«  ў ¤Ё­ ¬ЁзҐбЄго Ї ¬пвм ********/
/****************************************************************/
int func_restore()
{
int ret_code = 1;
FILE *fd;
serv *ptr, *curr_ptr;
/* ЋвЄалвЁҐ д ©«  ¤«п з⥭Ёп, Ґб«Ё д ©« ­Ґ ­ ©¤Ґ­ - ўлў®¤
ᮮ⢥вбвўго饣® б®®ЎйҐ­Ёп */
printf("Enter filename > ");
scanf("%s",FILE_NAME);
if ((fd = fopen(FILE_NAME, "r"))==NULL)
{
    printf("File '%s' not found\n",FILE_NAME);
    return 0;
}
func_free_list();
do
{
    if ((ptr=(serv *)malloc(sizeof(serv))) == NULL)
    {
    printf("Not enough dynamic space\n");
    break;
    }
    memset((void*)ptr, 0, sizeof(serv));
    if (fread(ptr->data, FIELD_NUM, FIELD_LEN+1, fd) > 0)
    {
    if (servh==NULL) servh = ptr;
    else curr_ptr->next = ptr;
    curr_ptr = ptr;
    }
    else
    {
    free(ptr);
    ret_code = 0;
    printf("\n============= File restored ============\n");
    break;
    }
} while ( 1 );
fclose(fd);  /* ‡ ЄалвЁҐ д ©«  */
return ret_code;
}

/*****************************************************************/
/*************** ”г­ЄжЁп б®авЁа®ўЄЁ бЇЁбЄ  ***********************/
/*****************************************************************/
int func_sort()
{
int n;
int j;
serv *a, *b, *c;
/* …б«Ё бЇЁб®Є Їгбв®© Ё«Ё ў ­Ґ¬ ®¤Ё­ н«Ґ¬Ґ­в,
в® ўл室 Ё§ дг­ЄжЁЁ */
if ((servh==NULL)||(servh->next==NULL)) return 0;
if ((j=get_sort_index()) == -1 ) return 0;
/* ‘®авЁа®ўЄ  бЇЁбЄ  ¬Ґв®¤®¬ "Їг§ламЄ " */
for (n=1; n; )
{
    n=0;
    for (a=servh, b=servh->next; b!=NULL; )
    {
    if (strcmp(a->data[j],b->data[j])>0)
    {
        a->next=b->next; b->next=a;
        if (a==servh) servh=b;
        else c->next=b;
        c=b; b=a->next;
        n=1;
    }
    else
    {
        c=a; a=b; b=b->next;
    }
    }
}
return 0;
}
/*****************************************************************/
/************ ‚ў®¤ ­®¬Ґа  н«Ґ¬Ґ­в  *******************************/
/*****************************************************************/

int get_ln ()
{
int ln;
printf("Enter line number >");
do
{
    scanf("%d",&ln);
    if ( ln < 1)
    {
    printf("\nIllegal line number. Try again >");
    ln=0;
    }
} while (!ln);
return --ln;
}

/*****************************************************************/
/************* “­Ёз⮦Ґ­ЁҐ н«Ґ¬Ґ­в  бЇЁбЄ  ***********************/
/*****************************************************************/
int func_delete ()
{
int ln;
serv *a, *b;
if (servh==NULL)
    printf("\n============ List is empty ============\n");
else
{
    ln = get_ln();
    if (ln==0)
    {
    a=servh; servh=a->next; free(a);
    printf("\n============ Element was deleted ============\n");
    }
    else
    {   
    for(a=servh, --ln; ln && (a!=NULL); a=a->next, ln--);
    if (a!=NULL)
    {
        if ((b=a->next)!=NULL)
        {
        a->next=b->next; free(b);
        printf("\n============ Element was deleted ============\n");
        }
    }
    }
}
return 0;
}

/*****************************************************************/
/********** €§¬Ґ­Ґ­ЁҐ §­ зҐ­Ёп Ї®«Ґ© н«Ґ¬Ґ­в  бЇЁбЄ  *************/
/*****************************************************************/
int func_change()
{
int ln, i, j, symbol;
serv *a;

ln = get_ln(); /* ‚ў®¤ ­®¬Ґа  н«Ґ¬Ґ­в  */
for ( a = servh; ln && a != NULL; ln--, a = a->next);
if (a == NULL) return 0;
/* ‚лў®¤ бв але Ё ўў®¤ ­®ўле §­ зҐ­Ё© */
/* ‡ ЇЁбм ­®ўле §­ зҐ­Ё© ў бЇЁб®Є */
for (i=0;i<FIELD_NUM;i++)
{
    printf("Old %-13s '%s'.  New > ",field_name[i], a->data[i]);
    memset((void*)a->data[i], 0, sizeof(a->data[i]));
    fflush(stdout);
    fflush(stdin);
    for (j=0; j<FIELD_LEN; j++)
    {
    if((symbol=getchar()) == '\n')
        break;
    a->data[i][j]=symbol;
    }
    fflush(stdin);
}
return 0;
}

/****************************************************************/
/********* ”г­ЄжЁп ®бў®Ў®¦¤Ґ­Ёп ¤Ё­ ¬ЁзҐбЄ®© Ї ¬пвЁ *************/
/****************************************************************/
void func_free_list()
{
serv *ptr, *ptr_next;

for(ptr = servh; ptr != NULL; )
{
    ptr_next = ptr->next;
    free(ptr);
    ptr = ptr_next;
}
servh = NULL;
}

/****************************************************************/
/************** ”г­ЄжЁп ўлЎ®а  бЇ®б®Ў  б®авЁа®ўЄЁ ***************/
/****************************************************************/
int get_sort_index()
{
int i, num;
for ( ; ; )
{   
    clrscr();
    printf("\n============= Sort by ==================\n");
    for (i=0; i<FIELD_NUM; i++)
    {
    printf("%d. %s\n", i+1, field_name[i]);
    }
    printf("\nEnter field number > ");
    fflush(stdout);
    fflush(stdin);
    num = getchar(); /* ‚ў®¤ ­®¬Ґа  Їг­Єв  */
    num -= 060;
    if( num < 1 || num > FIELD_NUM ) continue;
    break;
}
printf("\n=========== List sorted ================\n");
return --num;
}