Читайте также:
|
Cтруктуры - это составной объект, в который входят элементы любых типов, за исключением функций. В отличие от массива, который является однородным объектом, структура может быть неоднородной. Тип структуры определяется записью вида:
struct { список определений }
В структуре обязательно должен быть указан хотя бы один компонент. Определение структур имеет следующий вид:
тип-данных описатель;
где тип-данных указывает тип структуры для объектов, определяемых в описателях. В простейшей форме описатели представляют собой идентификаторы или массивы.
Пример:
struct { double x,y; } s1, s2, sm[9];
struct { int year;
char moth, day; } date1, date2;
Переменные s1, s2 определяются как структуры, каждая из которых состоит из двух компонент х и у. Переменная sm определяется как массив из девяти структур. Каждая из двух переменных date1, date2 состоит из трех компонентов year, moth, day. >p>Существует и другой способ ассоциирования имени с типом структуры, он основан на использовании тега структуры. Тег структуры аналогичен тегу перечислимого типа. Тег структуры определяется следующим образом:
struct тег { список описаний; };
где тег является идентификатором.
В приведенном ниже примере идентификатор student описывается как тег структуры:
struct student { char name[25];
int id, age;
char prp; };
Тег структуры используется для последующего объявления структур данного вида в форме:
struct тег список-идентификаторов;
Пример:
struct studeut st1,st2;
Использование тегов структуры необходимо для описания рекурсивных структур. Ниже рассматривается использование рекурсивных тегов структуры.
struct node { int data;
struct node * next; } st1_node;
Тег структуры node действительно является рекурсивным, так как он используется в своем собственном описании, т.е. в формализации указателя next. Структуры не могут быть прямо рекурсивными, т.е. структура node не может содержать компоненту, являющуюся структурой node, но любая структура может иметь компоненту, являющуюся указателем на свой тип, как и сделано в приведенном примере.
Доступ к компонентам структуры осуществляется с помощью указания имени структуры и следующего через точку имени выделенного компонента, например:
st1.name="Иванов";
st2.id=st1.id;
st1_node.data=st1.age;
60.
61.
Для доступа к файлу применяется тип данных FILE. Это структурный тип, имя которого задано с помощью оператора typedef в стандартном заголовочном файле <stdio.h>. Программисту не нужно знать, как устроена структура типа файл: ее устройство может быть системно зависимым, поэтому в целях переносимости программ обращаться явно к полям структуры FILE запрещено. Тип данных "указатель на структуру FILE” используется в программах как черный ящик: функция открытия файла возвращает этот указатель в случае успеха, и в дальнейшем все файловые функции применяют его для доступа к файлу.
Прототип функции открытия файла выглядит следующим образом:
FILE *fopen(const char *path, const char *mode);
Здесь path - путь к файлу (например, имя файла или абсолютный путь к файлу), mode - режим открытия файла. Строка mode может содержать несколько букв. Буква "r" (read) означает, что файл открывается для чтения (файл должен существовать). Буква "w" (write) означает запись в файл, при этом старое содержимое файла теряется, а в случае отсутствия файла он создается. Буква "a" (от слова append) означает запись в конец существующего файла или создание нового файла, если файл не существует.
В некоторых операционных системах имеются различия в работе с текстовыми и бинарными файлами (к таким системам относятся MS DOS и MS Windows; в системе Unix различий между текстовыми и бинарными файлами нет). В таких системах при открытии бинарного файла к строке mode следует добавлять букву "b" (от слова binary), а при открытии текстового файла -- букву "t" (от слова text). Кроме того, при открытии можно разрешить выполнять как операции чтения, так и записи; для этого используется символ + (плюс). Порядок букв в строке mode следующий: сначала идет одна из букв "r", "w", "a", затем в произвольном порядке могут идти символы "b", "t", "+". Буквы "b" и "t" можно использовать, даже если в операционной системе нет различий между бинарными и текстовыми файлами, в этом случае они просто игнорируются.
Режим - определяет, каким образом файл будет открыт. Ниже в таблице показаны допустимые значения режимов.
| Режим | Что обозначает данный режим |
| r | Открыть текстовый файл для чтения |
| w | Создать текстовый файл для записи |
| a | Добавить в конец текстового файла |
| wb | Создать двоичный файл для записи |
| rb | Открыть двоичный файл для чтения |
| ab | Добавить в конец двоичного файла |
| r+ | Открыть текстовый файл для чтения/записи |
| w+ | Создать текстовый файл для чтения/записи |
| a+ | Добавить в конец текстового файла или создать текстовый файл для чтения/записи |
| r+b | Открыть двоичный файл для чтения/записи |
| w+b | Создать двоичный файл для чтения/записи |
| a+b | Добавить в конец двоичного файла или создать двоичный файл для чтения/записи |
# include <stdio.h>
# include <stdlib.h>
/**/
Main()
{
FILE *fp;
Clrscr();
if ((fp = fopen("test", "w")==NUL)
{
cprintf("Ошибка при открытии файла.\n\r")"
gench();
}
Crpintf("Открытие файла прошло нормально.\n\r");
gench();
}
62.
при помощи fgets
Функция fgets применяется для чтения строки из потока. Считывание происходит до тех пор пока не будет достигнут конец строки (\n) или длина строки, в которую происходит считывание. Предположим, у нас есть файл some_file.txt с текстом
палиндромы
А в Енисее - синева.
А лама мала.
А лис, он умён - крыса сыр к нему носила. (И. Бабицкий)
#include <stdio.h>
#include <string.h>
int main (int argc, char* argv[]) /* argc хранит количество параметров, а argv[] указатели на эти параметры.
Например если мы запустим выполняемый файл "fgets_example param1 param2" то argc будет равно 2, а argv[] = {"fgets_example", "param1", "param2"}*/
{
FILE *file;
char *fname = "some_file.txt";
char result_sting[20]; //Строка в 20 символов
file = fopen(fname,"r");
if(file == 0)
{
printf("не могу открыть файл '%s'",fname);
return 0;
}
int i=0;
char *real_tail;
while(fgets(result_sting,sizeof(result_sting),file))
{
real_tail="";
printf("Строка %d:Длина строки - %d:",i++,strlen(result_sting));
if(result_sting[strlen(result_sting)-1] == '\n')//проверяем является ли последний элемент в строке символом ее окончания
{
real_tail="\\n";
result_sting[strlen(result_sting)-1]='\0';
};// эта часть кода добавленна лишь для отображения символа конца строки в консоль без перевода на новую строку
printf("%s%s\n",result_sting,real_tail);
}
fclose(file);
return 0;
}
в результате выполнения мы получим
Строка 0:Длина строки - 11:палиндромы\n
Строка 1:Длина строки - 19: А в Енисее - си
Строка 2:Длина строки - 6:нева.\n
Строка 3:Длина строки - 17: А лама мала.\n
Строка 4:Длина строки - 19: А лис, он умён
Строка 5:Длина строки - 19:- крыса сыр к нему
Строка 6:Длина строки - 19:носила. (И. Бабицки
Строка 7:Длина строки - 2:й)
Запись в поток при помощи fputc
Функция fputc применяется для записи символа в поток.
int fputc(int c, FILE *fp);
Параметр c "тихо" конвертируется в unsigned char перед выводом. Если прошло успешно, то fputc возвращает записанный символ. Если ошибка, то fputc возвращает EOF.
Стандартный макрос putc также определен в <stdio.h>, работая в общем случае аналогично fputc, за исключением того момента, что будучи макросом, он может обрабатывать свои аргументы более одного раза.
Стандартная функция putchar, также определенная в <stdio.h>, принимает только первый аргумент, и является эквивалентной putc(c, stdout), где c является упомянутым аргументом.
[править]
Пример использования
Нижеследующая программа на языке Си открывает двоичный файл с названием мойфайл, читает пять байт из него, а затем закрывает файл.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char buffer[5] = {0}; /* инициализируем нулями */
int i, rc;
FILE *fp = fopen("мойфайл", "rb");
if (fp == NULL) {
perror("Ошибка при открытии \"мойфайл\"");
return EXIT_FAILURE;
}
for (i = 0; (rc = getc(fp))!= EOF && i < 5; buffer[i++] = rc)
;
fclose(fp);
if (i == 5) {
puts("Прочитанные байты...");
printf("%x %x %x %x %x\n", buffer[0], buffer[1], buffer[2], buffer[3], buffer[4]);
} else
fputs("Ошибка чтения файла.\n", stderr);
return EXIT_SUCCESS;
}
63.1
Язык программирования Си поддерживает множество функций стандартных библиотек для файлового ввода и вывода. Эти функции составляют основу заголовочного файла стандартной библиотеки языка Си <stdio.h>.
Функциональность ввода-вывода языка Си по текущим стандартам реализуется на низком уровне. Язык Си абстрагирует все файловые операции, превращая их в операции с потоками байтов, которые могут быть как "потоками ввода", так и "потоками вывода". В отличие от некоторых ранних языков программирования, язык Си не имеет прямой поддержки произвольного доступа к файлам данных; чтобы считать записанную информацию в середине файла, программисту приходится создавать поток, ищущий в середине файла, а затем последовательно считывать байты из потока.
Потоковая модель файлового ввода-вывода была популяризирована во многом благодаря операционной системе Unix, написанной на языке Си. Большая функциональность современных операционных систем унаследовала потоки от Unix, а многие языки семейства языков программирования Си унаследовали интерфейс файлового ввода-вывода языка Си с небольшими отличиями (например, PHP). Стандартная библиотека C++ отражает потоковую концепцию в своем синтаксисе (смотри iostream).
поиск в файле, добавление и удаление данных.
Поиск в файле
while(!feof(pFile))
{
fscanf(pFile,"%s", &st);
printf("%s",st);
m=strlen(st);
}
int t=0;
printf("\n");
printf("введите кол-во символов ");
scanf("%i",&t);
if(t>0)
{
ch=fgetc(pFile);
// while((ch=fgetc(pFile))!= EOF)
//fgetc(pFile,"%c", &st);
for(int i=1;i<=t;i++)
{
printf("%c",ch);
}
}
64.
Поиск файла
char *searchpath(char *file);
Вначале поиск осуществляется в текущем каталоге текущего диска. Если файл не найден, функция перебирает пути из переменной окружения PATH.
В случае успеха возвращает строку, содержащую полный путь к файлу. Это имя размещается в статическом буфере и перезаписывается при каждом последующем вызове. В случае неудачи возвращается NULL.
65.
Управление динамической памятью: функции распределения памяти
Для глобальных переменных отводится фиксированное место в памяти на все время работы программы. Локальные переменные хранятся в стеке. Между ними находится область памяти для динамического распределения.
Функции malloc() и free() используются для динамического распределения свободной памяти. Функция malloc() выделяет память, функция free() освобождает ее. Прототипы этих функций хранятся в заголовочном файле stdlib.h и имеют вид:
void *malloc(size_t size);
void *free(void *p);
Функция malloc() возвращает указатель типа void; для правильного использования значение функции надо преобразовать к указателю на соответствующий тип. При успешном выполнении функция возвращает указатель на первый байт свободной памяти размера size. Если достаточного количества памяти нет, возвращается значение 0. Чтобы определить количество байтов, необходимых для переменной, используют операцию sizeof().
Пример использования этих функций:
#include <stdio.h>
#include <stdlib.h>
void main(void)
{
int *p, i;
p = (int *) malloc(100 * sizeof(int)); /* Выделение памяти для 100
целых чисел */
if (!p)
{
printf("Недостаточно памяти\n");
exit(1);
}
for (i = 0; i < 100; ++i) *(p+i) = i; /* Использование памяти */
for (i = 0; i < 100; ++i) printf("%d", *(p++));
free(p); /* Освобождение памяти */
}
Перед использованием указателя, возвращаемого malloc(), необходимо убедиться, что памяти достаточно (указатель не нулевой).
65.
Оператор C++ new позволяет вашим программам распределять память во время выполнения. Для использования оператора new вам необходимо указать количество байтов памяти, которое требуется программе. Предположим, например, что вашей программе необходим 50-байтный массив. Используя оператор new, вы можете заказать эту память, как показано ниже: char *buffer = new char[50]; Говоря кратко, если оператор new успешно выделяет память, он возвращает указатель на начало области этой памяти. В данном случае, поскольку программа распределяет память для хранения массива символов, она присваивает возвращаемый указатель переменной, определенной как указатель на тип char. Если оператор new не может выделить запрашиваемый вами объем памяти, он возвратит NULL-указатель, который содержит значение 0. Каждый раз, когда ваши программы динамически распределяют память с использованием оператора new, они должны проверять возвращаемое оператором new значение, чтобы определить, не равно ли оно NULL. Если вашей программе больше не нужна выделенная память, она должна ее освободить, используя оператор delete. Для освобождения памяти с использованием оператора delete вы просто указываете этому оператору указатель на данную область памяти, как показано ниже: delete pointer;
66.
Статическими величинами называются такие, память под которые выделяется во время компиляции и сохраняется в течение всей работы программы.
В языках программирования (Pascal, C, др.) существует и другой способ выделения памяти под данные, который называется динамическим. В этом случае память под величины отводится во время выполнения программы. Такие величины будем называть динамическими. Раздел оперативной памяти, распределяемый статически, называется статической памятью; динамически распределяемый раздел памяти называется динамической памятью (динамически распределяемой памятью).
Использование динамических величин предоставляет программисту ряд дополнительных возможностей. Во-первых, подключение динамической памяти позволяет увеличить объем обрабатываемых данных. Во-вторых, если потребность в каких-то данных отпала до окончания программы, то занятую ими память можно освободить для другой информации. В-третьих, использование динамической памяти позволяет создавать структуры данных переменного размера.
Работа с динамическими величинами связана с использованием еще одного типа данных — ссылочного типа. Величины, имеющие ссылочный тип, называют указателями.
Указатель содержит адрес поля в динамической памяти, хранящего величину определенного типа. Сам указатель располагается 1000 в статической памяти.
Адрес величины — это номер первого байта поля памяти, в котором располагается величина. Размер поля однозначно определяется типом.
Далее будем более подробно обсуждать указатели и действия с ними в языке Pascal, примеры будем приводить на Pascal и C.
Величина ссылочного типа (указатель) описывается в разделе описания переменных следующим образом:
Var <идентификатор>: ^<имя типа>;
Вот примеры описания указателей:
Type Mas1 = Array[1..100] Of Integer;
Var P1: ^Integer;
P2: ^String;
Pm: ^Mas1;
Здесь P1 — указатель на динамическую величину целого типа; P2 — указатель на динамическую величину строкового типа; Pm — указатель на динамический массив, тип которого задан в разделе Type.
Сами динамические величины не требуют описания в программе, поскольку во время компиляции память под них не выделяется. Во время компиляции память выделяется только под статические величины. Указатели — это статические величины, поэтому они требуют описания.
Каким же образом происходит выделение памяти под динамическую величину? Память под динамическую величину, связанную с указателем, выделяется в результате выполнения стандартной процедуры NEW. Формат обращения к этой процедуре:
NEW(<указатель>);
Считается, что после выполнения этого оператора создана динамическая величина, имя которой имеет следующий вид:
<имя динамической величины>:= <указатель>^
Пусть в программе, в которой имеется приведенное выше описание, присутствуют следующие операторы:
NEW(P1); NEW(P2); NEW(Pm);
После их выполнения в динамической памяти оказывается выделенным место под три величины (две скалярные и один массив), которые имеют идентификаторы:
P1^, P2^, Pm^
Например, обозначение P1^ можно расшифровать так: динамическая переменная, на которую ссылается указатель P1.
Дальнейшая работа с динамическими переменными происходит точно так же, как со статическими переменными соответствующих типов. Им можно присваивать значения, их можно использовать в качестве операндов в выражениях, параметров подпрограмм и пр. Например, если переменной P1^ нужно присвоить число 25, переменной P2^ присвоить значение символа "Write", а массив Pm^ заполнить по порядку целыми числами от 1 до 100, то это делается так:
P1^:= 25;
P2^:= 'Write';
For I:= 1 To 100 Do Pm^[I]:= I;
Кроме процедуры NEW значение указателя может определяться оператором присваивания:
<указатель>:= <ссылочное выражение>;
В качестве ссылочного выражения можно использовать
указатель;
ссылочную функцию (т.е. функцию, значением которой является указатель);
константу Nil.
Nil — это зарезервированная константа, обозначающая пустую ссылку, т.е. ссылку, которая ни на что не указывает. При присваивании базовые типы указателя и ссылочного выражения должны быть одинаковы. Константу Nil можно присваивать указателю с любым базовым типом.
До присваивания значения ссылочной переменной (с помощью оператора присваивания или процедуры NEW) она является неопределенной.
Ввод и вывод указателей не допускается.
Рассмотрим пример. Пусть в программе описаны следующие указатели:
Var D, P: ^Integer;
K: ^Boolean;
Тогда допустимыми являются операторы присваивания
D:= P; K:= Nil;
поскольку соблюдается принцип соответствия типов. Оператор K:= D ошибочен, т.к. базовые типы у правой и левой части разные.
Если динамическая величина теряет свой указатель, то она становится "мусором". В программировании под этим словом понимают информацию, которая занимает память, но уже не нужна.
Представьте себе, что в программе, в которой присутствуют описанные выше указатели, в разделе операторов записано следующее:
NEW(D); NEW(P);
{Выделено место в динамической памяти под две целые переменные. Указатели полу
чили соответствующие значения}
D^:= 3; P^:= 5;
{Динамическим переменным присвоены значения}
P:= D;
{Указатели P и D стали ссылаться на одну и ту же величину, равную 3}
WriteLn(P^, D^); {Дважды напечатается число 3}
Таким образом, динамическая величина, равная 5, потеряла свой указатель и стала недоступной. Однако место в памяти она занимает. Это и есть пример возникновения "мусора". На схеме показано, что произошло в результате выполнения оператора P:= D.
В Паскале имеется стандартная процедура, позволяющая освобождать память от данных, потребность в которых отпала. Ее формат:
DISPOSE(<указатель>);
Например, если динамическая переменная P^ больше не нужна, то оператор
DISPOSE(P)
удалит ее из памяти. После этого значение указателя P становится неопределенным. Особенно существенным становится эффект экономии памяти при удалении больших массивов.
Если указатель ссылается только на следующее звено списка (как показано на рисунке и в объявленной выше структуре), то такой список называют однонаправленным, если на следующее и предыдущее звенья — двунаправленным списком. Если указатель в последнем звене установлен не в Nil, а ссылается на заглавное звено списка, то такой список называется кольцевым. Кольцевыми могут быть и однонаправленные, и двунаправленные списки.
67.
Шаблоны (англ. template) — средство языка C++, предназначенное для кодирования обобщённых алгоритмов, без привязки к некоторым параметрам (например, типам данных, размерам буферов, значениям по умолчанию).
В C++ возможно создание шаблонов функций и классов.
Шаблоны позволяют создавать параметризованные классы и функции. Параметром может быть любой тип или значение одного из допустимых типов (целое число, enum, указатель на любой объект с глобально доступным именем). Например, нам нужен какой-то класс:
class SomeClass{
int SomeValue;
int SomeArray[20];
...
}
Для одной конкретной цели мы можем использовать этот класс. Но, вдруг, цель немного изменилась, и нужен еще один класс. Теперь нужно 30 элементов массива SomeArray и вещественный тип SomeValue и элементов SomeArray. Тогда мы можем абстрагироваться от конкретных типов и использовать шаблоны с параметрами. Синтаксис: в начале перед объявлением класса напишем слово template и укажем параметры в угловых скобках. В нашем примере:
template < int ArrayLength, typename SomeValueType > class SomeClass{
SomeValueType SomeValue;
SomeValueType SomeArray[ ArrayLength ];
...
}
Тогда для первой модели пишем:
SomeClass < 20, int > SomeVariable;
для второй:
SomeClass < 30, double > SomeVariable2;
Хотя шаблоны предоставляют краткую форму записи участка кода, на самом деле их использование не сокращает исполнимый код, так как для каждого набора параметров компилятор создаёт отдельный экземпляр функции или класса
Шаблоны функций
[править]
Дата добавления: 2015-07-26; просмотров: 79 | Нарушение авторских прав
| <== предыдущая страница | | | следующая страница ==> |
| Инициализация данных | | | Синтаксис описания шаблона |