Язык Си шаг за шагом
#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 │
└──────────────────────┘