Struct FILE

{int level; // пуст или полон буфер

unsigned flags; // флаги состояния файла

char fd; // логический номер файла, дескриптор файла

unsigned char hold; // непереданный символ

int bsize; // размер буфера

unsigned char _FAR *buffer;// указатель на буфер потока

unsigned char _FAR *curp; // указатель текущей позиции

unsigned istemp; // флаг временного файла

short token; // маркер действительности файла

};

Флаги состояния задают битовую позицию в члене структуры flags.

Определена специальная константа, обозначающая конец файла:

#define EOF (-1) // индикатор конца файла

Функции обмена с файлами могут работать в двух режимах: текстовом и двоичном. По умолчанию режим устанавливается текс­товый. В текстовом режиме при записи в файл символ '\n' (перевод на начало новой строки) преобразуется в два символа '\n' и '\0', а при чтении из файла такие символы уже воспринимаются как два символа '\n' и '\0'. Такженажатиеклавиш Ctrl-Z (конец ввода строки) воспринимается как конец строки '\0', который не записывается в файл.

При обмене с файлом в двоичном режиме никаких преобразова­ний символов не производится.

В файлах <fcntl.h> и <stdlib.h> определена специальная переменная _fmode, которая может принимать значения O_BINARY (бинарный режим) или O_TEXT (текстовый режим). Например:

_fmode=O_BINARY;

3.2 Открытие и закрытие потока

Для начала обмена данными между программой и файлом необходимо открыть поток.

Функция открытия потока имеет прототип:

FILE* fopen(const char* filename, const char* mode);

Эта функция открывает поток, который связывает программу с заданным файлом. В случае успешного открытия возвращается указатель на структуру типа FILE (FILE*), описывающую открытый поток. Если файл не удалось открыть, функция возвращает значение NULL- указатель. Возвращаемое значение указателя присваивается ранее определенной переменной типа FILE*, которую в дальнейшем можно использовать для обмена данными с файлами.

Переменная char* filename – указатель на константную стро­ку, задающую спецификацию открытого файла, т.е. путь и имя файла. Если путь не задан, то по умолчанию выбирается текущий диск и директорий.

Переменная char* mode ‑ указатель на строку, задающую режим открытия потока и состоящую из определенных символов:

r – поток открывается только для чтения из существующего файла, r+ – поток открывается для чтения из существующего и записи в существующий файл;

w – поток открывается только для записи в файл, w+ – поток откры­вается для записи в файл и для чтения из файла. Если файла нет, он создается, если файл существует, его старое содержимое пропадает;

a – поток открывается для добавления данных в конец файла, a+ – поток открывается для добавления данных в конец файла и для чтения из файла. Если файл не существует, он создается;

t – поток открывается в текстовом режиме, задается после r, w, a;

b – поток открывается в двоичном режиме, задается после r, w, a.

Пример. Фрагмент программы, в которой открывается поток fp для записи данных в файл myfile.txt ипоток fin для записи данных в файл abc.txt на диске D в директории USER:

FILE *fp, *fin;

fp=fopen("D:\\User\\myfile.txt","w");

char *fname=("D:\\User\\abc.txt");

fin=fopen(fname,"r");

Если открытие потока оказалось неудачным, то функция возвра­щает NULL- указатель. При открытии потока рекомендуется выполнять проверку возвращаемого значения функции открытия файла:

if(fp==NULL){puts(“ошибка открытия файла”); return -1;}

if(fin==NULL){puts("ошибка открытия файла");return -1;}

После работы с потоком его закрывают.

Функция закрытия потока имеет прототип:

int fclose(FILE *имя);

Эта функция закрывает открытый поток. В функцию передается указатель на структуру типа FILE (имя открытого потока), и при успешном закрытии потока функция возвращает 0, иначе – EOF(–1). Эта функция удаляет структуру типа FILE, выгружает содержимое буфера на диск, если файл был открыт для записи, и вызывает функцию закрытия файла MS DOS, которая обновляет содержимое директория (обновляет информацию о размере, дате и времени). Например: fclose(fp);

В программе может быть открыто несколько файлов. В конце работы с ними их необходимо все закрыть. Есть функция закрытия всех открытых файлов с прототипом: int fcloseall(void);

Эта функция возвращает число закрытых файлов, или EOF, если хотя бы один файл не удалось закрыть.

int n=fcloseall(void);

printf("n=%d",n); //n=2, если закрылись два открытых потока)

// или n=-1,если какой-либо поток из двух открытых не закрывается

Для переоткрытия файла с другим режимом доступа существует функция со следующим прототипом:

FILE *freopen(const char *filename,const char*mode,FILE *fp);

Эта функция закрывает поток fp с прежним именем файла и открывает снова этот же поток с именем файла, на который указывает ASCIIZ -строка filename в режиме, указанном в строке mode. В случае успеха функция возвращает указатель на описание открытого потока, которое будет совпадать с fp, иначе NULL. Если имена файлов разные, происходит переадресация файлового ввода-вывода.

fp=freopen("D:\\User\\myfile.txt","a",fp);

FILE *fp1=freopen("D:\\User\\myfile1.txt","ab",fp);

freopen("D:\\User\\abc.txt","r",fin);

Пример. Файл сначала открывается для чтения, затем снова откры­вается для дополнения.

#include<stdio.h>

int main()

{FILE *fp;

char buff[100], *fname ="myfile.txt";

fp=fopen(fname,"r"); // открытие потока для чтения из файла

if(fp!=NULL)fgets(buff,50,fp);// чтение из файла строки

else {puts("ERROR_1"); return -1;}

puts(buff); // вывод на экран считанной из файла строки

fp=freopen(fname,"a",fp); // переоткрытие потока

if(fp!=NULL) fputs("abcdef",fp);// добавление строки

else {puts("ERROR_2"); return -1;}

fclose(fp); // закрытие потока

return 0;}

При работе с файлами большая роль отводится обработке ошибок. Для анализа ошибок можно использовать функцию c прототипом:

void perror(const char *str);

Эта функция выводит в поток (на экран) строку str вместе с системной ошибкой. Список системных ошибок определен в файле <stdlib.h>.

FILE *ptr=fopen("abc.doc","r"); // открытие файла для чтения

if(fp==NULL){perror("Не могу открыть файл: "); return -1;}

char c=fgetc(ptr); // чтение одного символа

fclose(ptr); // закрытие потока

Если файл в текущем директории отсутствует, то на экран выведется:

Не могу открыть файл: No such file or directory

После успешного открытия файла программа может осуществ­лять файловый ввод-вывод. Функции потокового ввода-вывода можно разделить на четыре группы: 1) функции посимвольного ввода-выво­да, которые переносят один символ; 2) функции построчного ввода-вывода, которые переносят одну строку; 3) функции форматирован­ного ввода-вывода данных; 4) функции блокового ввода-вывода, которые переносят блоки данных.

3.3 Посимвольный ввод-вывод

Функция посимвольной записи (вывода) в файл имеет прототип:

int fputc(int ch, FILE *fp);

Эта функция помещает символ int ch после преобразования в тип char в открытый поток fp, связанный с файлом. В случае успеха возвращает код записываемого в файл символа, а в случае ошибки или достижения конца файла – EOF.

Пример. Запись символов в открытый для записи файл через поток fp

FILE *fp=fopen("abc.txt","w"); // открытие потока для записи

if(fp==NULL){puts("ошибка открытия файла"); return -1;}

char s1='Z', str1[]="Запорожье",s2;

fputc(s1,fp); // запись символа в файл через поток fp

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

fputc(str1[i],fp); // запись 9 символов в файл

fputc('\n',fp); // запись символа \n в файл

printf("Введите символ или Ctrl-Z");

while((s2=getchar())!=EOF)

fputc(s2,fp); // запись символов в файл

fclose(fp); // закрытие потока

Функция посимвольного чтения (ввода) из файла имеет прототип:

int fgetc(FILE *fp);

Эта функция возвращает символ из открытого потока fp, связанного с файлом, или EOF (–1) в случае ошибки или достижения конца файла.

Пример. Чтениесимволов из открытого для чтения файла через поток fp

FILE *fp=fopen("abc.txt","r"); // открытие потока для чтения

if(fp==NULL){puts("ошибка открытия файла"); return -1;}

char z1, str2[9],z2;

z1=fgetc(fp); // чтение символа из файла через поток fp

printf("%c\n",z1);// вывод на экран прочитанного символа

for(int j=0;j<9;j++)

{str2[j]=fgetc(fp); // чтение 9 -и символов из файла

printf("%c",str2[j]);} // вывод на экран cчитанных символов

while((z2=fgetc(fp))!=EOF) // чтение символов из файла

putchar(z2);// вывод на экран прочитанных символа

fclose(fp); // закрытие потока

3.4 Построчный ввод-вывод

Функция построчной записи (вывода) в файл имеет прототип:

int fputs(char*string, FILE *fp);

Эта функция переносит байты из строки string в открытый файл через поток fp. Перенос завершается при достижении символа '\0', который в файл не заносится. В случае успеха функция возвращает код последнего записанного в файл символа, а в случае ошибки – EOF. Необходимо следить, чтобы записыва­емая в файл последовательность символов имела '\0', иначе файл может оказаться неожиданно большим.

Пример. Запись строк в открытый для записи файл через поток fp

FILE *fp=fopen("abc.txt","w"); // открытие потока для записи

if(fp==NULL){puts("ошибка открытия файла"); return -1;}

char *s1=”Физика”,*ms1[3]={"ТЕК","КЕ","ПТЦА"};

fputs(s1,fp); // з апись строки в файл через поток fp

fputs("\n",fp); // з апись строки с \n в файл через поток fp

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

{fputs(ms1[i],fp); // запись 3 -х строк в файл через поток fp

fputs("\n",fp);}

fclose(fp);// закрытие потока

Функция построчного чтения (ввода) из файла имеет прототип:

char*fgets(char *string,int N,FILE *fp);

Эта функция принимает байты из открытого файла и размещает их по адресу, заданному указателем string. Прием завершается после при­ема N байт или при получении символа '\n', который тоже передает­ся в строку string. Последним символом является '\0'. В случае успеха возвращает указатель на строку string, а в случае ошибки или достижения конца файла – NULL –указатель. Для успешного чтения строки из файла надо зарезервировать достаточное место в памяти.

Пример. Чтение строк из открытого для чтения файла через поток fp

FILE *fp=fopen("abc.txt","r"); // открытие потока для чтения

if(fp==NULL){puts("ошибка открытия файла"); return -1;}

char s2[20], ms2[3][20]; // зрезервируем память

fgets(s2,20,fp);// чтение из файла строки, < 20 символов

puts(st2); // вывод на экран прочитанной строки

for(int j=0;j<3;j++)

{fgets(ms2[j],20,fp); // чтение из файла 3 - х строк, <20 сим-в

puts(ms2[j]);} // вывод на экран считанных строк

fclose(fp); // закрытие потока

Функция fgets() похожа на функцию gets(). Но функция gets(), получив из стандартного потока (клавиатуры) символ ' \n ' (Enter), преобразует его в ' \0 ' и помещает в строку. Функция fgets(), получив из потока (файла) символ ' \n ', записывает его в строку и еще дописывает символ ' \0 '. Функция fputs() похожа на функцию puts(). Но функция puts() преобразует символ конца строки ' \0 ' в символ ' \n ', выполняет перевод на начало новой строки. Функция fputs(), встретив символ ' \0 ' завершает запись в файл.

Таким образом, если записывать в файл строки без символа ' \n ' вконце строки функцией fputs(), то в файле будет только одна строка. При чтении функцией fgets() строки из файла функция puts() выве­дет на экран одну суммарную строку. Если записывать в файл строки с символом '\n' в конце, используя функцию fputs(), в файле будет несколько строк с символом ' \n '.При чтении строк из файла функцией fgets() символ ' \n 'преобразуется в символы' \n ', ' \0 ', а функция puts() выведет на экран строки с символом ' \n 'в конце каждой строки, т.е. между выводимыми строками появятся пустые строки.

Пример. Запись и чтение строк без символа ' \n 'и с символом ' \n '.

#include<stdio.h>

#include<string.h>

void main()

{int n=0;

FILE* pf=fopen("b.txt","w"); // открытие потока

char st1[]="Anna",st2[]="Маria",st3[20];

//char st1[]="Anna\n",st2[]="Маria\n",st3[20];

fputs(st1,pf); // запись в файл 4 символов (или 6 символов)

fputs(st2,pf); // запись в файл 5 символов (или 7 символов)

fclose(pf); // размер файла 9 байт (или 13 байт)

pf=fopen("b.txt","r");

while(fgets(st3,20,pf)!=NULL)

{puts(st3); n++;}

printf("Число строк=%d",n);

fclose(pf);}

На экран выведется

в первом случае:	во втором случае
AnnaМаria Число строк=1	Anna Маria Число строк=2

3.5 Форматированный ввод-вывод

Форматированный ввод-вывод данных является частным случаем строкового ввода-вывода. Особенность этого ввода-вывода то, что при переносе данных между файлом через открытый поток и программой происходит преобразование этих данных в соответствии с заданными спецификаторами формата. Спецификаторы формата такие же, как при консольном вводе-выводе.

Функция форматированной записи (вывода) в файл имеет прототип:

int fprintf(FILE *fp, char *format [,аргумент]…);

Эта функция выводит данные с преобразованием по формату в открытый поток fp, связанный с файлом. В случае успеха возвращает число выведенных байтов (символов), а в случае ошибки – EOF.

Пример. Запись чисел в открытый для записи файл через поток fp

FILE *fp=fopen("abc.txt","w");// открытие потока для записи

if(fp==NULL){puts("ошибка открытия файла"); return -1;}

int a=5; float b=3.56; long c=50000;

fprintf(fp,"%d %f %ld\n",a,b,c);

int arr[5]={1,2,3,4,5};

float mas[5]={1.1,2.2,3.3,4.4,5.5};

// запись массивов 5 -и чисел типа int, float в файл

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

fprintf(fp,"%d %f\n",arr[i],mas[i]);

Функция форматированного чтения (ввода) из файла имеет прототип:

int fscanf(FILE *fp, char *format [,указатель]…);

Эта функция выполняет ввод из открытого файла данных с преобразо­ванием по формату и с занесением в ячейки памяти, определяемые ука­зателями. В случае успеха возвращает число обработанных при вводе полей (спецификаторов) или EOF (–1) в случае ошибки или достижения конца файла.

Пример. Чтениечисел из открытого для чтения файла через поток fp

freopen("data.txt","r",fp); // переоткрытие потока

if(fp==NULL){perror("Входной файл не открыт "); return 1;}

int n; float f; long l;

fscanf(fp,"%d %f %ld\n",&n,&f,&l);// чтение чисел из файла

printf("%d %f %ld\n",n,f,l); // вывод чисел на экран

int a[5]; float m[5];

// чтение из файла и вывод на экран массивов из 5-и чисел типа int, float

for(int j=0;j<5;j++)

{fscanf(fp,"%d %f\n",&a[j],&m[j]);

printf("%d %f\n",a[j],m[j]); }

fclose(fp);

3.6 Форматированные вывод в строку и ввод из строки

Не редко возникает необходимость форматированного вывода данных в строку и ввода данных из строки.

Функция форматированного записи (вывода) в строку имеет прототип:

int sprintf(char *buf, char *format [,аргумент]…);

Эта функция выводит данные с преобразованием по формату в строку buf. Последний символ устанавливается ' \0 '. В случае успеха возвра­щает число выведенных байтов (символов), а в случае ошибки – EOF.

Функция форматированного чтения (ввода) из строки имеет прототип:

int sscanf(char *buf, char *format [,указатель]…);

Эта функция вводит из строки данные с преобразованием по формату и помещает их в ячейки памяти, определяемые указателями. В случае успеха возвращает число обработанных при вводе полей или EOF(–1) в случае ошибки.

Пример. Записьчисел в строку и чтение чисел из строки

int a1=10; long b1=50000; char buf1[20];

sprintf(buf1,"a1=%d, b1=%ld",a,b);

puts(buf1);// a1=10, b1=50000

float e, pi; char buf2[25]="2.718281, 3.141592";

sscanf(buf2,"%f, %f",&e,&pi);

printf("e=%f pi=%f\n",e,pi););//e=2.718281 pi=3.141592

int a2; long b2;

sscanf(buf1,"a1=%d, b1=%ld",&a2,&b2);

printf("a2=%d b2=%ld\n",a2,b2); //a2=10 b2=50000

3.7 Блоковый ввод-вывод

Эти функции предназначены для ввода-вывода блоков байт. Блок – это группа рядом расположенных байт, между которыми нет никаких специальных разделителей. Для того чтобы не иметь проблем с символами ' \n ', ' \0 ', блоковый ввод-вывод выполняют в бинарном режиме. За одно обращение можно переносить несколько блоков.

Функция блокового записи (вывода) в файл имеет прототип:

int fwrite(void *ptr, int size, int N, FILE *fp);

Эта функция записывает через поток fp в открытый файл N блоков, размером size байт каждый, из области памяти, определяемой указа­телем ptr. В случае успеха возвращает число блоков, а в случае ошибки – EOF.

Пример. Запись блоков данных в открытый для записи в двоичном режиме файл через поток fp

FILE *fp=fopen(“abc.txt”,"wb");

if(fp==NULL){puts("ошибка открытия файла"); return -1;}

struct REC{int a[2]; float b;}; // определение структ.типа

REC str1={1,2, 3.3}; // определение и инициализация структуры

fwrite(&str1,sizeof(REC),1,fp); // запись структуры в файл

REC str2[3]={{3,4, 5.5},{6,7, 8.8},{9,10, 1.1}};

fwrite(str2,sizeof(REC),3,fp);// запись массива структур в файл

fclose(fp);

Функция блокового чтения (ввода) из файла имеет прототип:

int fread(void *ptr,int size,int N,FILE *fp);

Эта функция считывает через поток fp из открытого файла N блоков, размером size байт каждый, в область памяти, определяемой указателем ptr. В случае успеха возвращает число блоков, а в случае ошибки или достижения конца файла – EOF.

Пример. Чтение блоков данных из открытого для чтения в двоичном режиме файла через поток fp

FILE *fp=fopen(“abc.txt”,"rb");

if(fp==NULL){puts("ошибка открытия файла"); return -1;}

REC str3, str4[3]; // определение структуры и массива структур

fread(&str3,sizeof(REC),1,fp); // чтение структуры из файла

printf("%d %d %f\n",str3.a[0],str3.a[1],str3.b);

fread(str4,sizeof(REC),3,fp);// чтение массива структур из файла

for(int i=0;i<3;i++) // вывод массива структур на экран

printf("%d %d %f\n",str4[i].a[0],str4[i].a[1],str4[i].b);

fclose(fp);

3.8 Произвольный доступ к файлу

При обмене данными с файлом (записи и чтении) – место, куда записывается или считывается информация, определяется указателем записи-чтения. Ранее рассматривались функции обмена с файлом, ко­торые осуществляли последовательный доступ к файлу. В библиотеке языка Си имеются функции, позволяющие выполнить произвольный доступ к файлу, т.е. доступ в любую точку файла.

Функция установки указателя записи-чтения на начало файла имеет прототип void rewind(FILE *fp); Например: rewind(fp);

Функция установки указателя записи-чтения в произвольную точку файла имеет прототип:

int fseek(FILE *fp, long offset, int from_where);

Эта функция устанавливает указатель записи-чтения в потоке fp на offset байт вправо или влево. Если offset>0, то указатель сдвигает­ся в сторону конца файла, если offset<0, то указатель сдвигается в сторону начала файла. Параметр from_where задает точку отсчета для сдвига: SEEK_SET – сдвиг от начала файла, SEEK_CUR – сдвиг от теку­щей позиции указателя, SEEK_END – сдвиг от конца файла. В случае успеха функция возвращает 0, иначе – EOF.

Установка указателя записи-чтения левее начала файла считается ошибкой, установка указателя правее конца файла делает значение указателя записи-чтения неопределенным. Например:

// установка указателя записи-чтения через 10байт от начала файла fseek(fp,10L,SEEK_SET);

Функция определения текущего положения указателя записи-чтения имеет прототип: long ftell(FILE *fp);

Эта функция возвращает значение в байтах (тип long) от начала фай­ла до текущего положения указателя записи-чтения файла, открытого через поток fp. В случае ошибки функция возвращает –1L. Например:

long cur=ftell(fp);

Пример. Запись и добавление в файл блоков данных (структур) и чтение одной заданной структуры записанных ранее в файл структур.

#include<stdio.h>

struct REC{unsigned id;char name[20];unsigned mark;};

int main()

{FILE *out,*in; REC rec;

int flag, sz=sizeof(REC); long len,kol,n;

if((out=fopen("mark.txt","wb"))==NULL)

{perror("Выходной файл не открыт"); return 1;}

do {puts("Введите номер записи, фамилию, оценку");

scanf("%d",&rec.id);

gets(rec.name);

scanf("%d",&rec.mark);

fwrite(&rec,sz,1,out);// запись в файл блока данных

puts("Продолжить ввод? Да-1, Нет-0");

scanf("%d",&flag);

}while(flag);

fclose(out);// закрытие файла

if((in=fopen("mark.txt","rb"))==NULL)

{perror("Входной файл не открыт"); return 2;}

// сдвиг указателя чтения-записи на конец файла

fseek(in,0,SEEK_END);

// определение текущего значения указателя чтения-записи

len=ftell(in);

kol=len/sz; // количество блоков в файле

printf("В файле %d записей\n", kol);

puts("Введите номер записи для чтения:");

scanf("%ld",&n);

if(n>0&&n<=kol)

{fseek(in,(n-1)*sz,SEEK_SET); // установка указателя

// чтения-записи на заданный блок от начала файла

fread(&rec,sz,1,in); // чтение из файла блока данных

printf("%d %s – %d\n",rec.id_rec,rec.name,rec.mark);

}

else puts("Вне файла!");

fclose(in); // закрытие файла

return 0;}

3.6 Управление файлами и каталогами

В языке С имеются функции для управления файлами и директориями, в BC31 они имеют описания в файле <dir.h>.

Функция создания директория имеет прототип:

int mkdir(const char *path);

Эта функция создает директорий по маршруту, задаваемому строкой, на которую указывает path. В случае успеха функция возвращает 0, иначе –1. Попытка создания корневого директория является ошибкой.

Например:

char *dd="C:\\Common\\Prog";

if(mkdir(dd)!=0) puts("Не могу создать директорий");

Функция удаления директория имеет прототип:

int rmdir(const char * path);

Эта функция удаляет директорий по маршруту, задаваемому строкой path. При успешном удалении директория функция возвращает 0, иначе –1. Функция выдает ошибку при попытке удалить не пустой или корневой директорий. Например:

char *dd="C:\\Common\\Prog";

if(rmdir(dd)!=0) puts(“Не могу удалить директорий”);

Функция удаления файла описана в заголовочном файле <stdio.h> и имеет прототип:

int remove(const char *filename);

Эта функция удаляет файл с именем, задаваемым строкой filename, при успешном удалении файла возвращает 0. В противном случае возвращает –1 и записывает код ошибки во внешнюю переменную errno (errno=ENOENT – нет файла с таким именем, errno=EACCES –файл только для чтения и т.д.). Например:

char *ff="C:\\Common\\Prog\\lab5.cpp");

if(remove(ff)!=0) puts("Не могу удалить файл");

Функция определения текущего диска имеет прототип:

int getdisk(void);

Эта функция возвращает целое число, определяющее текущий диск. Диску (A:) соответствует значение 0, диску(B:)– 1, диску(C:) – 2 и т.д. Например:

int n=getdisk();

printf(“Текущий накопитель %с:\n”,‘A’+n);

Функция задания текущего диска имеет прототип:

int setdisk(int drive);

Эта функция устанавливает в системе текущий диск, задаваемый пара­метром drive (0 соответствует диску A:, 1 – диску B:, 2 – диску C: и т.д.) В случае успеха функция возвращает общее число дисков в системе, иначе –1. Например:

int t_d=4; // диск Е

int n=setdisk(t_d);

printf("Текущий диск %с:\n", ‘A’+t_d);

printf("Всего дисков %d\n", n);

Функция определения текущего директори я для заданного диска имеет прототип:

int getcurdir(int drive, char *dir);

Эта функция записывает в буфер, на который указывает dir,строку текущего директория для диска, задаваемого значением drive. Если значение drive равно 0, то записывается информация о текущем директории текущего диска, если 1 – диска A: и т.д. Функция в случае успеха возвращает 0, иначе ‑ –1. Например:

char inf[40]; int disk=0;

int n=getcurdir(disk,inf);

if(n==0)

printf("Текущий директорий на диске %с %s\n"(disk+’A’-1),inf);

else printf("не могу определить директорий");

Функция задания текущего директория имеет прототип:

int chdir(const char *path)

Эта функция в качестве текущего рабочего директория устанавливает директорий, задаваемый строкой, на которую указывает path. Функ­ция в случае успеха возвращает 0, иначе ‑ –1. Например:

char dir[]=“F:\\Users\\DIR\\data.txt”);

int n=chdir(dir);

if(n!=0) printf(“не могу установить заданный директорий”);

else printf(“Диск %с, текущий директорий %s\n”,dir[0],dir);

Пример. В этом примере создается новый заданный директорий, который затем открывается и в него записывается текстовый файл.

#include<stdio.h>

#include<dir.h>

int main()

{char namedir[30];

FILE *fp;

puts("Введите имя нового директория по формату F:\\USERS\\…");

gets(namedir);

if(mkdir(namedir)!=0) // создание нового директория

{perror("Не могу создать директорий! "); return 1;}

if(setdisk(namedir[0]-'A')==-1)// установка заданного диска

{perror("Не могу установить диск! ");return 2; }

if(chdir(namedir)==-1)// установка заданного директория

{perror("Не могу установить директорий! ");return 3;}

if((fp=fopen("test.txt","w"))==NULL)

{perror("Не могу открыть файл!"); return 4;}

fputs("TEST",fp); // запись строки в файл

fclose(fp); return 0;}

Пример. В этом примере удаляются файл и директорий.

#include<stdio.h>

#include<dir.h>

int main()

{char namedir[20],namefile[20];

puts("Введите имя директория по формату C:\\ABC");

gets(namedir);

puts("Введите имя файла"); gets(namefile);

setdisk(namedir[0]-'A');// установка заданного диска

chdir(namedir); // установка заданного директория

if(remove(namefile)==-1) // удаление файла

{perror("Не могу удалить файл!"); return 1;}

if(rmdir(namedir)==-1) // удаление директория

{perror("Не могу удалить директорий!"); return 2;}

return 0;}

4 Многофайловая компиляция

Программы – это обычно совокупность функций. Функции, как правило, размещают в разных файлах, группируя их по каким-либо признакам. В результате для создания конечной программы необходимо их объединить в единое целое.

Напомним, что из всей совокупности функций в программе может быть только одна главная функция main(), которая является точкой входа в программу.

Для объединения функций в одну программу существует несколько механизмов.

Самый простой способ: создать программу из нескольких файлов, используя препроссесорную директиву #include.