-в операции sizeof;

-в операции явного преобразования типа данных;

-при объявлении формальных параметров внешней функции с использованием прототипа.

Во всех случаях используется тот же самый контекстный способ определения, в котором отсутствует имя переменной. Рассмотрим примеры:

p = malloc(sizeof(char *) * 20);

Резервируется память для размещения 20 указателей на строки.

long l;
((char *)&#38l) [2] = 5;

Указатель на переменную l типа long явно преобразуется в указатель на символ (байт) -значение 5 записывается во второй (начиная с нулевого) байт длинного целого l.

extern int strcmp(char *, char *);

прототип внешней функции сравнения строк с двумя формальными параметрами -указателями на строки.

Адресная арифметикаУказатель как адрес памяти

-любой указатель потенциально ссылается на неограниченную в обе стороны область памяти, заполненную переменными указуемого типа;

-переменные в области нумеруются от текущей указуемой переменной, которая получает относительный номер 0. Переменные в направлении возрастания адресов памяти нумеруются положительными значениями 1,2,3..., убывания - отрицательными --1,-2..;

-результатом операции " указатель + i" является адрес i-й переменной (значение указателя на i-ю переменную) в этой области относительно текущего положения указателя.

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

*p // Значение указуемой переменной;

p + i // Указатель на i-ю переменную после указуемой;

p -i // Указатель на i-ю переменную перед указуемой;

*(p+i) // Значение i-й переменной после указуемой;

p[i] // Значение i-й переменной после указуемой;

p++ // Установить указатель не переменную, следующую

// за указуемой;

p-- // Установить указатель на переменную,

// предшествующую указуемой;

p+=i // Переместить указатель на i переменных вперед

// относительно указуемой;

p-=i // Переместить указатель на i переменных назад

// относительно указуемой;

*p++ // Получить значение указуемой переменной и

// установить указатель на следующую;

*(--p) // Переместить указатель к переменной,

// предшествующей указуемой, и получить ее

// значение.

В операциях адресной арифметики транслятором автоматически учитывается размер указуемых переменных, то есть " +i" понимается не как смещение на i байтов, слов и пр., а как смещение на i указуемых переменных. Другая важная особенность: при перемещении указателя нумерация переменных в памяти остается относительной и всегда производится от текущей указуемой переменной.

Алгоритм

-данные - переменные, создаваемые на основе типов данных ;

-выражения, включающие переменные и операции по их обработке ;

-логика алгоритма, составленная из операторов ;

-модули, соответствующие логически завершенным частям алгоритма.

Если отнести последние три компоненты к алгоритмической части программы, то можно дать такое короткое определение :

Арифметические операции

a = (a + 1) % 16; // a присвоить a+1 по модулю 16

Атттестационный экзамен ()

КРИТЕРИЙ ОЦЕНКИ ВЫПОЛНЕНИЯ ЗАДАНИЯ

КРИТЕРИИ СНИЖЕНИЯ ОЦЕНКИ

СОДЕРЖАНИЕ ЗАДАНИЯ ПО ДИСЦИПЛИНЕ "ИНФОРМАТИКА"

СОДЕРЖАНИЕ ЗАДАНИЕ ПО ДИСЦИПЛИНЕ "ТЕХНОЛОГИЯ ПРОГРАММИРОВАНИЯ"

Байт, машинное слово

.

15 14 ... 8 7 5 ... 2 1 0
________________________________________________
1 0 0 0 1 1 0 1 0 1 0 1 1 0 1 1
________________________________________________
| | |
старший разряд (бит) 5-й разряд младший разряд

Размерность байта - 8 бит -принята не только для представления данных в большинстве компьютеров, но и в качестве стандарта для хранения данных на внешних носителях, для передачи данных по каналам связи, для представления текстовой информации. Кроме того, байт является универсальным "измерительным инструментом" - размерность всех форм представления данных устанавливается кратной байту. При этом машинное слово считается разбитым на байты, которые нумеруются, начиная с младших разрядов.

Самая распространенные формы представления данных, использующие одно машинное слово -целое число со знаком и без. Наиболее простая -целое положительное число без знака. В нем каждый разряд машинного слова имеет вес, в два раза больший, чем вес соседнего правого, то есть 1,2,4,8,16 и т.д. или последовательные степени 2. Тогда значение числа в машинном слове равно сумме произведений значений разрядов на их веса:

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

Базовые типы данных целых чисел

-int -размерность переменной -стандартное машинное слово;

int i; // целое со знаком, слово

char c; // целое со знаком, байт

unsigned char uc; // целое без знака, байт

unsigned u; // целое без знака, слово

long l; // целое со знаком, двойное слово

unsigned long ul; // целое без знака, двойное слово

short s; // целое со знаком, короткое слово

/ / (слово или байт)

Для определения размерности различных переменных и типов в Си имеется специальная операция, которая возвращает размерность типа данных, переменной и значения выражения выражения, подсчитанную в байтах:

sizeof (int) // размерность типа данных int - 2

sizeof l // размерность переменной типа long - 4

sizeof(i+2.0) // размерность значения выражения типа double - 8

Битовые поля

.

struct man
{ // 15 9 8 5 4 0

char name[20]; // ---------------------------------

unsigned dd:5; // | yy | mm | dd |

unsigned mm:4; // ---------------------------------

unsigned yy:7;
char *address; // 15 11 10 8 7 3 2 0

int xx:3; // ---------------------------------

int :5; // | | zz | ... | xx |

int zz:3; // ---------------------------------

};

A.dd = 12; A.mm = 5; A.yy=96; A.dd++; A.zz = A.xx;

Биты, байты, слова

Bk-t

N = 1 t =new Array()

function Set_quest() { elem = new Array() QST = new Array() for (i=1; i

Вопрос 1 Вопрос 2 Вопрос 3 Вопрос 4 Вопрос 5 Вопрос 6

Время

Всего

Правильно

Итого

Ответ

Числа с плавающей точкой

.

p 2
X = m * 10, например 25.4 = 0.254 * 10

где 0.1 m &#60 1 &#60/b -значащая часть числа, приведенная к интервалу 0.1 ... 1 , называемая мантиссой, a p -целое число, называемое порядком. Аналогично, если взять основание степени -2, то получим:

.

p 5
X = m * 2, например 25.4 = 0.79375 * 2

.

0.4 .665 3.1415926 1.17e2 -176E-3 1.1F5 3.33L

Что, как и зачем предлагается изучать

Раздел 3. "Программист системный"

Раздел 4. "Программист объектно-ориентированный"

Большинство изданий по языками и системам программирования путают две вещи : язык и практика программирования на нем. Общепринятая система погружения в язык - описание лексики, синтаксиса, напоминает изучение английского языка с помощью учебника грамматики и русско-английского словаря. Читающего же, в первую очередь интересует конечный результат - когда же он, наконец, начнет сам писать программы. Вопросы же технологии программирования, вообще "здравого смысла" при написании программ благополучно были отражены в книжках двадцатилетней давности и после этого забыты. Считается, что нынешние поколения программистов работают на столь высоком уровне, что неприлично напоминать о таких общеизвестных вещах, как списки, деревья, рекурсия.

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

- программирование на уровне Бейсик (l дилетантское) - простые переменные и массивы, основные алгоритмы решения арифметических задач, обработки текста, приближенных вычислений, законы информатики (простой и линейный поиск, сортировка), простые структуры данных - стек, очередь, модульное программирование (процедура, параметры), основы анализа программ путем разложения на стандартные фрагменты, основы технологии программирования ;

- программирование на уровне Паскаль (l продвинутое) - типы данных, иерархия типов данных и модулей (процедур) в сложный программах, производные типы данных - структуры, указатели, функции, динамическая память, общие вопросы организации памяти в программе ;

- организация данных - традиционный раздел, в котором Си предстает "во всей своей красе" (l системное).
Массивы указателей, списки, деревья, статические и динамические структуры данных. Указатели на функции и динамическое связывание, текстовые файлы и двоичные файлы произвольного доступа вплоть до физической организации баз данных (таблицы и индексы) ;


- технология объектно-ориентированного программирования и Си++ (l профессиональное). Классы и объекты. Иллюстрация возможностей Си++ средствами "классического" Си. "Эпизодическое" объектно-ориентированное программирование : определение классов, переопределение операций, объекты с динамическими данными. "Тотальное" объектно-ориентированное программирование - "от класса к классу". Наследование, полиморфизм. Технологии организации системы объектов в программе - объекты, управляемые сообщениями.

Отметим еще несколько принципиальных моментов, которые отслеживаются при изложении материала :


- если умение разрабатывать программы - это навыки " письма" , то не менее важными являются навыки " чтения" , то есть анализа уже готовых " хороших" программ. Поэтому в каждом параграфе должно быть 10-15 тестов - фрагментов программ и отдельных функций, которые составляют "Вопросы без ответов". Они также могут использоваться и как заготовки программ. Аналогично для самостоятельной работы должны предусматриваются 10-15 вариантов заданий.


- на каждом уровне погружения рассматриваются одни и те же алгоритмы, которые "вызывают чувство узнавания" - например, поиск минимума в массиве, массиве структур, дереве, и в том же дереве, представленном объектом класса.


- навык программирования в значительной степени приобретается по принципу "делай, как я", поэтому предпочтение отдается некоторому шаблону в решении поставленных задач. Импровизацию предлагается проявлять обучаемому.

Циклический список

class zlist
{
void *data;
zlist *next,*prev;
zlist *find(int); // Вспомогательный метод извлечения

public: // элемента списка по номеру

zlist(); // Конструктор пустого списка

~zlist(); //

int size(); // Количество элементов

void *operator[](int); // Извлечение

void operator()(void*,int); // Включение по номеру

void *remove(int); // Удаление по номеру

void *remove(void*); // Удаление по указателю на элемент данных

void *min( int(*)(void*,void*)); // Итератор поиска минимального

};

Конструктор списка определяет текущий объект как единственный элемент, который в соответствии с правилами построения циклического списка "замкнут сам на себя".

zlist::zlist()
{ prev=next=this; }

zlist *zlist::find(int n=-1)
{ zlist *p;
for (p=next; n!=0 &#38&#38 p!=this; n--, p=p-&#62next);
return p; }

Метод подсчета количества элементов в структуре данных стандартным образом обходит циклический список .

int zlist::size()
{ int n; zlist *p;
for (n=0, p=next; p!=this; n++, p=p-&#62next);
return n; }

Деревья

Вершину дерева можно определить таким образом:

struct tree
{
int val; // Значение элемента

tree *child[4]; // Указатели на потомков

};

Из определения элемента дерева следует только тот факт, что он имеет ограниченное число указателей на подобные элементы. Как и во всех динамических структурах данных характер связей между элементами определяется функциями, которые их устанавливают. В данном случае рекурсивное определение дерева требует и рекурсивного характера функций, работающих со связями. Простейшей функцией является функция обхода всех вершин дерева:

//------------------------------------------------------bk55-02.cpp

//------Рекурсивный обход дерева

void ScanTree(tree *p)
{
int i;
if (p == NULL) return; // следующей вершины нет

for (i=0; i&#60 4; i++) // рекурсивный обход

ScanTree(p-&#62child[i]); // потомков с передачей

} // указателей на них

Само дерево обычно задается в программе указателем на его главную вершину. Часто обход дерева используется для получения информации, которая затем возвращается через результат рекурсивной функции. Так работает, например, функция определения максимальной глубины дерева:

//------------------------------------------------------bk55-03.cpp

//------Минимальная длина ветвей дерева

int M inDepth(tree *p)
{ int i, m in, nn;
if (p == NULL) return 0; // следующей вершины нет

for (min = MinDepth(p-&#62child[0], i=1; i&#60 4; i++)
{ // обход потомков

nn = MinDepth(p-&#62child[i]);
if (nn &#62 max) max = nn;
} // возвращается глубина с

return min + 1; // учетом текущей вершины

}

Динамические массивы

//------------------------------------------------------bk47-01.cpp

// функция возвращает указатель на создаваемый

// динамический массив

int *GetArray()
{
int N,i; // Размерность массива

int *p; // Указатель на массив

cout &#62&#62 "Элементов в массиве:"; // в динамической памяти

cin &#60&#60 N;
if ((p = new int[N + 1]) == NULL)
return(NULL); // или malloc((N+1)*sizeof(double))

for (i=0; i&#60N; i++)
{
cout &#60&#60 i &#60&#60 "-ый элемент :";
cin &#62&#62 p[i];
}
p[i] = 0; // В конце последовательности

return(p); // данных - 0

} // Вернуть указатель

Здесь и далее используется эквивалентность синтаксиса *(p+i) и p[i] при использовании правил адресной арифметики для указателей.

Массивы, создаваемые в динамической памяти, будем называть ДИНАМИЧЕСКИМИ. Заметим, что Си позволяется использовать одинаковый синтаксис при работе с обычными и динамическими массивами. Во многих языках интерпретирующего типа (например, Бейсик) подобный механизм скрыт в самом трансляторе, поэтому массивы там "по своей природе" могут быть переменной размерности, определяемой во время работы программы.

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

Как известно, любого ресурса всегда не хватает. В компьютерах это прежде всего относится к памяти. Если на проблему ее распределения посмотреть с обычных житейских позиций, то можно извлечь много полезного для понимания принципов статического и динамического распределения памяти.

-самый неэффективный вариант : под каждый вид данных зарезервировать память заранее " по максимуму" . Применительно к массиву это означает, что мы заранее выбираем такую размерность, которая никогда не будет превышена. Но тем не менее, такое " никогда" рано или поздно может случиться , поэтому процесс заполнения массива лучше контролировать ;

-приемлемый вариант может быть реализован, если в какой-то момент времени выполнения программа " узнает" , какова в этот раз будет размерность обрабатываемых данных. Тогда она может создать динамический массив такой размерности и работать с ним. К сожалению, такое " знание" не всегда возможно ;

-идеальный вариант заключается в создании такой структуры данных, которая автоматически увеличивает свою размерность при ее заполнении. К сожалению, ни язык, ни библиотека здесь не помогут - такой массив можно реализовать только программно, по справедливости назвав ВИРТУАЛЬНЫМ МАССИВОМ.

//------------------------------------------------------bk47-03.cpp

// функция возвращает указатель на создаваемый

// динамический массив. Размерность массива увеличивается

// при заполнении с кратностью N - N, 2N, 3N ...

&#35define N 10
int *GetArray()
{
int i , *p; // Указатель на массив

p = new int[N]; // Массив начальной размерности

for (i=0; 1; i++)
{
cout &#60&#60 i &#60&#60 "-ый элемент";
cin &#62&#62 p[i];
if ((i+1)%N==0) // Массив заполнен ???

{ // Создать новый и переписать

int *q=new int[i+1+N];
for (int j=0; j&#60=i; j++)
q[j]=p[j];
delete p; p=q; // Считать новый за старый ,

} // а старый уничтожить

if (p[i]==0) return p; // Ограничитель ввода - 0

}
}

p = (int*) realloc(p,sizeof(int)*(i+1+N));

Динамические массивы указателей переменной размерности

//------------------------------------------------------bk52-03.cpp

// Текущее количество указателей

int size(double **p)
{ for (int i=0; p[i]!=NULL; i++);
return i;
}
// Увеличение размерности виртуального массива

// при его возможном переполнении

&#35define N 20
double **extend(double **p)
{
if (p==NULL) // Создать динамический МУ при отсутствии

{p=new double*[N]; p[0]=NULL; return p;}
int k=size(p);
if ((k+1)%N==0) // количество указателей будет кратно N

{ // создать новый ДМУ

double **q=new double*[k+1+N];
for (int i=0; i&#60=k; i++)
q[i]=p[i]; // переписать указатели

delete p; // уничтожить старый ДМУ

return q; // вернуть новый ДМУ

}
return p;}
// Добавить указатель в конец ДМУ

double ** append(double **p, double *s)
{
double **q=extend(q); // при необходимости перераспределить

int k=size(q); // память

q[k]=s; q[k+1]=NULL; return q;
}
// Добавить указатель по номеру

double ** append(double **p, double *s , int n)
{
double **q=extend(q); // при необходимости перераспределить

int k=size(q); // память

if (n&#62=k) { q[k]=s; q[k+1]=NULL; } // включить последним

else
{
for (int j=k; j&#62=n; j--) q[j+1]=q[j];
q[n]=s;
}
return q;}
// Пример вызова

void main()
{ double a1,a2,a3,**vm =NULL;
vm=append( vm,&#38a1) ;
vm= append( vm,&#38a2) ;
vm= insert( vm,&#38a3,0) ;
}

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

Динамическое связывание

//------------------------------------------------------bk56-03.cpp

&#35include &#60math.h&#62
typedef void (*VPTR)();
typedef double (*DPTR)(double);
struct ENTRY // описание точки входа функции

{
char name[20];
VPTR pf;
};
struct ENTRY DLL[] = // массив точек входа

{
{"sin", (VPTR)sin}, {"cos", (VPTR)cos,},
{"tan", (VPTR)tan}, {"",NULL}};
// Поиск указателя на функцию по имени функции

// (функция возвращает указатель на функцию вида void f())

VPTR DLink(ENTRY *pDLL, char *ps)
{ int n;
for (n=0; pDLL[n].pf !=NULL; n++)
if (strcmp(pDLL[n].name,ps) == 0)
return pDLL[n].pf;
return NULL;
}
void main()
{
double (*pa1)(double), (*pa2)(double);
//----- Динамическое связывание и вызов функций

if ((pa1 = (DPTR)DLink(DLL,"a1")) == NULL) return;
if ((pa2 = (DPTR)DLink(DLL,"a2")) == NULL) return;
y = (*pa1)(2.0) + (*pa2)(x);
}

Допустимые случаи использования оператора goto

retry: for(...) { for (...)
{...
if () goto retry;...
if () goto fatal; }
}
fatal:

Пример неправильного использования goto:

m1: for (i=0; i&#60n; i++)
{..if () goto m1;... }

Здесь имеется неявный внешний цикл, который не был замечен при проектировании программы. Исправленный вариант имеет вид:

while (1)
{ for (i=0; i&#60n; i++)
{ ...if () break;... }
if (i==n) break;
}

Дуализм двумерного массива и массива указателей

char *p[20];
p[i] // указатель на i-ю строку

p[i]++ // перейти в i-й строке с следующему символу

*(p[i] + j) // j-й символ в i-ой строке

p[i][j] // j-й символ в i-ой строке.

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

Двоично-десятичная арифметика

-отдельная цифра представлена 4 битами (тетрадой, шестнадцатеричной цифрой) ;

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

Например, число 17665 выглядит в этих формах представления следующим образом :

char s[]=" 17665" ;
long ss=0x00017655;

В качестве иллюстрации технологии работы с отдельными цифрами числа в десятичной системе счисления рассмотрим пример функции, добавляющей 1 к числу во внешней форме представления, то есть в виде текстовой строки. Добавление 1 состоит в поиске первой цифры, отличной от 9, к которой добавляется 1. Все встречающиеся " на пути" цифры 9 превращаются в 0. Если процесс " превращения девяток" доходит до конца строки, то производится расширение строки следующей цифрой 1.

//------------------------------------------------------bk48-05.cpp

void inc(char s[])
{
for (int i=0; s[i]!=0; i++); // Поиск конца строки

for (int n=i-1; n&#62=0; n--) // Младшая цифра - в конце

{
if (s[n]== 9 ) // 9 превращается в 0

s[n]= 0 ;
else { s[n]++; return; } // добавить 1 к цифре и выйти

}
for (s[i+1]=0; i&#62 0; i--) // Записать в строку 1000...

s[i]= 0 ;
s[0]= 1 ;}

Двоичное дерево

struct btree
{
int val;
btree *left,*right;
};

Указанное свойство позволяет применить в двоичном дереве алгоритм двоичного поиска. Действительно, каждое сравнение искомого значения и значения в вершине двоичного дерева позволяют выбрать для следующего шага правое или левое поддерево. Алгоритмы включения и исключения вершин дерева не должны нарушать указанное свойство: при включении вершины дерева поиск места ее размещения производится путем аналогичных сравнений:

//------------------------------------------------------bk55-06.cpp

//----- Рекурсивный поиск в двоичном дереве---------------

// Возвращается указатель на найденную вершину

btree *Search(btree *p, int v)
{
if (p==NULL) return(NULL); // Ветка пустая

if (p-&#62val == v) return(p); // Вершина найдена

if (p-&#62val &#62 v) // Сравнение с текущим

return(Search(p-&#62left,v)); // Левое поддерево

else
return(Search(p-&#62right,v)); // Правое поддерево

}
//----- Включение значения в двоичное дерево--------------

// функция возвращает указатель на созданную вершину,

// либо на существующее поддерево

btree *Insert(btree *pp, int v)
{
if (pp == NULL) // Найдена свободная ветка

{ // Создать вершину дерева

btree *q = new btree; // и вернуть указатель

q-&#62val = v;
q-&#62left = q-&#62right = NULL;
return q;
}
if (pp-&#62val == v) return pp;
if (pp-&#62val &#62 v) // Перейти в левое или

pp-&#62left=Insert(pp-&#62left,v); // правое поддерево

else
pp-&#62right=Insert(pp-&#62right,v);
return pp;
}
void main()
{
btree *ss=Search(ph,5); // пример вызова

ph=Insert(ph,6);
}

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

Двоичный файл - неограниченный массив байтов

-двоичный файл произвольного доступа представляет собой неограниченный массив байтов внешней памяти;

-форма представления данных в оперативной памяти компьютера (переменные) и в двоичном файле полностью идентичны ;

-программа имеет возможность при помощи функций ввода-вывода копировать любую область файла в любую область памяти без преобразования ("байт в байт"). Таким образом, можно разместить в любом месте файла любую переменную из памяти программы в том виде, в каком она присутствует в памяти и прочитать ее обратно;

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

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

// Открыть существующий как двоичный для чтения и записи

FILE *fd; fd = fopen("a.dat","rb+wb");
// Создать новый как двоичный для записи и чтения

fd = fopen("a.dat","wb+");

//------------------------------------------------------bk53-05.cpp

struct list2
{
list2 *next, *pred;
int val;
};
list *InsertSort(list2 *ph, int v)
{
list2 *q , *p=new list;
p-&#62val = v;
p-&#62pred = p-&#62next = NULL;
if (ph == NULL) return p; // включение в пустой список

for (q=ph; q !=NULL &#38&#38 v &#62 q-&#62val; q=q-&#62next) ;
// поиск места включения - q

if (q == NULL) // включение в конец списка

{ // восстановить указатель на

for (q=ph; q-&#62next!=NULL; q=q-&#62next) ;
p-&#62pred = q; // последний

q-&#62next = p;
return ph;
} // включить перед текущим

p-&#62next=q; // l следующий за новым = текущий

p-&#62pred=q-&#62pred; // l предыдущий нового = предыдущий

// l текущего

if (q-&#62pred == NULL) // включение в начало списка

ph = p;
else // включение в середину

q-&#62pred-&#62next = p; // l следующий за предыдущим l =l новый

q-&#62pred=p; // l предыдущийl l текущего = новый

return ph;
}

Наибольшие проблемы при работе со списками возникают при перемещении указателей в процессе перестановки элементов списков. Эти операции можно интерпретировать несколькими способами .

Exampl-

Назад: Некоторые полезные программные " заготовки"

Семестр 4

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

Нас прежде всего будет интересовать, какими свойствами обладают переменные и функции, определенные в различных точках модуля-файла, как они "узнают" о существовании друг друга и как они взаимодействуют между собой. Для начала сформулируем ряд необходимых терминов.

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

int a = 5 , B[10]={ 1,6,3,6,4,6,47,55,44,77 };

В определении переменной:

-задан тип переменной;

-задано имя переменной;

-определяется размерность и резервируется память. Размерность массивов в определении обязательно должна быть задана;

-производится инициализация памяти;

-для доступа к переменной из других модулей в текущем модуле может быть создана точка входа.

int strcmp(char *s, char *d) { ... }

В определении функции:

-задан тип результата;

-задано имя функции;

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

-транслируется тело функции;

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

Количество записей в файле определяется путем деления его размера на размер записи. Структура файла может быть усложнена с целью обеспечения его большей универсальности и устойчивости к ошибкам выполнения операций ввода-вывода и программирования. Например, в начало файла можно поместить переменные, содержащие размер записи и количество их в файле.

nrec size 0 1 2 m nrec-1
____________________________________________________
int int double double ... ... ... ...
____________________________________________________
2 * sizeof(int)+ m * size - адрес (смещение) записи

//---------------------------------------------- bk591.cpp

int nrec,size;
FILE *fd;
//---------------------------------------------------------

// Создать пустой файл

int Create(char *name, int sz)
{
if ((fd=fopen(name,"wb"))==NULL) // Создать новый для записи

return 0;
size=sz; nrec=0;
fwrite((void*)&#38nrec,sizeof(int),1,fd); // Записать в файл nrec и size

fwrite((void*)&#38size,sizeof(int),1,fd); //

fclose(fd);
return 1;
}
//----------------------------------------------------------------

// Открыть файл

int Open(char *name)
{
if ((fd=fopen(name,"rb+wb"))==NULL) // Открыть существующий

return 0; // для чтения и записи

fwrite((void*)&#38nrec,sizeof(int),1,fd); // Читать из файла nrec и size

fwrite((void*)&#38size,sizeof(int),1,fd); //

fseek(fd,0L,SEEK_ END); // Соответствует ли длина файла

if (ftell(fd)!=2*sizeof(int)+(long)nrec*size)
{ fclose(fd); return 0; } // значениям nrec и size?

return 1;
}
//----- Загрузить из файла запись в динамическую переменную

// n - номер записи

&#35include &#60alloc.h&#62
void *Get(int n)
{
void *pp;
if (fd==NULL) return NULL; // Файл не открыт

Файл записей переменной длины

-в первом случае, используется специальное значение или код -ограничитель записи. Типичным примером является строка текста в памяти, имеющая в качестве ограничителя символ '\0' , который в файле превращается в последовательность символов ' \r' и '\n'. В этом смысле обычный текстовый файл при работе с ним построчно есть файл записей переменной длины;

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

В качестве примера рассмотрим запись переменной длины, состоящую из фиксированной части - структуры и переменной части - строки, связанной с ней через указатель.

//------------------------------------------------------bk59-01.cpp

&#35include &#60stdio.h&#62
&#35include &#60alloc.h&#62
struct vrec
{
int dd,mm,yy;
char name[20]; // Строка фиксированной длины

char *addr; // Строка переменной длины

};

&#35define VSZ sizeof(vrec)

v rec *get(FILE *fd) // Чтение из файла в динамические

{ // переменные

int size;
vrec *p;
fread(&#38size,sizeof(int),1,fd); // Чтение счетчика

if (size == 0) return NULL; // EOF

if (size &#60 VSZ) return NULL; // Короткая запись

if ((p = new vrec) ==NULL) return NULL;
fread((void*)p,VSZ,1,fd); // Постоянная часть записи

size -= VSZ; // Остаток записи - строка

if ((p-&#62addr = new char[size]) ==NULL)
return NULL;
fread((void*)p-&#62addr,size,1,fd); // Переменная часть записи

return p;
}

void put(FILE *fd, vrec *p) // Добавление в файл

{
int size;
fseek(fd,-(long)sizeof(int),SEEK_END); // Установить на запись EOF

size = VSZ + strlen(p-&#62addr) + 1; // Общая длина записи (счетчик)

fwrite((void*)&#38size, sizeof(int), 1, fd); // Запись счетчика

f write((void*)p, VSZ, 1, fd); // Запись постоянной части

size -=VSZ;
fwrite((void*)p-&#62addr,size,1,fd); // Запись переменной части

size = 0; // Логический EOF-запись нулевой длины

fwrite((void*)&#38size, sizeof(int), 1, fd);
}

Файловые потоки

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&#38 read( char *p, int n);
istream&#38 read( signed char *p, int n);
istream&#38 read( unsigned char *p, int n);

// Запись указанного количества символов (байтов)

// из буфера в поток

ostream&#38 write( char *p, int n);


ostream&#38 write( signed char *p, int n);
ostream&#38 write(unsigned char *p, int n);

// Чтение-запись символа из потока

istream&#38 get( char &#38p);
istream&#38 get( signed char &#38p);
istream&#38 get( unsigned char &#38p);
ostream&#38 put( char c);

// Чтение строки из потока (n-длина, c-ограничитель,

// из потока не извлекается)

istream&#38 get(char *p, int n, char c='\n');

// Чтение строки из потока (n-длина, c-ограничитель,

// из потока извлекается, в буфер не пишется)

istream&#38 getline(char *p, int n, char c='\n');

// Пропуск n символов при вводе (c - ограничитель,

// извлекается из потока)

istream&#38 ignore(int n=1, int d=EOF);

// Число символов, прочитанных последней функцией

// неформатированного ввода

int gcount();

// Чтение символа без извлечения из потока

int peek();

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

istream&#38 putback(char c);

// Позиционирование в потоке и чтение текущей позиции

enum ios::seek_dir
{
beg = 0, // От начала файла

cur = 1, // От текущей позиции

end = 2 // От конца файла

};

typedef long streampos;
typedef long streamoff;

istream&#38 seekg(streampos);
istream&#38 seekg(streamoff, ios::seek_dir);
ostream&#38 seekp(streampos);
ostream&#38 seekp(streamoff, ios::seek_dir);
streampos istream::tellg();
streampos ostream::tellp();

Философские аспекты рекурсии

Как же следует вести разработку рекурсивного алгоритма, " не вспоминая о прошлом" и " не заглядывая в будущее" . Опираясь на метод математической индукции можно сформулировать следующие правила :

-рекурсивная функция разрабатывается как обобщенный шаг процесса, который вызывается в произвольных начальных условиях и который приводит к следующему шагу в некоторых новых условиях ;

-обобщенные начальные условия шага - формальные параметры функции ;

-начальные условия следующего шага - фактические параметры рекурсивного вызова ;

"Философский" смысл технологии ООП

Как видно из рисунка, цепочка вызовов функций является основной в схеме взаимодействия элементов программы, взаимосвязь элементов данных определяется характером передачи параметров между функциями. Поэтому традиционную технологию программирования можно назвать программированием "от функции к функции".

В технологии ООП взаимоотношения данных и алгоритма имеют более регулярный характер: во-первых, класс объединяет в себе данные (структурированная переменная) и методы (функции). Во-вторых, схема взаимодействия функций и данных принципиально иная. Метод (функция), вызываемый для одного объекта, как правило, не вызывает другую функцию непосредственно. Для начала он должен иметь доступ к другому объекту (создать, получить указатель, использовать внутренний объект в текущем и т.д.), после чего он уже может вызвать для него один из известных методов. Таким образом, структура программы определяется взаимодействием объектов различных классов между собой. Как правило, имеет место иерархия классов, а технология ООП иначе может быть названа как программирование "от класса к классу".

Философский смысл указателя

Основная же особенность каждого указателя состоит в том, что он дает " степень свободы" или универсальности любому алгоритму обработки данных. Действительно, если некоторый фрагмент программы получает данные непосредственно в некоторой переменной, то он может обрабатывать ее и только ее. Если же данные он получает через указатель, то обработка данных (указуемых переменных) может производиться в любой области памяти компьютера (или программы). При этом сам фрагмент может и " не знать" , какие данные он обрабатывает, если значение самого указателя передано программе извне.

Финал-апофеоз: классов, функций, строк

Шаг 1: Ударим классом по двоичному файлу

Шаг 2: Что такое произвольный элемент коллекции

Шаг 3: Строки -элементы таблицы

Шаг 4: Промежуточный финиш. Работаем с файлом строк

Шаг 5: Массив файловых указателей

Шаг 6: Файловая коллекция однотипных элементов

Шаг 7: Пример использования: ввод, сохранение и сортировка строк

Формальные и фактические параметры

void f(char **p, int A[], void (*f)())
{...}

Формат входных документов

Форматирование данных в потоках

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(); // Чтение маски флагов

Форматирование группы документов

Форматирование Си-программ

Форматирование строки

Шаг 1: Исходные данные и результат. Входная строка произвольной длины в массиве IN[], отформатированная строка длины n в массиве OUT[]. Выходная строка отвечает следующим требованиям:

-слово -любая последовательность символов, кроме пробела ;

-после форматирования число пробелов между словами различается не более чем на 1; -первое и последнее слово расположены по краям строки. Шаг 2: Форматирование включает в себя последовательность из трех действий:

void format(char IN[], char OUT[], int n)
{
// Собрать исходные данные по строке,

// необходимые для форматирования;

// Проверить возможность форматирования;

// Разместить слова в выходной строке.

}

Шаг 3: Данные по строке, необходимые для форматирования: -количество слов в строке -nw; -общее количество символов во всех словах -ns; -стандартное количество пробелов между словами при форматировании -np; -оставшееся количество пробелов, добавляемых по одному между словами -nr. На этом шаге детализируется проверка возможности форматирования и определяются взаимосвязанные параметры.

void format(char IN[], char OUT[], int n)
{ int nw, ns, np, nr;
// Определение nw, ns ...

OUT[0] = '\0';
if (nw &#60 2) return; // Мало слов в строке

np = (n - ns) / (nw - 1);
if (np &#60= 0) return; // Много символов в словах

nr = (n - ns) % (nw - 1); // Остаточное число пробелов

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

}

Шаг 4: Просмотр строки при определении параметров и форматировании можно выполнить, используя:

-цикл в цикле: цикл просмотра всех слов, в который включен цикл посимвольного просмотра интервала между словами и самого слова;

-цикл посимвольного просмотра строки, с использованием признака нахождения внутри слова или вне его - inword.

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

Форматирование таблиц

Формирование массивов указателей

-указуемые элементы (переменные) могут быть как обычными (статическими) переменными, создаваемые транслятором, так и динамическими переменными, создаваемыми в процессе работы программы;

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

В результате получаются структуры данных, единственное различие которых заключается во времени их формирования: от момента трансляции (инициализация) до момента выполнения.

Вариант 1. Формирование структуры данных при трансляции: переменные определяются статически, а указатели инициализируются. Такие структуры данных включены непосредственно в программный код и "готовы к работе":

double a1,a2,a3, *pd[] = { &#38a1, &#38a2, &#38a3, NULL};

Вариант 2. Переменные определяются статически, указатели устанавливаются программно. Этот вариант наиболее часто используется, когда указуемые переменные представлены массивом:

double d[19], *pd[20];
for (i=0; i&#60 19; i++) pd[i] = &#38d[i];
pd[i] = NULL;

Вариант 3. Указуемые переменные создаются динамически, массив указателей -статически:

double *p, *pd[20];
for (i=0; i&#60 19; i++)
{
p = new double; *p = i; pd[i] = p;
}
pd[i] = NULL;

Вариант 4. Все переменные, в том числе и массив указателей, создаются динамически. Результатом работы является указатель на создаваемый массив указателей (адрес массива указателей) (см. ниже " динамические массивы указателей " ):

double **pp, *p;
pp = new double *[20]; // память под массив

for (i=0; i&#60 19; i++) // из 20 указателей типа double*

{
p = new double;
*p = i; pp[i] = p;
}
pp[i] = NULL;

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

void clreol(void);
// Очистка строки от текущей позиции курсора до конца

votd clrscr(void);
// Очистка экрана

char *cgets(char *str);
// Чтение строки с терминала в str

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

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

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

// Возвращает &#38str[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);
// Установка режим повышенной яркости выводимых символов

// (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)

Функции для работы со строками (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. Возвращает

int strcmp(char *s1, char *s2);
// Сравнение строк s1 и s2 по значениям кодов символов (без

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

// -1 - s1 &#60 s2

// 0 - s1 = s2

// 1 - s1 &#62 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

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

.
------------------------------- Форматированный вывод --¬
¦ int printf(char *format,...) ¦
¦ - стандартный вывод ¦
¦ int fprintf(FILE *fd, char *format,...) ¦
¦ - явно указанный файл ¦
¦ int sprintf(char *str, char *format,...) ¦
¦ ¦ - строка в памяти ¦
¦ L--- число выведенных байтов или EOF ¦
L--------------------------------------------------------
------------------------------- Форматированный ввод ---¬
¦ int scanf(char *format,...) ¦
¦ - стандартный ввод ¦
¦ int fscanf(FILE *fd, char *format,...) ¦
¦ - явно указанный файл ¦
¦ int sscanf(char *str, char *format,...) ¦
¦ ¦ - строка в памяти ¦
¦ L--- число фактических параметров, для которых ¦
¦ введены значения, или EOF ¦
L--------------------------------------------------------

.
-- форматная строка ---¬ -------¬ фактические
printf("....%***...%***...%***",p1,p2,p3); параметры
¦ ¦ L-&#62&#62-¦--¦--- переменного
¦ L---&#62&#62------¦--- списка
L-----&#62&#62------------

Спецификация формата ввода-вывода фактического параметра ([] обозначают необязательную часть) .

.
% [флаги][ширина][.точность][модификатор] тип ------------¬
¦ ¦ ¦ +- "F" far-указатель ¦
¦ ¦ ¦ +- "N" near-указатель ¦
¦ ¦ ¦ +- "h" параметр типа short ¦
¦ ¦ ¦ L- "l" параметр типа long ¦
¦ ¦ ¦ или double (для scanf)¦
¦ ¦ +- "0" без дробной части ¦


¦ ¦ +- n не более n знаков после точки ¦
¦ ¦ L- * задается следующим фактическим ¦
¦ ¦ параметром функции ¦
¦ +- n минимальная ширина поля n (незаполненные ¦
¦ ¦ позиции - пробелы) ¦
¦ +- 0n то же, незаполненные позиции - нули ¦
¦ L- "*" задается следующим фактическим ¦
¦ параметром функции ¦
+- "-" выравнивание по левому краю поля ¦
¦ (по умолчанию - по правому) ¦
+- "+" выводится знак числа ("+" или "-") ¦
+- " " выводится пробел перед положительным числом ¦
L- "&#35" выводится идентификатор системы счисления ¦
("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)

Функции -элементы структуры

struct dat
{
int day,month,year;
int TestData(); // Проверка даты

void NextData(); // Добавить 1 день

void PlusData(int n) // Добавить n дней

{
while(n-- !=0) NextData();
}
};

static int mm[] = {31,28,31,30,31,30,31,31,30,31,30,31};
//----------- Проверка на корректность ------------------

int dat::TestData()
{
if (month ==2 &#38&#38 day==29 &#38&#38 year %4 ==0) return(1);
if (month ==0 || month &#62 12 || day ==0 || day &#62mm[month])
return(0);
return(1);
}
//----------- Следующая дата ----------------------------

void dat::NextData()
{
day++;
if (day &#60= mm[month]) return;
if (month ==2 &#38&#38 day==29 &#38&#38 year %4 ==0) return;
day=1;
month++;
if (month !=13) return;
month=1;
year++;
}
//--------- Основная программа --------------------------

void main()
{
dat a;
do cin &#60&#60 a.day &#60&#60 a.month &#60&#60 a.year;
while(a.TestData() ==0);
a.PlusData(17);
}

Как видно из примера, в качестве элементов структуры могут выступать функции. Такие элементы-функции имеют следующие особенности:

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

. имя_структуры::имя_функции

this-&#62month = 5;
this-&#62day++;
month = 5;
day++;

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

. имя_переменной.имя_функции (список_параметров)

Приведем фрагмент этой же программы в виде эквивалента на " классическом" Си:

void dat_PlusData(dat *this, int n)
//---------- Добавить n дней ----------------------------

{
while(n-- !=0) NextData(this);
}
void dat_NextData(dat *this)
//----------- Следующая дата ----------------------------

{
this-&#62day++;
...
this-&#62month=1;
this-&#62year++;
}
//--------- Основная программа --------------------------

void main()
{ dat a;
...
dat_PlusData(&#38a,17);
}

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

.
--------------------------------------------------------¬
¦ режим работы с файлом --------¬ ¦
¦ имя файла --------¬ ¦ ¦
¦ ¦ ¦ ¦
¦ FILE *fopen(char *name, char *mode)- открыть файл ¦
¦ ¦ ¦
¦ L--- указатель на дескриптор файла или NULL ¦
¦ ¦
¦ int fclose(FILE *fd) - закрыть файл ¦
¦ ¦ ¦
¦ L--- 0 или EOF (ошибка) ¦
¦ ¦
¦ int fcloseall(void) - закрыть все ¦
¦ ¦ ¦
¦ L--- число закрытых файлов или EOF ¦
¦ ¦
¦ FILE *freopen(char *name, char *mode, FILE *fd) ¦
¦ - закрыть и открыть повторно ¦
¦ ¦
¦ FILE *tmpfile(void) - создать и открыть временный ¦
¦ файл с уникальным именем ¦
L--------------------------------------------------------