Методические указания ЛР10_2014 (1079947), страница 3

Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 3)

////////

// Student * pStud = new Student;

Student * pStud = (Student *) malloc (sizeof(Student));

pStud->Num = 3;

pStud->Oklad = 3000.00;

strcpy(pStud->Name , "Большаков");

printf ("Пункт МУ 6:\n");

PrintStudent( pStud ) ;

// delete pStud;

free( pStud );

pStud= NULL;

////////

// МУ п.7

////////

Student SMas[] ={{"Первый" , 1 , 1000.0}, {"Второй" , 2 , 2000.0}, {"Третий" , 3 , 3000.0},

{"Четвертый" , 4 , 4000.0}};

int RazmS = sizeof(SMas)/ sizeof(Student); // Вычисление размерности массива

printf ("Пункт МУ 7:\n");

for (int i = 0 ; i < RazmS ; i++ )

PrintStudent( &SMas[i] ) ;

////////

// МУ п.8

////////

printf ("Пункт МУ 8:\n");

StudPrintMas( SMas , RazmS);

////////

// МУ п.9

////////

printf ("Пункт МУ 9:\n");

const int Rzm = 6;

Student * pPotok = new Student[Rzm];

// Заполнение

srand( (unsigned)time( NULL ) ); // Настройка датчика случайных чисел

rand(); // первое число

for (int i=0 ; i < Rzm ; i++ )

{

char Buf[20];

char Num[10];

strcpy(Buf , "Stud № - ");

pPotok[i].Num = (rand()*9)/ RAND_MAX ; // диапазон 0 - 9

pPotok[i].Oklad = 1000.0 * 10.0 * rand() / RAND_MAX ;// диапазон 0 - 10000.0

int n = (rand()*30)/ RAND_MAX ;// диапазон 0 - 30

strcat(Buf , itoa (n + 1 ,Num, 10 ));

strcpy( pPotok[i].Name , Buf);

// PrintStudent( &pPotok[i] );

};

StudPrintMas( pPotok , 6);

////////

// МУ п.10 BDStud.bin

////////

///////

// МУ п.11 Синий

////////

Student ZMas[] ={{"Запись 1" , 0 , 1000.0}, {"Запись 2" , 0 , 2000.0}, {"Запись 3" , 0 , 3000.0},

{"Запись 4" , 0 , 4000.0}};

int RazmZ = sizeof(ZMas)/ sizeof(Student); // Вычисление размерности массива

printf ("Пункт МУ 11(синий):\n");

system ( "attrib -R BDStud.bin "); // Снятие атрибута защиты записи, нужно после первого создания

pFBin = _open( "BDStud.bin", _O_RDWR |_O_BINARY | _O_CREAT | _O_TRUNC);

system("attrib -R BDStud.bin ");

if ( pFBin != -1 )

{

for ( int i = 0 ; i < RazmZ ; i++ )

{

ZMas[i].Num = i + 1;

_write (pFBin , &ZMas[i] , sizeof(Student));

};

_close( pFBin );

};

StudPrintMas( ZMas , RazmZ);

system("attrib -R BDStud.bin ");

////////

// МУ п.11 Рас

Student MASStud[100];

Student SRBuf;

printf ("Пункт МУ 11(Печать файла):\n");

pFBin = _open( "BDStud.bin", _O_RDWR |_O_BINARY );

if ( pFBin != -1 )

{

for ( int i = 0 ; _eof(pFBin) == NULL ; i++ )

{

/* int nByte = _read( pFBin , &SRBuf , sizeof(Student));

PrintStudent( &SRBuf ); */

int nByte = _read( pFBin , &MASStud[i] , sizeof(Student));

PrintStudent( &MASStud[i] );

RazmZ = i;

}

_close( pFBin );

};

printf ("Пункт МУ 11(Печать всего массива):\n");

StudPrintMas( MASStud , RazmZ + 1 );

////////

// МУ п.11 Зеленый

////////

printf ("Пункт МУ 11:\n");

system ( "attrib -R BDStud.bin "); // Снятие атрибута защиты записи, нужно после первого создания

pFBin = _open( "BDStud.bin", _O_RDWR |_O_BINARY | _O_CREAT | _O_TRUNC);

system("attrib -R BDStud.bin ");

if ( pFBin != -1 )

{

for ( int i = 0 ; i < 4 ; i++ )

{

Student StudFile;

char Buf[20];

char Num[10];

strcpy(Buf , "Запись № - ");

StudFile.Num = (rand()*9)/ RAND_MAX ;

StudFile.Oklad = 1000.0 * 10.0 * rand() / RAND_MAX ;

strcat(Buf , itoa (i + 1 ,Num, 10 ));

strcpy( StudFile.Name , Buf);

//

_write (pFBin , &StudFile , sizeof(Student));

PrintStudent( &StudFile );

};

//

_close( pFBin );

system("attrib -R BDStud.bin ");

};

// Специальные функции:

// - из файла в массив ( имя файла , указатель на массив структурных переменных)

/////////////////////////////////////////////////////

////////

// МУ п.12

////////

Student * pStMas;

int StudCount;

//

printf ("Пункт МУ 12:\n");

//printf ("Работа с функциями:\n");

StudFileToMas( "BDStud.bin" , &pStMas , &StudCount );

StudPrintMas( pStMas , StudCount);

// - из массива в файл ( имя файла , указатель на массив структурных переменных)

strcpy( (char *)((pStMas + 1)->Name) , "Новая");

/////////////////////////////////////////////////////

////////

// МУ п.13

////////

Student NZMas[] ={{"Запись 1" , 1 , 1000.0}, {"Запись 2" , 2 , 5000.0}, {"Запись 3" , 3 , 3000.0},

{"Запись 4" , 4 , 4000.0}};

RazmZ = sizeof(NZMas)/ sizeof(Student); // Вычисление размерности массива

// Изменение второй (индекс = 1) записи

NZMas[1].Num =5;

strcpy( NZMas[1].Name , "Изменение 2-й");

printf ("Пункт МУ 13:\n");

StudMasToFile( "BDStud.bin" , NZMas , RazmZ );

printf ("После редактирования массива и запоминания в файле\n");

StudPrintMas( NZMas , StudCount);

////////

// МУ п.14

////////

printf ("Пункт МУ 14:\n");

printf ("После редактирования массива и запоминания - распечатка из файла функцией:\n");

// Распечатка файла записей

StudPrintFile( "BDStud.bin" );

// Число записей в БД

////////

// МУ п.15

////////

printf ("Пункт МУ 15:\n");

/////////////////////////////////////////////////////

printf( "Число записей в БД = %d \n",StudFileCount( "BDStud.bin" , &StudCount ));

// Заполнение файла на основе массива

////////

// МУ п.13 (второй вариант на основе инициализированного массива)

////////

printf ("Пункт МУ 13:\n");

Student StudMas[] ={{"Иванов" , 3 , 7000.0}, {"Петров" , 2 , 2000.0}, {"Сидоров" , 1 , 3000.0}, {"Печкин" , 4 , 4000.0}};

StudMasToFile( "BDStud.bin" , StudMas , StudCount );

// Распечатка файла записей

StudPrintFile( "BDStud.bin" );

//

////////

// МУ п.16

////////

printf ("Пункт МУ 16:\n");

StudClearFile("BDStud.bin");

StudPrintFile( "BDStud.bin" );

////////

// МУ п.17

////////

//

printf ("Пункт МУ 17:\n");

// StudRemoveFile("BDStud.bin"); // Временно за комментировано

ClearReadonlyFile("BDStud.bin");

StudClearFile("BDStud.bin");

StudPrintFile( "BDStud.bin" );

//

printf ("Пункт МУ 17 снова добавим записи из массива:\n");

StudMasToFile( "BDStud.bin" , pStMas , StudCount );

StudPrintFile( "BDStud.bin" );

////////

// МУ п.18

////////

printf ("Пункт МУ 18 (Sawp - до):\n");

Student StudA ={ "Лаптева" , 1 , 1000.0};

Student StudB ={ "Иванова" , 2 , 2000.0};

PrintStudent(&StudA) ;

PrintStudent(&StudB) ;

printf ("Пункт МУ 18 (Sawp - после):\n");

SwapStudent( &StudA , &StudB); // Обмен двух отдельныз записей

PrintStudent(&StudA) ;

PrintStudent(&StudB) ;

// В массиве

printf ("Пункт МУ 18 (Sawp - pStMas - до):\n");

StudPrintMas( pStMas , StudCount);

printf ("Пункт МУ 18 (Sawp - pStMas - после):\n");

SwapStudent( &pStMas[0] , &pStMas[2]); // Обмен двух элементов массива

StudPrintMas( pStMas , StudCount);

// Сортировка массива по одному полю записи

////////

// МУ п.19

////////

printf ("Пункт МУ 19 (SORT - pStMas - до):\n");

StudPrintMas( pStMas , StudCount);

// Сортировка по окладу

for( int k =0 ; k< StudCount - 1 ; k++)

for ( int i =0 ; i< StudCount - 1 ; i++ )

if ( (pStMas + i)->Oklad > (pStMas + i + 1)->Oklad ) // Возрастание

SwapStudent( pStMas + i , pStMas + i + 1 );

printf ("Пункт МУ 19 (SORT - pStMas - после Oklad):\n");

StudPrintMas( pStMas , StudCount);

// Сортировка по имени

for( int k =0 ; k< StudCount - 1 ; k++)

for ( int i =0 ; i< StudCount - 1 ; i++ )

if ( strcmp((pStMas + i)->Name , (pStMas + i + 1)->Name ) > 0 ) // Возрастание

SwapStudent( pStMas + i , pStMas + i + 1 );

printf ("Пункт МУ 19 (SORT - pStMas - после Name):\n");

StudPrintMas( pStMas , StudCount);

// Сортировка по номеру

for( int k =0 ; k< StudCount - 1 ; k++)

for ( int i =0 ; i< StudCount - 1 ; i++ )

if ( (pStMas + i)->Num > (pStMas + i + 1)->Num ) // Возрастание

SwapStudent( pStMas + i , pStMas + i + 1 );

printf ("Пункт МУ 19 (SORT - pStMas - после Num):\n");

StudPrintMas( pStMas , StudCount);

////////

// МУ п.20

////////

printf ("Пункт МУ 20 (SORT - функция - до):\n");

StudPrintMas( pStMas , StudCount);

StudSortMasNum( pStMas , StudCount );

printf ("Пункт МУ 20 (SORT - функция - после):\n");

StudPrintMas( pStMas , StudCount);

//

////////

// МУ п.21

////////

// Сортировка файла (!!!) по одному полю записи

/////////////////////////////////////////////////////

printf ("Пункт МУ 21 (SORT - c разными функциями):\n");

printf ("СОРТИРОВКА: Работа с функциями Name:\n");

StudSortName("BDStud.bin" );

StudPrintFile( "BDStud.bin" );

/////////////////////////////////////////////////////

printf ("СОРТИРОВКА: Работа с функциями Num (убывание):\n");

StudSortNum("BDStud.bin");

StudPrintFile( "BDStud.bin" );

/////////////////////////////////////////////////////

printf ("СОРТИРОВКА: Работа с функциями Oklad(возрастание ):\n");

StudSortOklad("BDStud.bin" );

StudPrintFile( "BDStud.bin" );

/////////////////////////////////////////////////////

////////

// МУ п.22 чтение одной записи 3-й (0 - 4 )

////////

Student SFind ;

pFBin = _open( "BDStud.bin" , _S_IREAD |_O_BINARY );

if ( pFBin != -1 )

{

long posF = _lseek( pFBin, sizeof(Student) * 2, SEEK_SET ); // Установить новую текущую позицию

int nByte = _read( pFBin , &SFind , sizeof(Student));

};

printf ("Пункт МУ 22:\n");

printf ("Чтение из программы (номер = 3):\n");

PrintStudent( &SFind );

// Закрытие файла

_close( pFBin );

//

////////

// МУ п.22.1 чтение из функции

////////

///// - Прочитать запись по номеру

printf ("Чтение из функции (номер = 1):\n");

// Student SFind ;

FindStudNum( "BDStud.bin" , &SFind , 1);

PrintStudent( &SFind );

////////

// МУ п.22.2 интегрированные расчеты в программе

////////

double SumStip = 0;

Student SIntg;

printf ("Пункт МУ 22.2(Интегральные расчеты):\n");

pFBin = _open( "BDStud.bin" , _S_IREAD |_O_BINARY );

if ( pFBin != -1 )

{

for ( int i = 0 ; _eof(pFBin) == NULL ; i++ )

{

int nByte = _read( pFBin , &SIntg , sizeof(Student));

SumStip = SumStip + SIntg.Oklad;

}

_close( pFBin );

Характеристики

Список файлов книги