Читайте данную работу прямо на сайте или скачайте

Язык Си шаг за шагом

#include <stdio.h>

#include <dir.h>

#define FA_DIREC 0x10

#define CONTROL '$'

#define OPENа "<174>"

#define CLOSE "<175>"

#define DEFIS "<197>"

#define NUM "<102>"

#define EOLNа ' '

#define ITALIC "<I>"

#define BOLDа "<D>"

// $$narg=1;

charа in[20],x[40],z[80],str[120],img[80];

int empty,befor;

FILEа *fdi, *fdo;

int c0num,cnum,inum,nstr,tnum;

int sign,old,expand;

int GetStr()

{

befor = old; old = 1;

if (empty==0)

{

nstr++;

if (fgets(str,80,fdi)==NULL) return(-1);

if (str[0]==0 || str[0]=='\n')

{

befor=1;

nstr++;

if (fgets(str,80,fdi)==NULL) return(-1);

if (str[0]==0 || str[0]=='\n')

return(2);

else

{ empty=1; return(1); }

}

else

{ old=0; return(0); }

}

else

{

empty=0; old=0; return(0);

}

}

int NoLF()

{

int i;

for (i=0; str[i]!=0; i++)

if (str[i]=='\n') break;

str[i]=0;

}

Cat(s,pi,ss)

charа s[],ss[];

int *pi;

{

int i;

for (i=0; ss[i]!=0; i++,(*pi)++) s[*pi]=ss[i];

}

oidа ProcProg()

{

int i,j,n,k;

charа xx[120];

strcpy(xx,str);

for (i=j=n=k=0; xx[j]!=0; j++)

{

switch (xx[j])

{

case '<':

case '>': str[i++]=xx[j];

str[i++]=xx[j];

break;

case '/':а if (xx[j+1]=='/')

{

k++;

str[i++] = xx[j++];

str[i++] = xx[j];

Cat(str,&i,ITALIC);

}

else

str[i++] = xx[j];

break;

case '\"': if (n)

{

Cat(str,&i,BOLD);

str[i++] = xx[j];

}

else

{

str[i++] = xx[j];

Cat(str,&i,ITALIC);

}

n = !n; break;

default: str[i++] = xx[j];

}

}

if (k) Cat(str,&i,BOLD);

str[i]=0;

}

int Proc()

{

int i,j,n,k;

charа xx[120];

if (str[0]=='\t' && str[1]=='-') fprintf(fdo,"\n\n");

for (i=0; str[i]!=0; i++) xx[i]=str[i];

xx[i]=0;

for (i=j=n=0; xx[j]!=0; j++)

{

switch (xx[j])

{

case '\n':

case '\t':

case ' ': n++; if (n==1) str[i++]=' '; break;

case '-': if (!expand) str[i++]=xx[j]; break;

n=0;

if (xx[j+1]!=0 || xx[j-1]==' ')

Cat(str,&i,DEFIS);

else

str[i++]='-';

break;

case '\"':а if (!expand) str[i++]=xx[j]; break;

n=0;

if (sign)

Cat(str,&i,CLOSE);

else

Cat(str,&i,OPEN);

sign = !sign; break;

default: n=0; str[i++] = xx[j];

}

}

str[i]=0;

for (i--; i>=0 && str[i]==' '; i--) str[i]=0;

if (str[i]=='-' && str[i-1]!=' ')

{

str[i]=0;

fprintf(fdo,"%s",str);

}

else

fprintf(fdo,"%s%c",str,EOLN);

}

int Copy(ext,num,mode)

charа *ext;

int num;

int mode;

{

FILE *fd1;

int n;

sprintf(x,"%s%d.%s",in,num,ext);

puts(x);

if ((fd1=fopen(x,"w"))==NULL) return(0);

fprintf(fdo,"\n{ %s }\n\n",x);

if (mode==1)

{

sprintf(z,"//────────────────────────────────────────────── %s\n",x);

fprintf(fd1,"%s",z);

}

if ((mode & 1) && expand) ProcProg();

if (mode!=0) fprintf(fd1,"%s\n",str);

if (mode==0)

sprintf(img,"\n Рис.%s%d. %s",in,num,str+1);

while ((n=GetStr())!=-1)

{

NoLF();

if ((mode & 1) && expand)

{

аfprintf(fd1,"\n");

ProcProg();

}

if (n==2 || str[0]==CONTROL || mode==2 && n==1)

{

if (mode==0) fprintf(fd1,"%s\n",img);

fclose(fd1);

return(1);

}

if (n==1)

fprintf(fd1,"\n");

else

fprintf(fd1,"%s\n",str);

}

fclose(fd1);

return(0);

}

char A[]="АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧЩъЫЬЭЮЯ";

char B[]="абвгдежзийклмнопрстуфхцчшщъыьэюя";

charа Alpha(c)

char c;

{

int i;

for (i=0; A[i]!=0; i++) if (c==A[i]) return(B[i]);

return(0);

}

oid keywords()

{

FILE *fdi,*fdo;

int i,j,n;

charа cc,out[100];

sprintf(x,"%s0.txt",in);

if ((fdi=fopen(x,"r"))==NULL) return;

if ((fdo=fopen("keys.txt","a"))==NULL) return;

fseek(fdo,0L,2);

while ((cc=getc(fdi)) !=EOF)

{

if (Alpha(cc)==0) continue;

for (i=1,out[0]=cc; (cc=getc(fdi))!=EOF; i++)

{

if (cc ==' ' || (cc=Alpha(cc))!=0)

out[i]=cc;

elseа break;

}

out[i]=0;

if (i > 2) fprintf(fdo,"%s\t\t%s\n",out,in);

}

fclose(fdi);

fclose(fdo);

}

oid step()

{

int i,n,mode;

sprintf(x,"%s.",in);

if ((fdi=fopen(x,"r"))==NULL) return;

sprintf(x,"%s0.txt",in);

if ((fdo=fopen(x,"w"))==NULL) return;

c0num=cnum=inum=tnum=1;

nstr=0;

sign=0;

while((n=GetStr())!=-1)

{

NoLF();

if (n!=0)

fprintf(fdo,"\n\n");

else

{

mode=0;

if (str[0]==CONTROL) mode=1;

if (str[0]=='┌') mode=3;

if (str[0]=='╔') mode=3;

if (str[0]=='/' && str[1]=='/' && befor) mode=2;

if (str[0]=='#' && befor) mode=2;

for (i=0; str[i]!=0 && befor; i++)

{

if (str[i]==' ')а continue;

if (str[i]=='\t') continue;

if (str[i]>='a' && str[i]<='z') mode=4;

break;

}

switch(mode)

{

case 0: Proc();

break;

case 3: if (!Copy("TBL",tnum++,2)) return;

break;

case 2: if (!Copy("C",cnum++,1)) return;

break;

case 1: if (!Copy("TXT",inum++,0)) return;

break;

case 4: if (!Copy("C0",c0num++,3)) return;

break;

}

}

}

fclose(fdi);

fclose(fdo);

keywords();

}

oid main(int narg, char *argv[])

{

struct ffblk DIR;

int done,i;

expand=0;

if (narg < 2)

{

printf("bk.exe файл | * [+]\n* - все файлы\n+ - преобразование c-файлов\тип по умолчанию - .\n");

exit(0);

}

strcpy(in,argv[1]);

if (narg==3 && argv[2][0]=='+')а expand++;

if (in[0]!='*')

{

step();

}

else

{

for (done=findfirst("*.",&DIR,FA_DIREC); !done; done=findnext(&DIR))

{

if ((DIR.ff_attrib & FA_DIREC) ==0 && DIR.ff_name[0] !='.')

{

strcpy(in,DIR.ff_name);

for (i=0; in[i]!='.'; i++);

in[i]=0;

step();

}

}

}

}

Идентификатор BK1

Определением переменной BK1

Тип данных BK1

Индекс BK1

Инициализация BK1

Функция BK1

Заголовок функции BK1

Имя функции BK1

Результат функции BK1

Формальные параметры BK1

Локальные переменные BK1

Глобальные переменные BK1

Вызов функции BK1

Фактические параметры BK1

Инкремент BK1

Декремент BK1

Логическая операция ИЛИ BK1

Логическая операция НЕ BK1

Логическая операция И BK1

Оператор BK1

Ограничитель BK1

Составной оператор BK1

Блок BK1

Тело цикл BK1

Шаг цикл BK1

Заголовочный файл BK1

Переменная BK21

Тип данных BK21

Определение переменной BK21

Базовый тип данных BK21

Машинное слово BK21

Бит BK21

Разрядность BK21

Байт BK21

Стандартное машинное слово BK21

Двойное слово BK21

Тетрад BK21

Дополнительный код BK21

Перечислимый тип BK21

Код символ BK21

Индекс BK21

Направление выполнения операций BK22

Приведение типов BK22

Логическая операция Или BK22

Логическая операция Не BK22

дресное выражение BK22

Пустой оператор BK23

Составной оператор BK23

Блок BK23

Условие продолжения BK23

Заголовок функции BK24

Тело функции BK24

Определение функции BK24

Фактические параметры BK24

Локальные переменные BK24

втоматические переменные BK24

Передача параметров по значению BK24

Глобальные переменные BK24

Внешние переменные BK24

Объявление функции BK24

Прототип BK24

Расширение имени файла BK25

Макроопределение BK25

Макроподстановк BK25

Макропроцессор BK25

Макросредств BK25

Лексика BK25

Идентификатор BK25

Синтаксис BK25

Семантика BK25

Генерация кода BK25

Объектный модуль BK25

Модульное программирование BK25

Библиотека объектных модулей BK25

Компоновка BK25

Программирование без goto BK31

Итерационный цикл BK33

Метод последовательных приближений BK33

Строк BK34

Строковая констант BK34

Машинно-ориентированные операции BK35

Операции над машинными словами BK35

Поразрядные операции BK35

Поразрядная операция ИЛИ BK35

Поразрядная операция ИСКЛЮЧАЮЩЕЕ ИЛИ BK35

Поразрядная операция ИНВЕРСИИ BK35

Операция СДВИГА ВПРАВО BK35

Операция СДВИГА ВЛЕВО BK35

Маск BK35

Установка битов BK35

Выделение битов BK35

Маскирование BK35

Проверка битов BK35

Очистка битов BK35

Неравнозначность BK35

Сложение по модулю 2 BK35

Инверсия битов BK35

Логический сдвиг BK35

рифметический сдвиг BK35

Ключ BK37

Последовательный поиск BK37

Линейный поиск BK37

Двоичный поиск BK37

Сортировка подсчетом BK37

Сортировка вставками BK37

Сортировка выбором BK37

Обменная сортировк BK37

Сортировка слиянием BK37

Сортировка методом пузырьк BK37

Шейкер-сортировка BK37

Быстрая сортировк BK37

Медиан BK37

Поразрядная сортировка BK37

Простая вставк BK37

Вставка погружением BK37

Сортировка Шелл BK37

Простое слияние BK37

Поразрядная распределяющая сортировка BK37

Оперативная память BK41

дресом памяти BK41

Прямая адресация BK41

Косвенная адресация BK41

Указатель BK41

Назначение казателя BK41

Указуемая переменная BK41

Косвенное обращение по казателю BK41

Тип казателя BK41

дресная арифметик BK41

Передача параметров по значению BK41

Передача параметров по ссылке BK41

Сравнение казателей на равенство BK41

Преобразование типа казателя BK41

Указатель на пустой тип void* BK41

Сравнение казателей на больше-меньше BK41

Разность значений казателей BK41

Указатель на строку BK41

Строковая констант BK41

Элемент структуры BK42

Объект BK42

Производный тип данных BK43

Выделение составляющего типа данных BK43

Преобразование типа казателя BK44

Регистровая переменная BK46

Динамические переменные BK51

Динамическая память BK51

Виртуальный массив BK52

Дескриптор файл BK57

Двоичный файл произвольного доступа BK57

Текущая позиция в файле BK57

Смещение в файле BK57

дрес в файле BK57

Файловый казатель BK57

Объект BK61

Метод BK61

Класс BK61

Наследование BK61

Полиморфизм BK61

Передача параметра по ссылке BK62

Базовый класс BK64

Производный класс BK64

Виртуальная функция BK64

бстрактным базовый класс BK64

Приложение 1. Операции и приоритеты

─────────────────────────────────────

┌─────┬─────────────────────────────────────────┬───────┐

│Прио─│ Операции │Направ-│

│ритет│ │ление │

├─────┼─────────────────────────────────────────┼───────┤

1а │ () (вызов функции), [], ->, "."а │ ────> │

2а │ !, ~, +, - (унарные), ++, --, *, (тип), │ <──── │

│ │ sizeof, (new,delete - Си++) │ │

3а │.*, ->* - Си++ │ ────> │

4а │ *, /, % (бинарные) │ ────> │

5а │ +, - (бинарные) │ ────> │

6а │ <<, >> │ ────> │

7а │ <, <=, =>, > │ ────> │

8а │ ==, != │ ────> │

9а │ & (поразрядное) │ ────> │

│ 10а │ ^ │ ────> │

│ 11а │ | (поразрядное) │ ────> │

│ 12а │ && (логическое) │ ────> │

│ 13а │ || (логическое) │ ────> │

│ 14а │ ?: (условная) │ <──── │

│ 15а │ =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, │ <──── │

│ │ >>= │ │

│ 16а │ "," (запятая) │ ────> │

└─────┴─────────────────────────────────────────┴───────┘

Приложение 2. Интерфейс командной строки main

─────────────────────────────────────────────

// Вывод компонент командной строки, переданной в main

// Командная строка разбивается н части, каждая

// компонента оформляется отдельной строкой

#include <stdio.h>

// ┌─────────────── количество компонент

// а ┌── массив казателей на компоненты

main(int narg, char *argv[])

{ for (int i=0; i<narg; i++) puts(argv[i]); }

>test.exe 100

┌──────────┬─────┬─────┬─────┐

│test.exe\0│\0│100\0│\0│

argv[] └│─────────┴│────┴│────┴│────┘

┌───────┐0 │ │ │ │

│ ───────────┘ │ │ │

├───────┤1 │ │ │

│ ──────────────────────┘ │ │

├───────┤2 │ │

│ ────────────────────────────┘ │

├───────┤3 │

│ ──────────────────────────────────┘

└───────┘

Приложение 3. Стандартная библиотека ввода-вывода

─────────────────────────────────────────────────

1. Заголовочный файл библиотеки

┌

#include <stdio.h>

2. Определение символа "конец файла" и NULL-указатель

┌

#define NULLа 0

#define EOF -1

3. Определение дескриптора открытого файла в stdio.h

┌

typedef struct

{

...

unsigned flags; // Флаги состояния ───────────────┐

char fd; // Номер открытого файла (handle) │

unsigned char hold; // Возвращенный символ │

short bsize; // Размер внутреннего буфера │

unsigned char *buffer,*curp; │

... // и его казатели │

} FILE; ──── Определение типа "Дескриптор файла" │

(описатель потока) │

┌─── Флаги состояния - биты, определенные через define ───┘

│

_F_RDWR - открыт для чтения и записи

_F_READ - открыт только для чтения

_F_WRIT - открыт только для записи

_F_BUFа - имеет динамически выделенный буфер данных

_F_LBUF - построчная буферизация

_F_ERRа - обнаружена ошибка при выполнении операции

_F_EOFа - обнаружен конец файла при выполнении операции

_F_BINа - двоичный (прозрачный) режим

_F_IN - выполняется операция чтения

_F_OUTа - выполняется операция записи

_F_TERM - файл открыт на терминале

4. Проверка флагов состояния в дескрипторе файла

┌

FILE *fd;

...

if (fd->flags & _F_BIN)...

5. Макроопределения и функции проверки флагов состояния

┌───────────────────────────────────────────────────────┐

│ #define ferror(pf) ((pf)->flags & _F_ERR) │

│ #define feof(pf) ((pf)->flags & _F_EOF) │

│ #define fileno(pf) ((pf)->fd) │

│ void clearerr(FILE *pf) - сбросить _F_EER и _F_EOF │

└───────────────────────────────────────────────────────┘

6. Стандартные потоки (файлы) ввода-вывода

В библиотеке имеются внешние переменные-указатели

на дескрипторы файлов - стандартных стройств ввода-вывода.

┌

extern FILEа *stdin, *stdout, *stderr, *stdaux, *stdprn;

стандартный ввод ──┘ │ │ │ │

стандартный вывод ─────────┘ │ │ │

регистрация ошибок ─────────────────┘ │ │

дополнительное стройство ───────────────────┘ │

устройство печати ────────────────────────────────────┘

Эти файлы открываются библиотекой автоматическиа переда вы-

полнением mainа и по молчаниюа назначаются н терминал

(stdin - клавиатура, stdout,stderr - экран), последователь-

ный порт (stdaux) и принтер (stdprn). stdin и stdoutа могут

быть переназначены в командой строке запуск программы на

любые другие файлы

┌

>test.exeа <a.dat >c:\\b.dat

│ └─────── файл stdout

└───────────────── файл stdin

Все функции посимвольного, построчного иа форматированного

ввода-вывода имеют варианты для файлов стандартного ввода-

вывода.

7. Функции открытия-закрытия файла

┌───────────────────────────────────────────────────────┐

│ режим работы с файлом ────────┐ │

│ имя файла ────────┐ │ │

│ │ │ │

│ FILE *fopen(char *name, char *mode) - открыть файл │

│ │

└─── казатель на дескриптор файла или NULL │

│ │

│ int fclose(FILE *fd) - закрыть файл │

│ │

└─── 0 или EOF (ошибка) │

│ │

│ int fcloseall(void) - закрыть все │

│ │

└─── число закрытых файлов или EOF │

│ │

│ FILE *freopen(char *name, char *mode, FILE *fd) │

- закрыть и открыть повторно │

│ │

│ FILE *tmpfile(void) - создать и открыть временный │

│ файл с никальным именем │

└───────────────────────────────────────────────────────┘

Символы строки режима работы с файлом

┌

Создание нового при отсутствии файла ─────────────────┐

Начальное значение казателя в файле ─────────┐ │

сечение при закрытии ────────────┐ а │

Запись ───────────────┐ а а │

Чтение ────────┐ а а │

┌────┬──────────────────────────────┬───┬───┬───┬───┬───┐

│ rа │ чтениe │ + │ - │ - │ 0 │ - │

│ wа │ запись │ - │ + │ + │ 0 │ + │

│ aа │ запись (дополнение) │ - │ + │ + │EOF│ + │

│ r+ │ чтение и запись (обновление) │ + │ + │ - │ 0 │ - │

│ w+ │ чтение и запись (обновление) │ + │ + │ + │ 0 │ + │

│ a+ │ чтение и запись (обновление) │ + │ + │ - │EOF│ + │

├────┼───────────────────┬──────────┴───┴───┴───┴───┴───┤

│ bа │ двоичные данные │ после r,w,a,r+,w+,a+ │

│ tа │ текст │..... │

└────┴───────────────────┴──────────────────────────────┘

8. Функции посимвольного ввода-вывода

┌──────────────────────────────── Посимвольный ввод ────┐ │

│ int fgetc(FILE *fd) - явно казанный файл │

│ int getc(FILE *fd) │

│ int fgetchar(void) - стандартный ввод │

│ inc getchar(void) │

└─── код символа или EOF │

│ int ungetc(int ch, FILE *fd) - возвратить символ │

│ в файл (повторно читается) │

└───────────────────────────────────────────────────────┘

┌─────────────────────────────── Посимвольный вывод ────┐ │

│ int fputc(int ch,FILE *fd)а - явно казанный файл │

│ int putc(int ch, FILE *fd) │

│ int fputchar(int ch)а - стандартный вывод │

│ inc putchar(int ch) │

└─── код символа или EOF │

└───────────────────────────────────────────────────────┘

Примечание: хотя функции и выполняют ввода отдельного сим-

вола, обычно он осуществляется ва стандартнома режиме по-

строчного ввода, поддерживаемого операционной системой

("эхо"-печать вводимыха символов, редактирование строки).

Поэтому ва библиотеку строк попадаета только полностью,

после ввода символа "конец строки", жеа затема выдается

в программу посимвольно. Для немедленного реагирования про-

граммы на введенный символ или отказ от эхо-печати необхо-

димо пользоваться нестандартными библиотеками (например,

conio.h)

9. Функции построчного ввода-вывода

┌───────────────────────────────────── Построчный ввод ─┐

│ char *gets(char *str) - стандартный ввод │

│ char *fgets(char *str, int n, FILE *fd) │

└── str или NULL(ошибка)а │ - явно казанный файл │

│ максимальная длина строки ─┘ │

└───────────────────────────────────────────────────────┘

┌──────────────────────────────────── Построчный вывод ─┐

│ char *puts(char *str) - стандартный ввод │

│ char *fputs(char *str, FILE *fd) │

└── str или NULL(ошибка)а - явно казанный файл │

└───────────────────────────────────────────────────────┘

Примечание: при вводе-выводе все строки функции используют

в качестве стандартного ограничителя строки ва памятиа сим-

вола '\0'. Символа конц строки '\n'а уничтожается при

стандартном вводе-выводе (gets - не записываета ва строку,

puts автоматически добавляет при выводе)а и сохраняется

в строке при вводе-выводе из явно казанного файл (fgets

- записывает в строку, fputs - выводит имеющийся ва строке

(сама не добавляет)).

10. Функции форматированного ввода-вывода

┌────────────────────────────── Форматированный вывод ──┐

│ int printf(char *format,...) │

│ - стандартный вывод │

│ int fprintf(FILE *fd, char *format,...) │

│ - явно казанный файл │

│ int sprintf(char *str, char *format,...) │

│ - строка в памяти │

└─── число выведенных байтов или EOF │

└───────────────────────────────────────────────────────┘

┌────────────────────────────── Форматированный ввод ───┐

│ int scanf(char *format,...) │

│ - стандартный ввод │

│ int fscanf(FILE *fd, char *format,...) │

│ - явно казанный файл │

│ int sscanf(char *str, char *format,...) │

│ - строка в памяти │

└─── число фактических параметров, для которых │

│ введены значения, или EOF │

└───────────────────────────────────────────────────────┘

Форматная строка определяет количество и атипы фактических

параметров из переменного списка. Последовательность сим-

волов, идущая за "%" (спецификация формата), определяет тип

и формат ввода-вывод очередного фактического параметра.

При этом в функцияха форматированного вывод всеа символы

форматной строки выводятся в выходной файла з исключением

спецификаций формата, которые заменяются значениями

соответствующих фактических параметров. Ва функцияха форма-

тированного вывода тип параметра должен совпадать са задан-

ным в спецификации, ва функцияха форматного ввод -а быть

указателем на этот тип (то есть должена передаваться адрес

переменной, не ее значение).

┌

┌─ форматная строка ───┐ ┌──────┐фактические

printf("....%***...%***...%***",p1,p2,p3); параметры

│ │ └─>>─│──│──┘ переменного

│ └───>>──────│──┘ списка

└─────>>───────────┘

Спецификация формата ввода-вывода фактического параметра

([] обозначают необязательную часть)

┌

% [флаги][ширина][.точность][модификатор] тип ────────────┐

│ │ │ ├─ "F" far-указатель │

│ │ │ ├─ "N" near-указатель │

│ │ │ ├─ "h" параметр типа short │

│ │ │ └─ "l" параметр типа long │

│ │ │ или double (для scanf)│

│ │ ├─ "0" без дробной части │

│ │ ├─а nа не более n знаков после точки │

│ │ └─а *а задается следующим фактическима │

│ │ параметром функции │

│ ├─ n минимальная ширина поля n (незаполненные │

│ │ позиции - пробелы) │

│ ├─ 0nа то же, незаполненные позиции - нули │

└─ "*" задается следующим фактическим │

│ параметром функции │

├─ "-" выравнивание по левому краю поля │

│ (по молчанию - по правому) │

├─ "+" выводится знак числа ("+" или "-") │

├─ " " выводится пробел перед положительным числом │

└─ "#" выводится идентификатор системы счисления │

("0" -восьмеричная, "0x" -шестнадцатеричная, │

"." -для float) char "c" ────────┤

адесятичное int "d" ────────┤

то же "i" ────────┤

адесятичное unsignedа "u" ────────┤

восьмеричное unsignedа "o" ────────┤

шестнадцатеричное unsignedа "x" ────────┤

со строчными и прописными А..Fа "X" ────────┤

float в формате ***.*** "f" ────────┤

float в формате *.***e*** "e" ────────┤

float в формате *.***E*** "E" ────────┤

в зависимости float ("e" или "f") "g" ────────┤

от точности float ("E" или "F") "G" ────────┤

char * "s" ────────┘

(ввод по точности или до \n, вывод по

точности, до \n или до \0)

10. Функции позиционирования и блочного ввода-вывода

┌──────────────────────────────────── Позиционирование ───┐

│ void rewind(FILE *fd) - становить казатель │

│ в файле на начало │

│ long ftell(FILE *fd) - получить значение │

│ казателя в файле │

└── номер байта (позиция) или -1L │

│ intа fseek(FILE *fd, long pos, int mode) - становить а │

│ │ │ казатель в файле │

а номер байта (позиция)─┘ │ на заданную позицию│

│ способ позиционирования ────────┘ │

│ SEEK_SET(0) - от начал │

│ SEEK_CUR(1) - от текущей позиции │

│ SEEK_END(2) - от конца файл │

└──── 0 или EOF (ошибка) │

│ int fgetpos(FILE *fd, long *ppos) - аналоги ftell,fseek │

│ int fsetpos(FILE *fd, long *ppos) с казателем, раз-а │

│ мещенным в памяти │

└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────── Блочный ввод-вывод ──┐

│ intа fread(void *buff, int size, int nrec, FILE *fd) │

│ int fwrite(void *buff, int size, int nrec, FILE *fd) │

│ │ а а └── число записей │

│ │ └─────────── размер записи │

│ └─────────────────── адрес памяти │

└─────────── число введенных(выведенных) записейа │

└─────────────────────────────────────────────────────────┘

Приложение 4. Директивы препроцессора

─────────────────────────────────────

Подстановка строки текста вместо идентификатора.

┌───────────────────────────────────────────────────────┐

│ #define идентификатора строка_текст │

└───────────────────────────────────────────────────────┘

#define SIZEа 100

#define ErrStr "Ошибка вышла, вот..."

Макроопределение:а подстановк вместо идентификатор с

набором фактических параметрова строкиа текста, ва которой

формальные параметры заменяются на фактические.

┌───────────────────────────────────────────────────────┐

│ #define идентификатор(параметры) строка_с_параметрами │

└───────────────────────────────────────────────────────┘

#define FOR(i,n) for(i=0; i<n; i++)

...

FOR(k,20) A[k]=0; // for(k=0; k<20; k++) A[k]=0;

FOR(j,m+2) {...}а // for(j=0; j<m+2;а j++) {...}

Включение текстового файла из системного или явно задан-

ного каталога в текст программы.

┌───────────────────────────────────────────────────────┐

│ #include <имя_файла> │

│ #include "имя_файла" │

└───────────────────────────────────────────────────────┘

Идентификаторы, предопределенные в трансляторе директивой

define

┌───────────────┬───────────────────────────────────────┐

│ Идетификатор │ Значение │

├───────────────┼───────────────────────────────────────┤

│ __LINE__а │ Десятичная константа, номер строки │

│ │ исходного текста программы │

│ __FILE__а │ Строка, имя транслируемого файла │

│ __DATE__а │ Строка, текущая дат │

│ __TIME__а │ Строка, текущее время │

│ __STDC__а │ Значение 1, версия Си соответствует │

│ │ ANSI-стандарту, иначе - не определен │

│ __cplusplus │ Значение 1, программа на Си++ (.cpp) │

│ │ иначе - не определен │

└───────────────────────────────────────────────────────┘

Отмена директивы define

┌───────────────────────────────────────────────────────┐

│ #undef идентификатор │

└───────────────────────────────────────────────────────┘

Условная трансляция. Ва текста программы включается ее

часть после директивы if или после elseа ва зависимости от

того, определен или нета проверяемыйа идентификатора дирек-

тивой define

┌──────────────────────────┬────────────────────────────┐

│ Идентификатор определена │ Идентификатор не определен │

├──────────────────────────┴────────────────────────────┤

#ifdef идентификатор #ifndef идентификатор │

... текст_1...... текст_1... │

#else #else │

... текст_2...... тескт_2... │

#endif #endif │

└───────────────────────────────────────────────────────┘а

(ветка else может отсутствовать)

Условная трансляция. Ва текста программы включается ее

часть после директивы if или после elseа ва зависимости от

того, истинно (не равно 0) или ложно (равно 0)а константное

выражение. Директива elif - сочетание else и if.

┌───────────────────────┐ ┌───────────────────────┐

#if выражение │ │ #if выражение │

... текст_1... │ │... текст_1... │

#else │ │ #elif выражение │

... текст_2... │ │... текст_2... │

#endif │ │ #elif выражение │

└───────────────────────┘ │... тескт_3... │

│ #else │

│ ... текст_4 │

│ #endif │

└───────────────────────┘

Присваивание текущего номера строки и имени файла

┌───────────────────────────────────────────────────────┐

│ #line константа "имя_файла" │

└───────────────────────────────────────────────────────┘

Сообщение транслятора об ошибке

┌───────────────────────────────────────────────────────┐

│ #error текст_сообщения │

└───────────────────────────────────────────────────────┘

Приложение 5. Анахронизмы языка Си

──────────────────────────────────

Большинство анахронизмов наследовано из "библей-

ского" Си, наприсанного для "ленивых" программистов, кото-

рым недосуг делать некоторые определения, поэтому ониа вы-

полняются по молчанию.

1. Результат функции, у которой в заголовке не казан тип,

по молчанию считается int (но не void).

┌ Эквивалентно

myfun() {...} int myfun() {...}

2. Имеется старевшийа альтарнативныйа синтаксиса заголовка

функции и ее объявления, для которого транслятор не выпол-

няет проверку соответствия формальных и фактическиха пара-

метров.

┌

extern int sum();а // Объявление внешней функции

int sum(); // Предварительное объявление

... // функции, следующей по тексту

int sum(c,n) // Заголовок определения функции

int c[],n; // Oпределение типов формальных

{... } // параметров

В скобках казаны имена параметров, определение иха типов

дается отдельными строками в произвольном порядке с исполь-

зованиема стандартного способ определения переменных.

Объявление внешней функции или предварительное объявление

функции не содержат списка формальных параметров.

3. Если производится вызов не известнойа (не определенной

ранее и не объявленной функции), то он считается внешней

функцией с результатом типа int и объявленной беза контроля

соотвествия параметров, то есть

┌

extern int What();

Приложение 6. Библиотеки стандартных функций

────────────────────────────────────────────

1. Функции работы с символами (Заголовочный файл - ctype.h)

───────────────────────────────────────────────────────────

Следующиеа функции проверяюта предъявляемый в качестве

параметр символа н соответствиеа тойа или инойа группе

и возвращают, соответственно, логическийа результата 1/0.

int isalnum(int c);

// латинская буква или цифры (A-Z,a-z,0-9)

int isalpha(int c);

// латинская буква (A-Z,a-z)

int isascii(int c);

// символ ASCII - код в диапазоне 0..127

int iscntrl(int c);

// кода управляющего (неотображаемого)а символ ASCIIа -

// 0x00..0x1F или 0x7F.

int isdigit(int c);

// десятичная цифра (0-9)

int isgraph(int c);

// видимый (отображаемый) символ ASCII (0x21-0x7E)

int ispunct(int c);

// символ - разделитель (iscntrl или isspace)

int isspace(int c);

// символ - эквивалент пробелa: пробел (0x20), горизонталь-

// ная табуляция, перевод строки, вертикальная табуляция,

// перевод страницы, возврат каретки (0x09-0x0D)

int isupper(int c);

// символ верхнего регистра клавиатуры

int isxdigit(int c);

// символ шестнадцатеричной цифры (0-9, A-F, a-f)

int toascii(int c);

// преобразование целого ва символа код ASCIIа -а очистка

// старших битов, начиная с 7-го

int tolower(int c);

// преобразованиеа символ -а латинскойа буквы верхнего

// регистра к нижнему (большой -а ва маленькую). Остальные

// символы не меняются

int toupper(int c);

// преобразование латинской буквы нижнего регистра к верхнему

2. Функции для работы со строками (Заголовочные файлы

string.h, stdlib.h)

─────────────────────────────────────────────────────

double atof(char *s);

int atoi(char *s);

longа atol(char *s);

// преобразование строки в вещественное, целоеа и длинное

// целое

charа *itoa(intа v, char *s, int n);

charа *ltoa(long v, char *s, int n);

charа *ultoa(unsigned long v, char *str, int n);

// преобразование целого, длинного целого со знакома и без

// знака v в строку str в системе счисления по основанию n.

// Возвращает копию значения str

charа *strcat(char *dst, char *src);

// Присоединение строки src к строке dst. Возвращаета копию

// значения dst

charа *strchr(char *str, int c);

// Поиск первого вхождения символа c в строку str. Возвращает

// казатель на найденный символ или NULL

int strcmp(char *s1, char *s2);

// Сравнение строк s1 и s2 по значениям кодов символов (без

// знака). Результат:

// -1 -а s1 < s2

// 0а -а s1 = s2

// 1а -а s1 > s2

charа *strcpy(char *dst, char *src);

// Копирование строки src в строку dst. Возвращаета копию

// значения dst

int strcspn(char *str, char *slist);

// Количество символов в строке str (подряд от начала), не

// совпадающих с символами в строке slist

charа *strdup(char *str);

// Копия строки str в динамической памяти

unsigned strlen(char *str);

// Длина строки str

charа *strlwr(char *str);

// Преобразованиеа ва строке strа латинскиха буква нижнего

// регистра в буквы верхнего ("маленьких - в большие")

charа *strncat(char *dst, char *src, int n);

// Присоединениеа nа символова строкиа srcа к строкеа dst.

// Возвращает копию значения dst

int strncmp(char *s1, char *s2, int n);

// Сравнение строк s1 и s2 по значениям кодов символов (без

// знака). Сравнение производится для nа первыха символов.

// Результат аналогичен strcmp

charа *strncpy(char *dst, char *src, int n);

// Копирование n символов из строки src в строку dst

int strnicmp(char *s1, char *s2, int n);

// То же, что и strncmp, но без различия верхнего и нижнего

// регистра для латинских букв

charа *strnset(char *str, int c, int n);

// Замена n первых символов в строке str на символ c

charа *strpbrk(char *str, char *slist);

// Поиск первого символа в str, входящего ва строкуа slist.

// Возвращает казатель на найденный символ

charа *strrchr(char *str, int c);

// Поиск последнего вхождения символ cа ва строку str.

// Возвращает казатель на найденный символ

charа *strset(char *str, int c);

// Заполнение строки str символом c

int strspn(char *str, char *slist);

// Количество символов в строке strа (подряда ота начала),

// совпадающих с символами в строке slist

charа *strstr(char *str, char *ss);

// Поиск вхождения подстроки ss ва строкеа str. Возвращает

// казатель на начало найденного фрагмента в str или NULL

double strtod(char *str, char **endptr);

longа strtol(char *str, char **endptr, int n);

// Чтение из строки strа вещественного числ илиа длиного

// целого в системе счисления c основаниема n. endptrа -

// адрес казателя, гдеа сохраняется казатель н символ

// в str, на котором завершилось чтение строки

charа *strtok(char *str, char *s);

// Выделение слова в строке str. Слово - любая последова-

// тельность символов, кроме символов-разделителей, пере-

// численных в строке s.

// При первом вызове возвращает казатель на первый символ

// строки. При последующих вызовах с str=NULL возвращает

// казатель на очередное слово

charа *strupr(char *str);

// Замена в строке str латинмких букв нижнего регистра на

// верхний ("маленьких на большие")

3. Функции для работы с терминалом в текстовом режиме

(Заголовочный файл - conio.h)

───────────────────────────────────────────────────────────

oidа clreol(void);

// Очистка строки от текущей позиции курсора до конца

otdа clrscr(void);

// Очистка экрана

charа *cgets(char *str);

// Чтение строки с терминала в str

// str[0] - максимальная длина строки

// str[1] - действительная длина строки

// str[2]... и далее - символы строки

// Возвращает &str[2]

int cprintf(char *fmt,...);

// Аналогична функции форматированного вывода printf, но

// работает по отношению к окну, созданному функцией window

int cputs(char *str);

// Вывод строки на терминал

int cscanf(char *fmp,...);

// Аналогична функции форматированного ввода scanf

oidа delline(void);

// даление строки, в которой находится курсор

oidа gotoxy(int x, int y);

// становка курсора в позицию с координатами (x,y).

// Координаты курсора отсчитываются от левого верхнего

// гла, начиная с 1

oidа highvideo(void);

// станавка режим повышенной яркости выводимых символов

int movetext(int x0,int y0,int x1,int y1,int x, int y);

// Перенос содержимого текстового окна с координатами

// (x0,y0)(x1,y1) в область экрана с координатами левого

// верхнего гла (x,y)

oidа normvideo(void);

// становка режима обычной яркости выводимых символов

oid textattr(int attr);

// становка атрибутов (цвет символов и фона) выводимых

// символов

oidа textbackground(int c);

// становка цвета фона выводимых символов и очищаемого

// экрана

oidа textcolor(int c);

// становка цвета выводимых символов

oidа textmode(int c);

// становка текстового режима

int wherex(void);

int wherey(void);

// Значение координаты курсора

oidа window(int x0,int y0, int x1, int y1);

// Создание текстового окна с координатами (x0,y0)(x1,y1)

4. Математические функции (Заголовочный файл - math.h)

──────────────────────────────────────────────────────

int abs(int n); // Абсолютное значение n

double acos(double x); // Функция арккосинуса

double asin(double x); // Функция арксинуса

double atan(double x); // Функция арктагенса

double atan2(double y,double x);

// Функция арккосинуса y/x

double cos(double x); // Функция косинуса (x - в радианах)

double cosh(double x); // Функция гиперболического косинуса

double exp(double x); // Экспоненциальная функция

double fabs(double x); // Абсолютное значение x

double floor(double x);// Целая часть x

double fmod(double y,double x);

// Остаток от деления y на x

double hypot(double y,double x);

// Гипотенуза катетов y,x

longа labs(dong n); // Абсолютное значение n

double ldexp(double x, int n); n

// Значение x * 2

double log(double x); // Функция натурального логарифма

double log10(double x);// Функция десятичного логарифма

double poly(double x, int n, double c[]);

// Степенной полином

// n n-1

// y = c[n]*xа + c[n-1]*x +... + c[1]*x + c[0]

double pow(double y,double x);

// Функция y в степени x

double pow10(int n); // Функция 10 в степени n

double sin(double x); // Функция синуса

double sinh(double x); // Функция гиперболического синуса

double sqrt(double x); // Функция квадратного корня

double tan(double x); // Функция тангенса

double tanh(double x); // Функция гиперболического тангенса

5. правление памятью и другие специальные функции

──────────────────────────────────────────────────

Приложение 7. Таблицы кодов символов ASCII

──────────────────────────────────────────

┌───┬───────────┬───────────┬───┬───┬───┬───┬───┬───┐

│0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │

├───┼───────────┼───────────┼───┼───┼───┼───┼───┼───┤

│ 0 │nul │dle │' '│ 0 │ @ │ P │ ` │ p │

│ 1 │soh │dc1 │ ! │ 1 │ A │ Q │ a │ q │

│ 2 │stx │dc2 │ " │ 2 │ B │ R │ b │ r │

│ 3 │etx │dc3 │ # │ 3 │ C │ S │ c │ s │

│ 4 │eot │dc4 │ $ │ 4 │ D │ T │ d │ t │

│ 5 │enq │nak │ % │ 5 │ E │ U │ e │ u │

│ 6 │ack │syn │ & │ 6 │ F │ V │ f │ v │

│ 7 │bel │etb │ ' │ 7 │ G │ W │ g │ w │

│ 8 │bs │can │ ( │ 8 │ H │ X │ h │ x │

│ 9 │ht │em │ ) │ 9 │ I │ Y │ i │ y │

│ A │lf │sub │ * │ : │ J │ Z │ j │ z │

│ B │vt │esc │ + │ ; │ K │ [ │ k │ { │

│ C │ff │fs │, │ < │ L │ \ │ l │ | │

│ D │cr │gs │ - │ = │ M │ ] │ m │ } │

│ E │so │rs │. │ > │ N │ ^ │ n │ ~ │

│ F │si │us │ / │ ? │ O │ _ │ o │del│

└───┴───────────┴───────────┴───┴───┴───┴───┴───┴───┘

Коды символов из первых двуха колонока вводятся при одно-

временном нажатииа клавиши Ctrlа иа символа, находящегося

двумя колонками правее (например, soh - Ctrl+A).

Кодовая таблица 866 - MS DOS

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐

│ 8 │ 9 │ A │ B │ C │ D │ E │ F │

├───┼───┼───┼───┼───┼───┼───┼───┼───┤

│ 0 │ А ││ а │ └ │ ╨ │ р а │

│ 1 │ Б │ С │ б │ ┴ │ ╤ │ с а │

│ 2 │ В │ Т │ в │ ┬ │ ╥ │ т а │

│ 3 │ Г │ У │ г │ │ │ ├ │ у а │

│ 4 │ Д │ Ф │ д │ ┤ │ ─ │ ф а │

│ 5 │ Е │ Х │ е │ ╡ │ ┼ │ х а │

│ 6 │ Ж │ - │ ж │ ╞ │ ц │

│ 7 │ З │ - │ з │ ╟ │ ╫ │ ч а │

│ 8 │ И │ Ш │ и │ ╚ │ ╪ │ ш а │

│ 9 │ Й │ Щ │ й │ ╣ │ ╔ │ ┘ │ щ │

│ A │ К │ ъ │ к │ ║ │ ╩ │ ┌ │ ъ │

│ B │ Л │ Ы │ л │ ╗ │ ╦ │ ы а │

│ C │ М │ Ь │ м │ ╝ │ ╠ │ ь а │

│ D │ Н │ Э │ н │ ═ │ э │

│ E │ О │ Ю │ о │ ╬ │ ю │

│ F │ П │ Я │ п │ ┐ │ ╧ │ я а │

└───┴───┴───┴───┴───┴───┴───┴───┴───┘

Кодовая таблица 1251 - MS Windows

┌───┬───┬───┬───┬───┬───┬───┬───┬───┐

│ 8 │ 9 │ A │ B │ C │ D │ E │ F │

├───┼───┼───┼───┼───┼───┼───┼───┼───┤

│ 0 а а а │ А ││ │ р │

│ 1 а а а │ Б │ С │ б │ с │

│ 2 а а а │ В │ Т │ в │ т │

│ 3 а а а │ Г │ У │ г │ у │

│ 4 а а а │ Д │ Ф │ д │ ф │

│ 5 а │ Е │ Х │ е │ х │

│ 6 а а а │ Ж │ - │ ж │ ц │

│ 7 а а а │ З │ - │ з │ ч │

│ 8 а а а │ И │ Ш │ и │ ш │

│ 9 а а а │ Й │ Щ │ й │ щ │

│ A а а а │ К │ ъ │ к │ ъ │

│ B а а а │ Л │ Ы │ л │ ы │

│ C а а а │ М │ Ь │ м │ ь │

│ D а а а │ Н │ Э │ н │ э │

│ E а а а │ О │ Ю │ о │ ю │

│ F а а а │ П │ Я │ п │ я │

└───┴───┴───┴───┴───┴───┴───┴───┴───┘

Приложение 8. Классы потоков ввода-вывода на Си++

─────────────────────────────────────────────────

Классы потокова ввода-вывод являются объектно-ориенти-

рованным эквивалентом стандартнойа библиотекиа ввода-вывода

(stdio).

1. Классы потокового ввода-вывода

ios - базовый потоковый класс

streambuf - буферизация потоков

istream - потоки ввода

ostream - потоки вывода

iostream - двунаправленные потоки

iostream_withassign

- поток с переопределенной операцией

присваивания

istrstreamа - строковые потоки ввода

ostrstreamа - строковые потоки вывода

strstream - двунаправлеые строковые потоки

ifstream - файловые потоки ввода

ofstream - файловые потоки вывода

fstream - двунаправленные файловые потоки

Стандартные потоки (istream,ostream,iostream) - для работы

с терминалом.

Строковые потоки (istrstream, ostrstream, strstream) -

для ввода-вывода из строковых буферов, размещенных в

памяти.

Файловые потоки (ifstream, ofstream, fstream) - для работы

с файлами.

2. Заголовочные файлы.

#include <iostream.h> // Стандартные потоки ввода-вывода:

// ios,istream,ostream,iostream

#include <fstream.h> // Файловые потоки ввода-вывода:

// ifstream,ofstream,fstream

#include <iomanip.h> // Манипуляторы

#include <strstream.h>а // Резидентные потоки ввода-вывода:

// istrstream,ostrstream,strstream

3. Предопределенные объекты-потоки.

Следующие потоки заранее определены и открыты в программе

перед вызовом функции main:

extern istream cin;а // Стандартный поток ввода

// с клавиатуры

extern ostream cout; // Стандартный поток вyвода

// на экран

extern ostream cerr; // Стандартный поток вывода

// сообщений об ошибках

// (экран)

extern ostream cerr; // Стандартный буферизованный поток

// вывода сообщений об ошибках

// (экран)

4. Переопределенные операции чтения-записи для базовых

типов данных

В потоках переопределены операции >> (ввод)а иа <<а (вывод)

для базовых и некоторыха другиха типова данных. Ввод-вывод

осуществляется са преобразованиема внутренней (двоичной)

формы представления во внешнюю (символьную).

ostream &operator<<(char);

ostream &operator<<(int);

ostream &operator<<(long);

...

ostream &operator<<(char*);

...

istream &operator>>(char&);

istream &operator>>(int&);

istream &operator>>(long&);

...

Данное определение позволяет использовать цепочки операций

int n;

double d;

cout << "n=" << n << " d=" << d << "\n";

cinа >> n >> d;

5. Переопределение операций чтения-записи для типов

данных пользователя

#include <iostream.h>

class myclass

{

int d1,d2;

...

public:

friend istream& operator>>(istream&, myclass&);

friend ostream& operator<<(ostream&, myclass&);

...

};

istream& operator>>(istream &STR, myclass &DAT)

{

STR >> DAT.d1 >> DAT.d2;

return(STR);

}

ostream& operator<<(ostream &STR, myclass &DAT)

{

STR << "d1=" << DAT.d1 << " d2=" << DAT.d2 << "\n";

return(STR);

}

6. Форматирование данных в потоках

Флаги форматирования - битовые поля в переменной типа long

enumа ios::io_format

{

skipws = 0x1, // Игнорирование пробелов при вводе

leftа = 0x2, // Выравнивание по левой границе поля

right = 0x4, // Выравнивание по правой границе поля

internal= 0x8, // Знак выводится по левому краю поля,

// само число выравнивается по правому

dec = 0x0010, // Десятичная система счисления

oct = 0x0020, // Восьмеричная система счисления

hex = 0x0040, // Шестандатеричная система счисления

showbase= 0x0080, // Вывод индикатора системы счисления

// (0... или 0x...)

showpoint=а 0x0100, // Обязательный вывод десятичной точки

uppercase=а 0x0200, // Верхний регистр символов:

// 0X00FF, 0.5E2

showpos = 0x0400, // Обязательный вывод "+"

scientific= 0x0800, // Обязательный вывод порядка числа

fixed = 0x1, // Вывод с фиксированной точкой.

unitbuf = 0x2, // Очистка буфера после каждого вывода

stdio = 0x4 // Очистка потоков stdout, stderr

// после каждого вывода (flush)

};

Функции форматирования в классе ios

longа flags(); // Чтение флагов форматирования

longа flags(long); // Присваивание флагов форматирования

// (нулевых и единичных)

// (возвращает старые значения флагов)

longа setf(long); // становка флагов форматирования

// (установленных в маске в 1)

longа unsetf(long); // Сброс флагов форматирования

// (установленных в маске в 1)

longа setf(long,long);// Установка флагов форматирования

// из первого параметра по маске

// второго параметра

charа fill(); // Чтение символа заполнения (пробел)

charа fill(char); // стаовка символа заполнения

int precision(); // Чтения точности представления

// float и double

int precision(int); // становка точности представления

int width(); // Чтение текущей ширины поля

int width(int); // становка текущей ширины поля

static long bitalloc();// Чтение маски флагов

7. Манипуляторы

Манипуляторы - функции потока, которые можно включать в

операции помещения и извлечения в потоки ( <<, >>).

endl // Помещение в выходной поток символа

// конца строки '\n' и вызов функции flush

ends // Помещение в выходной поток символа '\0'

flush // Вызов функции вывода буферизованных данных

// в выходной поток

dec // Установка основания 10 системы счисления

hex // Установка основания 16 системы счисления

oct // Установка основания 8 системы счисления

ws // Установка игнорирования при вводе пробелов

setbase(int) // Установка основания системы счисления

// (0 - 10 - по молчанию, также 8,10,16)

resetiosflasg(long)

// Сброс флагов форматирования по маске

setiosflags(long)

// Установка флагов форматирования по маске

setfill(int) // Установка заполняющего символа

setprecision(int)

// Установка точности вывода вещественных

// чисел

setw(int) // Установка ширины поля ввода-вывода

Пример вызова манипулятора:

cout << 15 << hex << 15 << setbase(8) << 15;

8. Состояние потока

Состояние потока характеризуется элементома данныха state,

для которого определены флаги состояния и функции управления

состоянием.

enumа ios::io_state

{

goodbit = 0x00, // Ошибок нет

eofbit = 0x01, // Обнаружен признак конца файла

failbit = 0x02, // Ошибка форматирования или

// преобразования данных

badbit = 0x04, // Серьезная ошибка (буферизация,

// чтение после конца файла и т.д.)

hardfail= 0x08а // Аппаратная ошибка

};

Функции правления состоянием в класса ios

int rdstate();а // Чтение текущего состояния

int eof(); // Проверка флага eof

int fail(); // Проверка badbit | failbit | hardfail

int bad(); // Проверка badbit | hardfail

int good(); // Проверка на отсутствие ошибок

int clear(int=0); // становка флагов ошибки, по

// умолчанию - очистка всех

operator void*(); // Преобразование к типу void*,

// возвращает NULL, если fail()==1

int operator!(); // Возвращает 1, если fail()==1

Последние переопределения позволяют проверять наличие ошибок

в потоках в виде

if (cout)... или if (!cout)...

9. Файловые потоки

Классы файловых потоков

ifstream - файл ввода, производный от istream

ofstream - файл вывода, производный от ostream

fstream - файл ввода-вывода, производный от iostream

Флаги режимов работы с файлом

enumа ios::open_mode

{

in =а 0x01, // Открыть файл только для чтения

out = 0x02, // Открыть файл только для записи

ate = 0x04, // При открытии позиционироваться в конец файла

app = 0x08, // Открыть существующий для дополнения

trunc = 0x10, // Создание нового файла взамен существующего

nocreate=0x20, // Не создавать новый файл при его отсутствии

noreplace=0x40, // Не создавать новый файл, если он существует

binary= 0x80а // Двоичный файл ("прозрачный" ввод-вывод без

// преобразования символов конца строки)

};

Конструкторы объектов (для классов ifstream,ofstream,fstream)

и функции открытия/закрытия файлов

ifstream(); // Без открытия файлов

...

ifstream( // С открытием файла в заданном

char *name, // режиме imode

int imode=ios::in,

int prot=filebuf::openprot);

...

ifstream(int fd); // С присоединенем файла с дескрип// тором fd

...

ifstream( // То же, с явно заданным буфером

int fd,

char *buf, int sz);

...

oidа ifstream::open( а

char *name, // Открытие файла в заданном режиме

int imode=ios::in,

int prot=filebuf::openprot);

...

oidа close(); // Закрыть файл

oidа setbuf(

char *p,int sz);// становить буфер потока

int fd(); // Дескриптор открытого в потоке файла

int is_rtl_open(); // 1 - файл открыт в потоке

Унаследованные переопределения операторов позволяют проверять

наличие ошибок в потоках в виде

fstream ss;

if (ss) ... или if (!ss)...

Функции ввода-вывода данных файловых потоков

(унаследованы из istream,ostream и iostream)

// Чтение казанного количества символов (байтов)

// из потока в буфер

istream& read( char *p, int n);

istream& read( signed char *p, int n);

istream& read( unsigned char *p, int n);

// Запись казанного количества символов (байтов)

// из буфера в поток

ostream& write( char *p, int n);

ostream& write(а signed char *p, int n);

ostream& write(unsigned char *p, int n);

// Чтение-запись символа из потока

istream& get( char &p);

istream& get( signedа char &p);

istream& get( unsignedа char &p);

ostream& put( char c);

// Чтение строки из потока (n-длина, c-ограничитель,

// из потока не извлекается)

istream& get(char *p, int n, char c='\n');

// Чтение строки из потока (n-длина, c-ограничитель,

// из потока извлекается, в буфер не пишется)

istream& getline(char *p, int n, char c='\n');

// Пропуск n символов при вводе (c - ограничитель,

// извлекается из потока)

istream& ignore(int n=1, int d=EOF);

// Число символов, прочитанных последней функцией

// неформатированного ввода

int gcount();

// Чтение символа без извлечения из потока

int peek();

// Возвращение символа во входной поток

istream& putback(char c);

// Позиционирование в потоке и чтение текущей позиции

enumа ios::seek_dir

{

beg = 0, // От начала файла

cur = 1, // От текущей позиции

end = 2 // От конца файла

};

typedef longа streampos;

typedef longа streamoff;

istream& seekg(streampos);

istream& seekg(streamoff, ios::seek_dir);

ostream& seekp(streampos);

ostream& seekp(streamoff, ios::seek_dir);

streampos istream::tellg();

streampos ostream::tellp();

10. Строковые потоки

Строковые потоки - потоки, источниками символов которых

являются не файлы, строки в памяти. Они наследуют все

функции и операции istream, ostream и iostream.

Конструкторы строковых потоков (p - буфер строки, n - длина,

mode - режим открытия)

istrstream(char *p);

ostrstream(char *p, int n, int mode);

// mode = ios::out - запись с начала строки

// mode = ios::ate - добавление к существующей строке

strstream (char *p, int n, int mode);

// ios::in - чтение строки

// ios::out - запись строки

// ios::ate - добавление к существующей строке

// функция seekg - позиционирование в строке

Приложение 9. Работа в оболочке Borland C в DOS

────────────────────────────────────────────────

1. Вызов оболочки

c:\bc\bin\bc - вызов оболочки

c:\bc\bin\bcа a.c - вызов оболочки для файла a.c

c:\bc\bin\bcа b.prj - вызов оболочки для проекта b.prj

2. Система меню

Меню верхней части экрана. Вход по F10 или по Alt+"Z",

где Z - первая (прописная) буква в соответствующем слове

меню (например, Alt+F --> строка меню File)

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└──────────────────────────────────────────────────────────────┘

Некоторые команды меню выполняются при нажатии функциональных

клавиш (F1-F10) в сочетании с Shift, Alt или Ctrl, что указано

в соответствующих строках меню.

3. Работа с окнами и файлами

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└─│────────────────────────────────────────────────────────────┘

│ ┌─ Создать новый файл с временным именем

│ NONAMExx.C и открыть окно

┌─┴───────────────┐ │┌ Открыть окно с выбранным файлом

│ New а ─────┘│ (файл выбирается в отдельном окне,

│ Open F3 а ──────┘ при вводе нового имени - создается)

│ Save F2 а ─────── Сохранить текущее окно в файле

│ Save as... а ─────── Сохранить текущее окно в отдельном

│ Save allа а ──────┐ файле с явно заданным именем

├─────────────────┤ └ Сохранить все окна в файлах

│ Change dir... а ─────── Выбрать текущий каталог файлов

│ Print а ─────── Печать текущего окна

│ DOS Shell а ─────── Запуск оболочки DOS

├─────────────────┤ а (возврат по команде EXIT)

│ Quit Alt+X ─────── Выход

└─────────────────┘

Alt+0 - открыть список окон. Список окон представляет собой

отдельное окно, содержащее меню - список окон, по

которому можно перейти в любое выбранное окно или

закрыть его (Del)

Alt+n - непосредственно перейти в окно с номером n=1..9

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└───────────────────────────────────────────────────│──────────┘

Изменить положение окна клавишами перемещения │

курсора и размеры окна клавишами ┌───────────┴───────┐

перемещения курсора с Shift ──────────── Size/Moveа Ctrl+F5 │

Развернуть/свернуть на полный экран ──── Zoomа F5 │

Каскадное расположение окон ──────────── Cascade │

Расположение окон без перекрытий ─────── Tile │

Перейти в следующее по номеру окно ───── Next F6 │

Закрыть текущее окно ─────────────────── Close Alt+F3 │

Закрыть все окна ─────────────────────── Close all │

Открыть или перейти в окно: │ │

Окно сообщений транслятора ───────────┐ ├───────────────────┤

Окно вывода программы (параллельно са └─ Message │

User screen) ─────────────────────────── Output │

Окно точек просмотра ─────────────────── Watch │

Экран программы (переход/возврат) ────── User screen Alt+F5 │

Окно регистров процессора ────────────── Register │

Окно файла проекта ───────────────────── Project │

Окно собственных замечаний ───────────── Project notes │

├───────────────────┤

Открыть список окон ──────────────────── List all Alt+0а │

└───────────────────┘

4. Редактирование

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└─────│────│───────────────────────────────────────────────────┘

│ ┌──┴─────────────────┐

│ │Find ─── Искать по образцу

│ │Replaceа ─── Искать по образцу с заменой

│ │Search again Ctrl+L ─── Искать следующий за найденным

│ │ по Find или Replace

│ │Go to line number ─── Переход к строке с заданным

│ │... а номером

│ │Locate function ─── Поиск заголовка функции

│ └────────────────────┘ в программе

┌─────┴─────────────────┐

│Undo ALT+BkSp ────── Отменить последнюю команду

│Redo Shift+Alt+BkSpа ────── Повторить последнюю команду

├───────────────────────┤а Операции с буфером (Clipboard):

│Cutа Shift+Del ─── далить блок с записью в буфер

│Copy Ctrl+Ins ─── Копировать блок в буфер

│Paste Shift+Ins ─── Вставить блок из буфера

│Clear Ctrl+Del ─── далить блок

│Copy Example ─── Копировать выбранный пример

├───────────────────────┤ из Help в буфер

│Show Clipboard ─── Просмотр буфера

└───────────────────────┘

Перемещения курсора:

Символ влево <-

Символ вправо ->

Слово влево Ctrl <-

Слово вправо Ctrl ->

Строка вверх "стрелка вверх"

Строка вниз "стрелка вниз"

Прокрутка вверх на одну строку Ctrl-W

Прокрутка вниз на одну строку Ctrl-Z

Страница вверх PgUp

Страница вниз PgDn

Перемещения на большие расстояния:

К началу строки Home

К концу строки End

К верхнему краю окн Ctrl Home

К нижнему краю окн Ctrl End

К началу файл Ctrl PgUp

К концу файл Ctrl PgDn

К началу блок Ctrl-Q B

К концу блок Ctrl-K K

К последней позиции курсор Ctrl-Q P

Команды вставки и перемещения:

Задание/снятие режима вставки Ins

Удалить символ слева от курсор Backspace

Удалить символ у курсор Del

Удалить слово вправо Ctrl-T

Вставить строку Ctrl-N

Удалить строку Ctrl-Y

Удалить символы до конца строки Ctrl-Q Y

Команды обработки блоков:

Пометить блок Shift + <стрелки>

(перемещение курсора)

Начало блок Ctrl-K B

Конец блок Ctrl-K K

Пометить слово под курсором Ctrl-K T

Пометить текущую строку Ctrl-K L

Удалить блок Ctrl-K Y

Прочитать блок из файла (текст Ctrl-K R

из файла читается и размещается

по текущему положению курсора)

Записать блок в файл Ctrl-K W

Копировать блок Ctrl-K C

Переместить блок Ctrl-K V

Печатать блок Ctrl-K P

Скрыть/отобразить блок Ctrl-K H

Задать структурный отступ блок Ctrl-K I

Отменить структурный отступ блок Ctrl-K U

Другие команды:

Восстановить строку Ctrl-Q L

Возвратиться к редактору из меню Esc

Искать Ctrl-Q F

Искать и заменить Ctrl-Q A

Табуляционное перемещение Tab

5. Модульное программирование. Проект

Файл проекта используется при разработке модульной програм-

мы, состоящей из нескольких файлов (модулей) (см.4.6). Про-

ект содержит список файлов исходных текстов (.c и.cpp) или

объектных модулей (.obj), также все становки параметров

транслятора и оболочки. При работе без файл проект обо-

лочка транслирует, компонует и выполняет файл текущего окна.

При наличии открытого файла проекта оболочка руководствуется

списком файлов проекта.

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└───────────────────────────────────│──────────────────────────┘

┌┴──────────────┐

┌────────────────────────────────── Open project │

│┌───────────────────────────────── Close projectа │

││ ├───────────────┤

││ Добавить файл в проект ───────── Add item │

││ далить файл из проекта ──────── Delete item │

││ становка параметров ─────────── Local optionsа │

││ трансляции текущего файла ┌─ Include filesа │

││ Список включаемых файлов ─────┘ └───────────────┘

││ текущего файла

││

│└ Закрыть файл проекта и перейти в обычный режим работы

│

└─ Открыть файл проекта. В отдельном окне выбирается имя файла

проекта. Тип по молчанию - PRJ. При вводе имени нового файла -

создается файл проекта с текущими становками параметров транс-

лятора и оболочки. Открывается отдельное омно project - список

файлов проекта. При работе в этом окне можно далять выбранные

файлы из проекта (Del) и включать файлы в проект (Ins). В по-

следнем случае открывается меню для выбора файла.

6. Трансляция и компоновка

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└─────────────────│───│────────────────────────────────────────┘

┌───────────────┴─┐ │

│Run Ctrl+F9а ──── Команда "Make" и выполнение программы

│... │ │

└─────────────────┘ │

┌─────────────┴─────────┐

┌───────│Compileа Alt-F9а │

│┌──────│Make F9 │

││┌─────│Link │

│││┌────│Build all │

││││ ├───────────────────────┤

││││ │Rеmove messages ─── Очистить окно сообщений

││││ └───────────────────────┘ транслятора (message)

│││└─── Безусловная трансляция и компоновка файла текущего

││а окна или проекта

││└──── Компоновка файла текущего окна или проекта

│└───── Трансляция и компоновка файла текущего окна или

│ проекта (каждый файл транслируется только при

│ словии внесения изменений в текст программы,

│ в том числе в файлы, включенные директивой include)

└────── Трансляция файла текущего окна

При трансляции и компоновке открывается окно сообщений транс-

лятора (message), в который выводятся сообщения об ошибках и

предупреждения. При выборе сообщения в окне message происходит

позиционирование в окне к строке, вызвавшей это сообщение.

При нажатии Enter на выбранном сообщении производится переход

в окно к строке, вызвавшей это сообщение.

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└──────────│───────────────────────────────────────────────────┘

┌──────────┴───────────┐

│... │ ┌─ Переход к строке программы, вызвавшей

│Previous error Alt+F7 ──┘а предыдущее сообщение (message)

│Next error Alt+F8 ──── Переход к строке программы, вызвавшей

│... │ следующее сообщение

└──────────────────────┘

7. Выполнение и отладка

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└──────────────────│───────────────────────────────────────────┘

┌─────────────────┴─────┐

│Run Ctrl+F9 ── Команда "Make" и выполнение программы

│Programm reset Ctrl+F2 ── Сброс и становка начального состояния

│Goto cursor F4 ────┐а программы при отладке

│Trace into F7 ───┐└─ Выполнять программу до строки,

│Step over F8 ──┐а отмеченной курсором

│Arguments ─┐│└── Выполнить одну строку программы

└───────────────────────┘││ с трассировкой вызываемой функции

│└─── Выполнить одну строку программы

│ без трассировки вызываемой функции

└──── Задать аргументы командной строки

программы при отладке

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└─────────────────────────────────│────────────────────────────┘

┌┴─────────────────────────┐

┌──────────────────────────────── Inspect Alt+F4 │

│┌─────────────────────────────── Evaluate/modify Ctrl+F4 │

││ Последовательность (стек )──── Call stack Ctrl+F3 │

││ вызовов функций │Watches ──┐

││ становить/отменить точку───── Toggle breakpoint Ctrl+F8 │

││ останова в текущей строке ┌── Breakpoints │ │

││ Просмотр/редактирование ───┘а └──────────────────────────┘ │

││ списка точек останов │

││ Точки просмотра (вычисляемые выражения в окне Watch)

││ ┌─────────────────────┴─┐

││ Добавить точку просмотра ──────────── Add watch Ctrl+F7а │

││ далить текущую точку просмотра ───── Delete watch │

││ Редактировать текущую точку ───────── Edit watch │

││ далить все точки просмотра ───────── Remove all watches │

││ └───────────────────────┘

│└─ Вычисление и модификация значения адресного выражения

в отдельном окне

└── Просмотр и модификация (инспектирование) значения текущей

переменной под курсором (Аlt+F4) или явно казанной

переменной или адресного выражения (меню). Значение

переменной или выражения отображается в отдельном окне,

окно закрывается по Esc. Alt+M - модификация выбранного

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

8. Настройка

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└───────────────────────────────────────────│──────────────────┘

┌───┴───────────┐

│Application │

│Compiler ─

│Transfer │

│Make │

│Linker ─

│Librariesа │

│Debugger │

│Directories │

├───────────────┤

│Environment ─

├───────────────┤

│Save │

└───────────────┘

9. Система помощи

┌──────────────────────────────────────────────────────────────┐

│File Edit Search Run Compile Debug Project Options Window Help│

└──────────────────────────────────────────────────────────│───┘

┌──────────────────┴───┐

Тематическое содержание Help ─────────── Contents F1 │

Перечень ключевых слов (индекс) ──────── Index Shift+F1 │

Контекстный поиск по текущему слову ──── Topic Searchа Ctrl+F1 │

Возвращение к предыдущей теме ────────── Previous Topic Alt+F1 │

Информация о Help ────────────────────── Help on help │

└──────────────────────┘