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

#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];

}

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,"\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);

}

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,"%s\t\t%s\n",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,"\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();

}

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

{

struct ffblk DIR;

int    done,i;

expand=0;

if (narg < 2)

    {

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

    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 <stdio.h>

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

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

main(int narg, char *argv[])

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

            >test.exe aaa 100 bbbb

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

            │test.exe\0│aaa\0│100\0│ccc\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:\xxx\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  вещественного  числа  или  длиного

// целого в системе счисления  с  основанием  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 <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      =     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        // Помещение в выходной поток символа '\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);

...

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:\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             │

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