курсовые,контрольные,дипломы,рефераты
#include
#include
#define FA_DIREC 0x10
#define CONTROL '$'
#define OPEN "<174>"
#define CLOSE "<175>"
#define DEFIS "<197>"
#define NUM "<102>"
#define EOLN ' '
#define ITALIC ""
#define BOLD "
// $$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];
}
void 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,"nn");
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 }nn",x);
if (mode==1)
{
sprintf(z,"//────────────────────────────────────────────── %sn",x);
fprintf(fd1,"%s",z);
}
if ((mode & 1) && expand) ProcProg();
if (mode!=0) fprintf(fd1,"%sn",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,"%sn",img);
fclose(fd1);
return(1);
}
if (n==1)
fprintf(fd1,"n");
else
fprintf(fd1,"%sn",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);
}
void 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,"%stt%sn",out,in);
}
fclose(fdi);
fclose(fdo);
}
void step()
{
int i,n,mode;
sprintf(x,"%s.000",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,"nn");
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();
}
void main(int narg, char *argv[])
{
struct ffblk DIR;
int done,i;
expand=0;
if (narg < 2)
{
printf("bk.exe файл | * [+]n* - все файлыn+ - преобразование c-файловтип по умолчанию - .000n");
exit(0);
}
strcpy(in,argv[1]);
if (narg==3 && argv[2][0]=='+') expand++;
if (in[0]!='*')
{
step();
}
else
{
for (done=findfirst("*.000",&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
// ┌─────────────── количество компонент
// │ ┌── массив указателей на компоненты
main(int narg, char *argv[])
{ for
(int i=0; i >test.exe aaa 100 bbbb
┌──────────┬─────┬─────┬─────┐ │test.exe │aaa │100 │ccc │ argv[]
└│─────────┴│────┴│────┴│────┘ ┌───────┐0 │ │ │
│ │ ───────────┘ │ │
│ ├───────┤1 │ │
│ │
──────────────────────┘ │
│ ├───────┤2 │ │ │
────────────────────────────┘ │ ├───────┤3 │ │ ──────────────────────────────────┘ └───────┘ Приложение
3. Стандартная библиотека ввода-вывода ───────────────────────────────────────────────── 1. Заголовочный файл библиотеки ┌ #include
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
c:xxxb.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(ошибка) - явно указанный файл │ └───────────────────────────────────────────────────────┘ Примечание: при вводе-выводе все строки функции
используют в качестве стандартного ограничителя строки в памяти
сим- вол ' '. Символ
конца строки '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 или до ) 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 ... FOR(k,20)
A[k]=0; // for(k=0; k<20; k++) A[k]=0; FOR(j,m+2)
{...} // for(j=0; 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
вещественного числа или
длиного // целого в системе счисления с
основанием n. endptr
- // адрес указателя, где
сохраняется указатель на
символ // в str, на котором завершилось чтение строки char *strtok(char *str, char *s); // Выделение слова в строке str. Слово - любая последова- // тельность символов, кроме символов-разделителей, пере- // численных в строке s. // При первом вызове возвращает указатель на первый
символ // строки. При последующих вызовах с str=NULL возвращает // указатель на очередное слово char *strupr(char
*str); // Замена в строке str латинмких букв нижнего регистра на // верхний ("маленьких на большие") 3. Функции для работы с терминалом в текстовом режиме (Заголовочный файл - conio.h) ─────────────────────────────────────────────────────────── void clreol(void); // Очистка строки от текущей позиции курсора до конца votd 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 void delline(void); // Удаление строки, в которой находится курсор void gotoxy(int x, int y); // Установка курсора в позицию с координатами (x,y). // Координаты курсора отсчитываются от левого верхнего // угла, начиная с 1 void highvideo(void); // Устанавка режим повышенной яркости выводимых символов int movetext(int x0,int y0,int x1,int y1,int x,
int y); // Перенос содержимого текстового окна с координатами // (x0,y0)(x1,y1) в область экрана с координатами левого // верхнего угла (x,y) void normvideo(void); // Установка режима обычной яркости выводимых символов void textattr(int attr); // Установка атрибутов (цвет символов и фона) выводимых // символов void textbackground(int c); // Установка цвета фона выводимых символов и очищаемого // экрана void textcolor(int c); // Установка цвета выводимых символов void textmode(int
c); // Установка текстового режима int wherex(void); int wherey(void); // Значение координаты курсора void 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 // ios,istream,ostream,iostream #include
// ifstream,ofstream,fstream #include
#include //
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 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 = 0x0001, //
Игнорирование пробелов при вводе left = 0x0002, //
Выравнивание по левой границе поля right = 0x0004, //
Выравнивание по правой границе поля internal= 0x0008, // Знак выводится по левому краю поля, //
само число выравнивается по правому dec = 0x0010, //
Десятичная система счисления oct = 0x0020, //
Восьмеричная система счисления hex = 0x0040, //
Шестандатеричная система счисления showbase= 0x0080, // Вывод индикатора системы счисления //
(0... или 0x...) showpoint= 0x0100, // Обязательный вывод десятичной точки uppercase= 0x0200, // Верхний регистр символов: //
0X00FF, 0.5E2 showpos = 0x0400, //
Обязательный вывод "+" scientific= 0x0800, // Обязательный вывод порядка числа fixed = 0x1000, //
Вывод с фиксированной точкой nnn.mmm unitbuf = 0x2000, //
Очистка буфера после каждого вывода stdio = 0x4000 //
Очистка потоков 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 //
Помещение в выходной поток символа ' ' 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); ... void ifstream::open(
char *name, // Открытие файла в заданном режиме int imode=ios::in, int prot=filebuf::openprot); ... void close(); //
Закрыть файл void 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:bcbinbc -
вызов оболочки c:bcbinbc a.c - вызов оболочки для файла a.c c:bcbinbc 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 │ └──────────────────────┘
Билеты и ответы по Информатике за 11-й класс
Лекции по высокоуровневым методам информатики и программированию
10 задач с решениями программированием на Паскале
Разработка программы- тренажера "Управление электросетями"
Разработка математической модели и ПО для задач составления расписания
Использование макросов для программирования в MS ACCESS
Помощь в обучении программированию
Ответы к экзаменационным билетам по Информатике. 2001-2002 год
Компьютерная фирма
Интегрирование методом Симпсона
Copyright (c) 2024 Stud-Baza.ru Рефераты, контрольные, курсовые, дипломные работы.