Sn = Sn + i
Программа
#include <stdio.h>
#include <conio.h>
#include <math.h>
Int main()
{
int n, sn=0;
printf(“\nДо какого числа суммировать:”);
scanf(“%d”, &n);
for (int i = 1; i <= n; i++)
{
sn+=i;
}
printf(“\nСумма чисел от 1 до %d равна %d ”, n, sn);
return 0;
}
СТРУКТУРЫДАННЫХ
В повседневной практике обработки информации мы часто имеем дело с естественно организованными (объединенными) представлениями информации: текстами, списками, таблицами, анкетами. Такие организованные (структурированные) данные во многом облегчают их восприятие и обработку.
Естественная организация данных эффективно отражается в современных языках программирования понятием структур данных.
Под структурами данных понимаются специальным образом организованные совокупности данных, облегчающие реализацию алгоритма и их компьютерную обработку.
Отличительной особенностью хорошо написанных программ является то, что данные в них организованы в определенные, наиболее подходящие для их хранения и обработки структуры, а сами программы являются лишь средством обработки этих структур независимо от их информационного содержания. Проектирование подходящих структур данных для их эффективной обработки программой столь же важно, и занятие это, возможно, более сложное, чем написание собственно операторов программы в соответствии с выбранным алгоритмом их обработки. Хорошо спроектированные структуры данных облегчают и ускоряют их обработку, улучшают понимание самой программы.
К базовым структурамданных в Си относятся:
· переменные,
· массивы,
· строки,
· смеси,
· структуры,
· файлы.
Из этих структур можно конструировать более сложные, например файлы структур (базы данных).
Понятие переменных было введено раньше – это структура данных, состоящая из отдельных элементов, каждый из которых имеет имя, тип и конкретное значение.
Массивы
В программировании часто встречаются задачи, связанные с хранением и обработкой большого количества однотипных данных. Например, требуется ввести оценки по информатике для 25 студентов группы ИС-09 и определить средний балл. Для решения этой задачи опишем 25 переменных: is09_1, is09_2,is09_3, …, is09_25:
int is09_1, is09_2, is09_3, …, is09_25;
Каждая из них будет соответствовать одному студенту. После этого используем 25 операторов для ввода оценок:
printf(“\nОценка первого:”);
scanf(“%d”, &is09_1);
printf(“\nОценка второго:”);
scanf(“%d”, &is09_2);
...
printf(“\nОценка двадцать пятого:”);
scanf(“%d”, &is09_25);
И, наконец, определим средний балл:
float sr_ball;
sr_ball=(is09_1+is09_2+is09_3+... +is09_25)/25.0;
А что произойдет, если нужно будет решить эту задачу для всего университета? Описывать и вводить несколько тысяч переменных?
Для решения таких задач используют массивы. Для структур, используемых
в алгоритмизации, организация массивов представляется наиболее удобной для программирования. Это связано с возможностью непосредственного логического доступа
к любому их элементу без обращения к предыдущим элементам, что обеспечивает простоту взаимодействия между логической организацией данных и их физическим представлением, поскольку массив легко проецируется на оперативную память. Это обстоятельство оказалось столь удобным для программирования, что для большинства структур данных разработаны механизмы их эмуляции на базе массивов.
Массив состоит из конечного числа элементов (компонент), содержимое которых относится к некоторому общему, базовому типу. При этом сам базовый тип должен быть таким, что принадлежность к нему гарантирует одинаковые размеры памяти для размещения каждой из компонент. Элементы различаются местом их размещения внутри структуры, иначе говоря, номером, или индексом. Обычным является непрерывное представление массива, как логическое, так и физическое, то есть логический (описанный в программе) массив проецируется на непрерывный участок оперативной памяти. Значит, необходимо, чтобы такой участок существовал. Отсюда вытекают ограничения на размер массива, диктуемые организацией оперативной памяти: массив должен поместиться в сегмент данных программы, размеры которого фиксированы. И, конечно, данные в массивах сохраняются только до конца работы программы.
Таким образом, массив представляет собой структуру данных, определяемую на основе следующих своих свойств:
1) массив состоит из однотипных элементов, при этом используемый тип называется базовым,
2) число элементов массива строго фиксировано,
3) элементы массива упорядочены в том смысле, что каждому из них соответствует один или несколько индексов, позволяющих однозначно указать его расположение в составе структуры,
4) количество индексов, которое связано с отдельным элементом массива, определяет его размерность (одномерные, двумерные, трехмерные…),
5) число элементов массива совпадает с общим количеством возможных значений его индексов,
6) массив – именованная совокупность данных, причем использование его имени совместно с индексами позволяет определять значения его элементов,
7) доступ к элементам массива является прямым, то есть любой элемент массива полностью определяется своими индексами, и возможности доступа к нему не зависят от других элементов.
Массивы можно определить и через понятия математики.
В современной математике для описания и решения многих задач используются матрицы и вектора.
МатрицейAnm называется таблица чисел, состоящая из n строк и m столбцов.
Каждый элемент матрицы aij полностью определяется своими индексами – номерами строки i и столбца j, в которых он расположен.
Количество индексов определяет размерность матрицы: одномерная матрица (вектор), двумерная, трехмерная и т. д.
Максимальное значение каждого индекса определяет размер матрицы.
В качестве аналога матриц в программировании выступают массивы.
Массив – это упорядоченный набор фиксированного количества однотипных компонентов, имеющих общее имя – имя массива и различающихся значениями своих индексов. В зависимости от количества индексов компонентов (элементов) массива различают одномерные (вектора), двумерные (матрицы) и т. д. массивы.
Элементы векторов хранятся в оперативной памяти компьютера в расположенных друг за другом ячейках в том порядке, в котором они размещены в векторе. Таким образом, структура вектора полностью соответствует структуре оперативной памяти компьютера, поэтому остальные структуры данных размещаются в памяти так, как они размещались бы в одномерных массивах.
Двумерный массив состоит из элементов, образующих прямоугольную таблицу, причем первый индекс элемента обозначает номер строки, а второй – номер столбца этой таблицы, на пересечении которых расположен данный элемент:
a11 a12 a13 …
a21 a22 a23 …
a31 a32 a33 …
……………………..
Таким образом, двумерный массив полностью соответствует понятию матрицы. В оперативной памяти элементы двумерного массива расположены последовательно, строка за строкой: сначала элементы первой строки, затем второй и так далее: a11, a12, a13,…, a21, a22, a23,…, a31, a32, a33,… Значит, второй индекс (номер столбца) изменяется быстрее, чем первый (номер строки).
Многомерные массивы располагаются в памяти компьютера так, что сначала изменяется последний индекс элемента, затем – предпоследний и так далее.
Массив как структура данных характеризуется тем, что с помощью индексов обеспечивается прямой (непосредственный) доступ к каждому его элементу: чтение или запись любого элемента массива не зависит от того, прочитаны или записаны предшествующие ему элементы.
Тип элементов массива называется его базовым типом. В Си это может быть любой стандартный (целый, вещественный, символьный) или пользовательский (массив структур, файлов, функций) тип данных.
Индексы элементов массива могут быть только целыми положительными числами и начинаются с нуля. Перед использованием массива в программе его необходимо описать – назвать его имя, указать его размеры (количество элементов, строк, столбцов…) и базовый тип:
int vect[5];
float matr[2][3];
char str[20];
Описаны:
- одномерный массив целых чисел (вектор) vect, состоящий из пяти элементов,
- двумерный массив (матрица) вещественного типа matr, имеющая две строки и три столбца,
- строка символов str из 20 элементов.
Как видно, при описании массива в Си каждая его размерность записывается в отдельных скобках, а не перечисляется через запятые, как в Паскале. Размеры массива можно задать именованной константой или указать в директиве #define – это считается хорошим стилем программирования:
#define count 5
#define row 2
#define col 3
#define n_str 20
int vect[count];
float matr[row][col];
char str[n_str];
Индексы элементов массивов в Си всегда начинаются с нуля, поэтому, например, описанный вектор vect имеет следующие элементы:
vect[0] vect[1] vect[2] vect[3] vect[4]
а двумерный массив matr – 6 следующих элементов:
matr[0][0] matr[0][1] matr[0][2]
matr[1][0] matr[1][1] matr[1][2]
Таким образом, первая строка и первый столбец двумерного массива имеют индекс 0.
Элементы массива можно использовать во всех выражениях, операторах
и функциях, определенных для их типа.
Начальные значения элементам массива в Си можно задавать при их описании (инициализировать массив), при этом размеры одномерных массивов (векторов) в квадратных скобках можно не указывать – для их хранения будет отведено столько ячеек оперативной памяти, сколько значений указано в фигурных скобках:
int vect[] = {-5, 3, -2, 8, 1};
float matr[2][3] = {{0.2, -1.5, 3.14},
{-2.73, 25.54, 0.89}};
Если задано значений меньше, чем описано элементов вектора, то недостающие элементы инициализируются нулями:
int vect[5] = {-5, 3, -2};
Последние два элемента вектора vect инициализируются нулями.
Еще раз необходимо обратить внимание на то, что в отличие от Паскаля при описании и при работе с многомерными массивами в Си каждый индекс элемента массива заключается в отдельные квадратные скобки:
matr[1][2]=0.89;
Если использовать запись matr[1,2], то она будет интерпретироваться как matr[2]. Согласно правилам языка Си, значением всего выражения в скобках является результат вычисления последнего выражения, перед которым стоит запятая.
В отличие от Паскаля конкретные размеры массива в Си можно задать с клавиатуры до его описания:
int row, col;
printf(“\n row=”);
scanf(“%d”, &row);
printf(“\n col=”);
scanf(“%d”, &col);
float matr[row][col];
Примеры:
1. Ввести с экрана элементы целочисленного массива matr33, вывести его на экран, транспонировать (заменить строки соответствующими столбцами) и снова вывести на экран:
#include <stdio.h>
#include <conio.h>
#include <math.h>
Int main()
{
const int row=3, col=3;
int temp;
int matr[row][col];
printf(“\nВведите 3 элемента нулевой строки через пробелы: ”);
scanf(“%d%d%d”, &matr[0][0], &matr[0][1], &matr[0][2]);
printf(“\nВведите 3 элемента первой строки через пробелы: ”);
scanf(“%d%d%d”, &matr[1][0], &matr[1][1], &matr[1][2]);
printf(“\nВведите 3 элемента второй строки через пробелы: ”);
scanf(“%d%d%d”, &matr[2][0], &matr[2][1], &matr[2][2]);
printf(“\nВведенный массив:”);
printf(“\n%5d%5d%5d”, matr[0][0], matr[0][1], matr[0][2]);
printf(“\n%5d%5d%5d”, matr[1][0], matr[1][1], matr[1][2]);
printf(“\n%5d%5d%5d”, matr[2][0], matr[2][1], matr[2][2]);
// транспонируем матрицу
temp=matr[0][1];
matr[0][1]=matr[1][0];
matr[1][0]=temp;
temp=matr[0][2];
matr[0][2]=matr[2][0];
matr[2][0]=temp;
temp=matr[1][2];
matr[1][2]=matr[2][1];
matr[2][1]=temp;
// снова выводим ее на экран
printf(“\nТранспонированный массив:”);
printf(“\n%5d%5d%5d”, matr[0][0], matr[0][1], matr[0][2]);
printf(“\n%5d%5d%5d”, matr[1][0], matr[1][1], matr[1][2]);
printf(“\n%5d%5d%5d”, matr[2][0], matr[2][1], matr[2][2]);
printf(“\n”);
return 0;
}
2. Рассортировать элементы заданного случайным образом целочисленного вектора vector[n] методом обменной сортировки (пузырька):
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <time.h>
Int main()
{
int i, m, vector_min, vector_max, temp;
time_t t;// текущее время для инициализации
// генератора случайных чисел
srand((unsigned) time(&t));// инициализация генератора
// случайных чисел
printf("\nВведите нижнюю границу:");
scanf(“%d”, &vector_min);
printf("\nВведите верхнюю границу:");
scanf(“%d”, &vector_max);
printf("\nВведите размер вектора:");
scanf(“%d”, &n);
int vector[n];
printf("\nИсходный вектор:\n");
m = vector_max–vector_min + 1;
for (i=0; i<n; i++)
{
// получение случайного числа в диапазоне
// от vector_min до vector_max
vector[i]=rand()% m + vector_min;
printf(" %5d", vector[i]);
}
printf("\n");
for (m=n-2; m>=0;m--)
for (i=0; i<=m;i++)
if (vector[i] > vector[i+1])
{
temp=vector[i];
vector[i]=vector[i+1];
vector[i+1]=temp;
}
printf("\nОтсортированный вектор:\n");
for (i=0; i<n; i++)
{
printf(" %5d", vector[i]);
}
printf("\n");
return 0;
}
3. Рассортировать элементы заданного случайным образом целочисленного вектора vector[n] методом Шелла (обменная сортировка с убывающим шагом).
В этом случае массив делится на группы по два элемента и производится сортировка в каждой группе: максимальный элемент ставится на второе место. После этого массив делится на группы по четыре элемента, и они снова сортируются. Количество элементов в сортируемой группе удваивается до тех пор, пока не остается одна группа, включающая все элементы массива, которая и сортируется окончательно:
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <time.h>
Int main()
{
int vector_min, vector_max, temp;
int i, i1, i2, i3, m, per;
time_t t;// текущее время для инициализации
// генератора случайных чисел
srand((unsigned) time(&t)); // инициализация генератора
// случайных чисел
printf("\nВведите нижнюю границу:");
scanf(“%d”, &vector_min);
printf("\nВведите верхнюю границу:");
scanf(“%d”, &vector_max);
printf("\nВведите размер вектора:");
scanf(“%d”, &n);
int vector[n];
printf("\nИсходный вектор:\n");
m= vector_max–vector_min + 1;
for (i=0; i<n; i++)
{
// получение случайного числа в диапазоне
// от vector_min до vector_max
vector[i]=rand()% m + vector_min;
printf(" %5d", vector[i]);
}
printf("\n");
i1=n-1;
while (i1>=1)
{
i1 /= 2;
i2=n-i1-1;
do
{
per=1;
for (i=0; i<=i2; i++)
{
i3=i+i1;
if (vector[i] > vector[i3])
{
temp=vector[i];
vector[i]=vector[i3];
vector[i3]=temp;
per=0;
} // if (vector[i] > vector[i3])
} // for (i=0; i<=i2; i++)
} // do
while (!per);
} // while (i1>=1)
printf("\nОтсортированный вектор:\n");
for (i=0; i<n; i++)
{
printf(" %5d", vector[i]);
}
printf("\n");
return 0;
}
Файлы
В общем случае файлом называется последовательность некоторых однотипных информационных компонентов, сохраняемая во внешней памяти компьютера под одним именем. На этом основании файл считается структурой данных.
Полномасштабная работа с файлами принадлежит к прерогативам операционной системы. Здесь мы используем специальные команды создания, просмотра, копирования и удаления файлов, знакомимся с их свойствами, сортируем их, а также объединяем в иерархическую древовидную структуру каталогов. Однако выполнение всех перечисленных операций с файлами организуется и осуществляется, как правило, вручную. Средства работы с файлами, предусмотренные в Си, позволяют автоматизировать эти функции.
Существуют задачи, для которых заранее невозможно определить количество выходных или входных данных. Оно определяется только в процессе решения конкретной задачи, то есть при работе программы. Поэтому возникла необходимость
в специальной структуре данных, которая представляла бы собой последовательность компонентов, в общем случае разнотипных, причем длина этой последовательности заранее не определялась, а конкретизировалась при выполнении программы. К тому же эта структура данных должна была бы храниться не в оперативной памяти компьютера, а на внешних устройствах.
В современных алгоритмических языках такую структуру данных называют файлом.
В отличие от рассмотренных выше структур данных – массивов, при описании которых необходимо задавать их точный размер для выделения в оперативной памяти необходимого количества ячеек для их размещения, при описании файлов их размер не указывается.
Вторым отличием от массивов – структур данных с произвольным (прямым) доступом к любому их элементу (можно обратиться, например, к пятому элементу вектора, предварительно не считывая предыдущие четыре элемента), файлы являются структурами, как с произвольным, так и с последовательным доступом – для обращения к их пятому элементу необходимо прочитать предыдущие четыре.
Таким образом, файл – это упорядоченная совокупность однотипных элементов, имеющая произвольную длину, прямой или последовательный доступ.
Аналогом файлов является магнитофонная лента: количество записей в ней заранее неизвестно, всегда доступна для прослушивания только текущая запись, и для прослушивания очередной записи необходимо прослушать или перемотать все предыдущие.
Файлы, используемые в Си, делятся на физические (внешние) и логические (внутренние). Физические файлы являются средствами обмена данными и хранятся на внешних носителях. Это единственная структура, посредством которой данные, обрабатываемые программой, могут быть получены извне, а результаты работы программы могут быть переданы во внешний мир и сохранены.
Таким образом, физические (внешние) файлы сохраняются после окончания работы программы, их создавшей, и данные, записанные в них, могут быть использованы для дальнейшей работы.
Логические файлы хранятся в оперативной памяти компьютера во время работы программы, их создавшей, и стираются после окончания ее работы. На логическом уровне в качестве информационных компонентов файлов могут выступать любые структуры данных: числа, символы, строки, массивы. На физическомуровне универсальным информационным компонентом любого файла является байт. Иначе говоря, содержимое любого файла представляет собой последовательность байтов.
Взаимоотношения данной программы с последовательностью байтов данного файла могут строиться по-разному в зависимости от того, каким определен тип файла
в программе.
В Си различают два типа внешних файлов:
1) текстовые;
2) бинарные (двоичные).
Текстовые файлы
Текстовые файлы представляют собой последовательность строк различной длины, каждая из которых заканчивается меткой EOLn – End Of Line – конец строки (последовательность символов #13#10). В конце файла стоит метка EOF – End Of File.
Запись данных в текстовый файл практически не отличается от вывода данных на экран терминала. Чтение же данных из текстового файла имеет свои особенности.
Объявляется текстовый файл указателем на него:
FILE *f;
где f – указатель на файл – имя логического файла (файловая переменная),
FILE – служебное слово – только заглавными буквами!
Перед началом работы с файлом необходимо связать имя логического файла (файловую переменную) с соответствующим ему физическим файлом на внешнем носителе – открыть файл:
f=fopen(“путь”, “режим”);
где путь – полный путь к файлу на внешнем носителе,
режим – режим открытия файла:
r – чтение (read),
w – запись (write),
a – добавление в конец файла (append),
r+ – чтение с обновлением (r + w),
w+ – запись с обновлением,
a+ – добавление с обновлением.
FILE *f_text;
f_text=fopen(“D:/User/my_file.txt”, “w”); // по указанному
// пути создан текстовый файл
// my_file.txt и открыт
// для записи
Если файл с таким именем уже существовал, то он очищается (из него удаляется информация).
Форматная запись (вывод) в файл осуществляется функцией:
fprintf(указатель на файл, формат вывода, список вывода);
Пример 1: записать в файл my_file.txt построчно значения элементов следующего массива mass34:
1 2 3 4
5 6 7 8
9 10 11 12
Программа
const int n=3;
const int m=4;
const int k=m*m;
int i, j;
int mass[n][m]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int vector[k];
FILE *f_text;
f_text=fopen(“D:/User/my_file.txt”, “w”); // файл открыт
// для записи
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
fprintf(f_text, “%5d”, mass[i][j]);
fprintf(f_text, “\n”);
}
fclose(f_text); // после записифайл обязательно закрыть!
Структура файла my_file.txt:
1 2 3 4
5 6 7 8
9 10 11 12
Внимание! При записи чисел в текстовый файл оставлять между ними хотя бы по одному пробелу!
Перед чтением данных из файла его необходимо открыть для чтения:
f=fopen(“путь”, “r”);
Если файл не найден, то значение указателя f будет равно NULL.
Форматированное чтение (ввод) из файла осуществляется функцией:
fscanf(указатель на файл, формат ввода, список ввода);
Прочитаем созданный файл и запишем числа в вектор vector16:
f_text=fopen(“D:/User/my_file.txt”, “r”); // файл открыт
// для чтения
for (i=0; i<k; i++) // обнуляем вектор
vector[i]=0;
i=0; // индекс очередного элемента
while (!feof(f_text)) // пока не конец файла
{
fscanf(f_text, “%d”, &j); // читаем из него данные
vector[i]=j; // и записываем в вектор
i++;
}
printf("\nVector_1:\n");
for (i=0; i<k; i++)
printf("%4d", vector[i]);
printf("\n");
На экран будет выведено:
Vector_1:
1 2 3 4 5 6 7 8 9 10 11 12 0 0 0 0
Добавим в последнюю строку файла последовательность чисел 4, 3, 2, 1:
f_text=fopen(“D:/User/my_file.txt”, “a”); // файл открыт
// для добавления
for (i=4; i>0; i--)
fprintf(f_text, “%5d”, i);
fprintf(f_text, “\n”);
fclose(f_text); // после записифайл обязательно закрыть!
Структура файла my_file.txt:
1 2 3 4
5 6 7 8
9 10 11 12
4 3 2 1
Снова прочитаем созданный файл и запишем числа в вектор vector16:
f_text=fopen(“D:/User/my_file.txt”, “r”); // файл открыт
// для чтения
for (i=0; i<k; i++) // обнуляем вектор
vector[i]=0;
i=0; // индекс очередного элемента
while (!feof(f_text)) // пока не конец файла
{
fscanf(f_text, “%d”, &j); // читаем из него данные
vector[i]=j; // и записываем в вектор
i++;
}
printf("\nVector_2:\n");
for (i=0; i<k; i++)
printf("%4d", vector[i]);
printf("\n");
На экран будет выведено:
Vector_2:
1 2 3 4 5 6 7 8 9 10 11 12 4 3 2 1
Пример 3: создать базу данных на текстовом файле my_base.txt – в каждой его строке записать следующие данные о студентах:
группа – строка длиной 10 символов,
фамилия – строка длиной 20 символов,
имя – строка длиной 10 символов,
средний балл сессии – вещественное число,
оценка по информатике – целое число.
Опишем исходные данные:
char gruppa[10];
char fam[20];
char name[10];
float sr_ball;
int ocenka;
Создадим текстовый файл my_base.txt и откроем его для записи:
FILE *f_base; // указатель на создаваемый файл
f_base=fopen(“D:/User/my_base.txt”, “w”);
Данные в базу будем вводить циклом с постусловием. Интерфейс программы:
Gruppa: IS-09
Familija: Pupkin
Imja: Vasilij
Sr. ball: 3.14
Ocenka: 3
Gruppa: IS-09
Familija: Ivanov
Imja: Ivan
Sr. ball: 4.09
Ocenka: 5
Gruppa: 0
Запросы продолжаются до тех пор, пока вместо номера группы не введем цифру ноль – это терминатор (прерыватель цикла ввода).
После ввода данных об очередном студенте записываем их в файл форматным способом, указывая длину каждого записываемого данного:
fprintf(f_base, “%10s%20s%10s%5.2f%2d\n”, gruppa, fam, name, sr_ball, ozenka);
Программа
FILE *f_base; // указатель на создаваемый файл
char gruppa_1[10];
char fam_1[20];
char name_1[10];
float sr_ball;
int ocenka;
f_base=fopen("D:/User/my_base.txt", "w");
do
{
printf("\n gruppa:");
scanf("%s", gruppa);
if (gruppa[0]=='0') // если ноль – выход из цикла ввода
break;
printf("\n familija:");
scanf("%s", fam);
printf("\n imja:");
scanf("%s", name);
printf("\n sr. ball:");
scanf("%f", &sr_ball);
printf("\n ocenka:");
scanf("%d", &ocenka);
fprintf(f_base, "%10s%20s%10s%7.2f%5d\n", gruppa, fam, name, sr_ball, ocenka);
}
while (1); // псевдобесконечный цикл
fclose(f_base); // после записи файл обязательнозакрыть!
Структура файла:
IS-09 Pupkin Vasilij 3.14 3
IS-09 Ivanov Ivan 4.09 5
Прочитаем этот файл с выводом на экран прочитанных данных:
f_base=fopen("D:/User/my_base.txt", "r"); // файл открыт
// для чтения
while (!feof(f_base)) // пока не конец файла
{ // читать данные
fscanf(f_base, "%s%s%s%f%d", gruppa, fam, name, &sr_ball, &ocenka);
printf("\n%10s%20s%10s%7.2f%5d", gruppa, fam, name, sr_ball, ocenka); // и выводить их на экран
}
На экран будет выведено:
IS-09 Pupkin Vasilij 3.14 3
IS-09 Ivanov Ivan 4.09 5
Таким образом, текстовые файлы могут хранить разнотипную информацию, что можно использовать для создания баз данных.
Бинарные файлы
Бинарные файлы представляют собой последовательность символов длиной один байт, нумерация которых начинается с нуля. В конце файла стоит метка EOF – End Of File.
Объявляется бинарный файл так же, как и текстовый:
FILE *f;
где f – указатель на файл – имя логического файла,
FILE – служебное слово – только заглавными буквами!
Перед началом работы с файлом необходимо связать имя логического файла (файловую переменную) с соответствующим ему физическим файлом на внешнем носителе – открыть файл:
f=fopen(“путь”, “режим”);
где путь – полный путь к файлу на внешнем носителе,
режим – режим открытия файла:
rb – чтение (b – binary – бинарный, двоичный),
wb – запись,
ab – добавление в конец файла,
r+b – чтение с обновлением (rb + wb),
w+b – запись с обновлением,
a+b – добавление с обновлением.
FILE *f_bin;
f_bin=fopen(“D:/User/my_file.dat”, “wb”);
// по указанному
// пути создан бинарный файл
// my_file.dat и открыт
// для записи
Если файл с таким именем уже существовал, то он очищается (из него удаляется информация).
Форматированная запись (вывод) в файл осуществляется функцией
fprintf(указатель на файл, формат вывода, список вывода);
Пример: записать в файл my_file.dat строку символов abc12345+*-/%&@
FILE *f_bin;
const int n=15;
int i;
char d;
char str[n]=”abc12345+*-/%&@”;
f_bin=fopen(“D:/User/my_file.dat”, “wb”); // файл открыт
// для записи
for (i=0; i<n; i++)
fprintf(f_bin, “%c”, str[i]); // запись в файлпосимвольно
fclose(f_bin); // после записифайл обязательно закрыть!
Структура файла my_file.dat:
abc12345+*-/%&@
Внимание! В бинарных файлах нельзя использовать символ перехода на новую строку.
Перед чтением (вводом) данных из файла его необходимо открыть для чтения:
f=fopen(“путь”, “rb”);
Если файл не найден, то значение указателя f будет равно NULL.
Форматированное чтение (ввод) из файла осуществляется посимвольно функцией
fscanf(указатель на файл, формат ввода, список ввода);
Прочитаем созданный бинарный файл посимвольно и выведем на экран:
f_bin=fopen("D:/User/my_file.dat", "rb");
while (!feof(f_bin)) // пока не конец файла
{
fscanf(f_bin, "%c", &d); // читаем очереднойсимвол
// в переменную d
printf("%c", d);
}
На экран будет выведено:
abc12345+*-/%&@
Над бинарными файлами определены следующие операции:
a) перемещение указателя файла в заданную позицию