Xhtml 1.0css 2.1ie 7ie 8ie 9Cr 8Op 12Sa 5Fx 4

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

В С совсем немного возможностей по построению пользовательских типов данных. Точнее, сами возможности практически безграничны, но вот "базовых кирпичиков", из которых все строится, всего 4. Это структуры (structures), объединения, или союзы (unions), битовые поля (bit fields) и перечисления (enumerations). Причем последний тип, перечисление, в С не очень популярен - никаких дополнительных преимуществ, кроме улучшения читаемости программы, он не дает. А наиболее распространен первый тип - структуры. Давайте с него и начнем.

Структуры.

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

/* Complex number as array */ double cmplx[2]; /* [0] - real part, [1] - img */

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

/* Array of complex numbers-arrays */ double cmplxarr[10][2]; /* [][0] - real part. [][1] - img */

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

/* complex.h */ struct COMPLEX {    double re;   double im;  };

или то же самое, но короче

/* complex.h */ struct COMPLEX {    double re, im; };

Как видите, для определения структуры сначала ставят ключевое слово struct, затем название типа (это не название переменной, а именно название пользовательского типа), а затем в фигурных скобках определяют так называемые поля - таким же образом, как вне структуры вы бы определяли переменные. Так, в нашей структуре для комплексных чисел есть два поля типаdouble с именами re и im. Обычно, если программа состоит из нескольких файлов, то такое описание типа выносят в файл-заголовок (поэтому я и написал в комментарии complex.h). А потом включают его в те файлы, где таким типом хотят пользоваться.

Написав подобное определение, мы теперь можем пользоваться нашим новым типом данных - создавать переменные, указатели на него, массивы, и так далее. Только название нашего нового типа будет 'struct COMPLEX', а не COMPLEX. Вот примеры использования нового типа для создания различных объектов:

#include "complex.h" struct COMPLEX number1, number2; /* два числа */ struct COMPLEX arr[10]; /* массив */ struct COMPLEX *ptr; /* указатель */

Кстати, если структура понадобилась только в одном файле, то можно даже совместить описание типа и создание переменных, вот так:

struct COMPLEX {    double re, im; } number1, *ptr; struct COMPLEX number2;

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

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

/* Структура - элемент односвязного списка */ struct LIST_ELM {   char info[100]; /* поле-массив char */   /* Поле-указатель на предыдущий элемент */   struct LIST_ELM *prev;  };

Прямо при создании структур (имеются в виду переменные, а не само описание типа) их можно инициализировать - задавать полям начальные значения. Форма записи при этом следующая (на примере LIST_ELM):

struct LIST_ELM first = { "First item", NULL }; struct LIST_ELM second = { "Second item", &first };

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

struct USELESS {   char *p;   int a[2];   double d; }; struct USELESS useless = { NULL, { 1,2 }, 3.14 };

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

#include "complex.h" struct COMPLEX number, *ptr; /* Работа со полями структуры - точка */ number.re = 1.0; number.im = number.re; /* Работа с полями через указатель - стрелочка */ ptr = &number; ptr->re=1.0; ptr->im=ptr->re;

Разумеется, во втором случае можно было бы использовать комбинацию звездочки (доступ через указатель) и точки

(*ptr).re=1.0; (*ptr).im=(*ptr).re;

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

p->next->q1->i=0;

и вы сразу это оцените.

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

Но все-таки структуры придуманы прежде всего для того, чтобы работать с разнородной информацией, как с одним целым. Пока все преимущества, которые мы видели - поля переменной сгруппированы в одном объекте и доступны через имя этой переменной. Что еще можно делать со структурой? Разумеется, передавать в функцию в качестве параметра и возвращать результат. Однако тут есть одна особенность. Если структура несёт в себе большое колличество данных, то передача её как аргумента (передача по значению) приведёт к копированию всех этих данных из одного места в другое. Чтобы избежать подобных накладных расходов эффективней передать указатель на структуру. Вот как это выглядит на практике:

#include <stdio.h> #include "complex.h" /* Заносим комплексное значение по указанному адресу */ void set_complex(struct COMPLEX *n, double re, double im) {   n->re = re;   n->im = im; } /* Складываем два числа, возвращаем результат */ struct COMPLEX *add_complex(     struct COMPLEX *n1,      struct COMPLEX *n2 )  {    static struct COMPLEX result;   result.re = n1->re + n2->re;   result.im = n1->im + n2->im;   return &result; } main() {   struct COMPLEX number1, number2, *ptr;   set_complex( &number1, 1.0, 1.0);   set_complex( &number2, 1,0, 0.0);   ptr=add_complex(&number1, &number2);   printf("%g %g\n", ptr->re, ptr->im); }

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

Битовые поля.

Вот, собственно, и все, что я собирался сказать о структурах. Перейдем теперь к битовым полям. Прежде, чем показать, как они выглядят, приведу характерный пример, где они требуются. Представьте себе, что вы пишете программу для работы с контроллером КАМАК. И в документации на контроллер написано что-нибудь в таком духе: "CSR (cтатусный регистр) доступен по адресу 0xD8000. Для генерации цикла КАМАК номер функции (0..31) нужно занести в биты 1-5 статусного регистра, а в бит 0 занести 1. После завершения цикла бит 0 будет очищен контроллером.". И вам надо выполнить 8 функцию КАМАК, а затем дождаться завершения цикла. Разумеется, все это можно проделать с помощью операций битовой арифметики:

volatile char *csr = (char*)0xD8000; /* Заслать в биты 1..5 функцию 8, взвести бит 0 */ *csr = (8<<1)|1 /* Дождаться, пока контроллер очистит бит 0 */ while ( (*csr & 1) != 0) ;

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

Само по себе определение битового поля очень похоже на определение структуры, только после каждого поля указывается его размер в битах. И в качестве типа поля указывать можно только int, signed или unsigned. Вот как мы могли бы описать статусный регистр из примера выше:

struct CSR {   unsigned busy : 1; /* Бит, запускающий цикл */   unsigned f : 5 ; /* 5 битов под функцию */   int unused: 3; /* Три неиспользуемых старших бита */ };

Теперь, создав переменную такого типа, мы будем иметь в ней три "маленьких" целых числа - unused с длиной 3 бита и диапазоном -4..3, беззнаковое f длиной 5 бит и диапазоном 0..31, и беззнаковое busy из одного бита, то есть, с диапазоном 0..1. Причем все эти переменные окажутся упакованными в один байт. И теперь мы можем проделать со статусным регистром требуемую работу в гораздо более понятной форме:

volatile struct CSR *mycsr = (struct CSR *)0xD8000; /* Заслать в биты 1..5 функцию 8 */ csr->f = 8; /* взвести бит 0 */ csr->busy = 1; /* Дождаться, пока контроллер очистит бит 0 */ while ( csr->busy ) ;

Можно еще более усовершенствовать определение нашего битового поля - не давать имя первой, неиспользуемой, группе битов, благо С это позволяет:

struct CSR {   unsigned busy : 1; /* Бит, запускающий цикл */   unsigned f : 5 ; /* 5 битов под функцию */   int : 3; /* Три неиспользуемых старших бита */ };

При этом 3 бита под безымянное поле все равно будут выделены, так что нужные нам поля f иbusy окажутся на прежних местах.

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

Объединения.

Третий из определяемых пользователем типов данных - это объединение, или союз. Определяется этот тип с помощью другого ключевого слова - union, например, так.

union DOUBLE_UCHAR8 {   double d;   unsigned char uc[8]; };

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

Перечисления.

И, наконец, последний тип - перечисление (enumeration). По-моему, наименее популярный - это можно понять даже по соотношению частоты определения перечислений и структур в той же стандартной библиотеке С. Этот тип позволяет создавать синонимы для последовательности целых чисел, а затем эти синонимы использовать в качестве символических констант. Или использовать сам этот тип в качестве параметра функции. Например, мы можем написать

enum BOOLEAN { FALSE, TRUE };

А потом использовать вместо 0 и 1 имена FALSE и TRUE. Или использовать имя нашего типа для задания параметра:

void f(enum BOOLEAN flag) {   if (flag==FALSE)     printf("flag==FALSE\n");   else     printf("flag==TRUE\n"); } main() {   f(FALSE);   f(TRUE); }