Пользовательские типы данных

9.1.2. Структуры – параметры функций

Если функция не изменяет структуру, то такую структуру можно передать по значению.

Пример 9.1. Отображение полей структуры на экране дисплея

#include <iostream.h>
#include <conio.h>
  struct book {
    char title[40];
    char authors[30];
    char publishing_house[15];
    int year;
    int pages;
    float price;
  };
void show_book(book b)
{ cout << "Title: "<< b.title << endl;
  cout << "Authors: "<< b.authors << endl;
  cout << "Publishing house: "<< b. publishing_house << endl;
  cout << "Year: "<< b.year << endl;
  cout << "Pages: " << b.pages << endl;
  cout << "Price: " << b.price << endl;
}
void main()
{ book a={"Programming Languages", "Jean E.Sammet",
		"Prentice-Hall", 1969,785,49.99};
  show_book(a);
  getch();
}
//=== Результат работы ===

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

Пример 9.2. Параметр функции – указатель на структуру.

#include <iostream.h>
#include <conio.h>
  struct book {
    char title[40];
    char authors[30];
    char publishing_house[15];
    int year;
    int pages;
    float price;
  };
void input_book(book *b)	//структура передается по указателю
{ cout << "Title: ";
  cin >> b->title;
  cout << "Authors: ";
  cin >> b->authors;
  cout << "Publishing house: ";
  cin >> b->publishing_house;
  cout << "Year: ";
  cin >> b->year;
  cout << "Pages: ";
  cin >> b->pages;
  cout << "Price: ";
  cin >> b->price;
}
void main()
{ book a,*pa=a;
  input_book(pa);
  getch();
}

Пример 9.3. Параметр функции – ссылка на структуру

#include <iostream.h>
#include <conio.h>
  struct book {
    char title[40];
    char authors[30];
    char publishing_house[15];
    int year;
    int pages;
    float price;
  };
void input_book(book b)	//структура передается по ссылке
{ cout << "Title: ";
  cin >> b.title;
  cout << "Authors: ";
  cin >> b.authors;
  cout << "Publishing house: ";
  cin >> b.publishing_house;
  cout << "Year: ";
  cin >> b.year;
  cout << "Pages: ";
  cin >> b.pages;
  cout << "Price: ";
  cin >> b.price;
}
void main()
{ book a;
  input_book(a);
  getch();
}

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

Пример 9.4. Вложенные структуры

struct Point {int x; int y;};
struct Line {Point P1; Point P2;}
  Line ab;
  ab.P1.x=5;
  ab.P1.y=5;
  ab.P2.x=25;
  ab.P2.y=30;

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

9.1.3.Функции, возвращающие структуры

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

Пример 9.5. Функции g1, g2 и g3 возвращают структуру

#include <iostream.h>
#include <conio.h>
struct ss {int a; float b; };
ss g1(ss v)		//параметр - значение
{ v.a=7; v.b=8; return v; }
ss g2(ss v)		//параметр - ссылка
{ v.a=v.b+7; v.b=v.a+8; return v; }
ss g3(const ss v)	//параметр - константная ссылка
{ ss q;
  q.a=v.b+7; q.b=v.a+8; return q;
}
void main()
{ ss x1,y1={1,2};
  ss x2,y2={3,4};
  ss x3,y3={5,6};
  x1=g1(y1);
  cout << "x1=" << x1.a << '; ' << x1.b << endl;
  cout << "y1=" << y1.a << '; ' << y1.b << endl;
  y1=g1(y1);
  cout << "x1=" << x1.a << '; ' << x1.b << endl;
  cout << "y1=" << y1.a << '; ' << y1.b << endl;
  x2=g2(y2);
  cout << "x2=" << x2.a << '; ' << x2.b << endl;
  cout << "y2=" << y2.a << '; ' << y2.b << endl;
  x3=g3(y3);
  cout << "x3=" << x3.a << '; ' << x3.b << endl;
  cout << "y3=" << y3.a << '; ' << y3.b << endl;
  y3=g3(y3);
  cout << "x3=" << x3.a << '; ' << x3.b << endl;
  cout << "y3=" << y3.a << '; ' << y3.b << endl;
  getch();
}
//=== Результат работы ===
x1=7; 8         //x1 - изменился
y1=1; 2         //y1 - не изменился
x1=7; 8         //x1 - не изменился
y1=7; 8         //y1 - изменился
x2=11; 19       //x2 - изменился
y2=11; 19       //y2 - изменился
x3=13; 13       //x3 - изменился
y3=5; 6         //y3 - не изменился
x3=13; 13       //x3 - не изменился
y3=13; 13       //y3 - изменился

9.1.4. Структуры в языке C++

В языке C++ структуры послужили прообразом классов. Их основное отличие от структур языка C в том, что теперь структуры могут объединять разнородные данные с функциями – методами их обработки. Часть компонент структуры может быть доступна всем пользователям, другая часть может быть сокрыта, т.к. предназначена для выполнения внутренних задач. Однако со всеми этими особенностями структур мы будем знакомиться после изучения основ объектно-ориентированного программирования.

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

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

enum name_list {name1,name2,...};

За каждым таким именем по умолчанию закрепляются целочисленные константы:

В чем смысл замены целочисленных констант такими символьными обозначениями? Дело в том, что в конкретных прикладных задачах удобно иметь дело с мнемоническими обозначениями характеристик некоторых объектов. Например, имея дело с цветами радуги, было бы удобно ввести обозначение для палитры радуги ( rainbow ) и перечислить в ней цвета в том порядке, как они упорядочены в природе (" каждый охотник желает знать, где сидят фазаны " – красный, оранжевый, желтый, зеленый, голубой, синий, фиолетовый):

enum rainbow {red, orange, yellow, green, aqua, blue, purple};

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

enum rainbow r_col;
  r_col=yellow;
...............
  if(r_col==yellow)...

В языке C++ при объявлении переменных типа перечисление разрешается опускать служебное слово enum:

rainbow r_col=yellow;

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

enum week {sunday=1, monday, tuesday, wednesday, thursday, 
             friday, saturday};
  enum month {jan=1, feb, mar, apr, may, jun, jul, aug, sep, 
              oct, nov, dec };

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

Перечисления очень широко используются многими системными программами, особенно графическими:

enum line_style{SOLID_LINE,     //сплошная линия
                DOTTED_LINE,    //пунктирная линия
                CENTER_LINE,    //штрих-пунктирная линия
                DASHED_LINE,    //штриховая линия
                USERBIT_LINE};  //линия, определяемая пользователем
enum COLORS {BLACK,BLUE,GREEN,CYAN,RED,MAGENTA,BROWN,...};

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

#include <stdio.h>
#include <conio.h>
void main()
{ enum qq {zero, one, two, three};
  enum qq a,b;
  a=one;
  b=a+two;
  printf("a=%d b=%d",a,b);
getch();
}
//=== Результат работы ===
a=1 b=3

Правда, при компиляции 7-й строки было выдано предупреждение о попытке присвоения значения типа int переменной типа qq, но все обошлось. Однако замена на оператор b=a+three; никаких эмоций у компилятора не вызвала и был получен результат b=4. Даже попытка выполнить b=5 ; тоже прошла гладко. Так что с данными типа enum компилятор работает как с целыми числами и на выход за пределы заданного диапазона внимания не обращает.

Обратим внимание еще на один нюанс в приписывании числовых номеров константам из перечисления:

enum num12 {one=1,ein=1,two,zwei=2};

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

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

Объединения – это такие наборы данных, которые компилятор должен разместить в оперативной памяти, начиная с одного и того же места. Впервые такое совмещение разных данных появилось в языке ФОРТРАН, где для этой цели использовался оператор EQUIVALENCE (эквивалентность). Основным назначением этого оператора была попытка экономии оперативной памяти за счет размещения вновь используемых массивов на месте уже отработавших массивов. В последующем этот оператор использовался и для совместного доступа к одним и тем же полям оперативной памяти как к данным разного типа. Наконец, еще одна дополнительная услуга со стороны оператора EQUIVALENCE состояла в том, что программисты, создающие разные фрагменты программы могли использовать разные имена для обозначения одних и тех же физических величин. Эквивалентность двух разных имен позволяла свести к минимуму переделки при объединении фрагментов программ.

В языках C, C++ объединения создаются с помощью оператора union. В рамках MS-DOS, где нехватка оперативной памяти давала себя знать, с помощью объединений можно наложить друг на друга массивы, используемые в разное время. Однако наиболее важная цель объединений – расположить в одном и том же месте данные разного типа. Это позволяет обращаться к тем или иным полям, используя переменные разного типа. Наиболее характерным объектом такого типа является ячейка электронной таблицы, в которой пользователь может разместить текст или числовое выражение того или иного типа.

Самым употребительным объединением в рамках MS-DOS было использование машинных регистров при обращении к функциям BIOS и операционной системы. Для этой цели в заголовочном файле dos.h было определено объединение REGS:

struct WORDREGS	// структура из 16-битных данных
{ unsigned int ax,bx,cx,dx,si,di,cflag,flags; };
struct BYTEREGS	// структура из 8-битных данных
{ unsigned char al,ah,bl,bh,cl,ch,dl,dh; }
union REGS {struct WORDREGS x;
            struct BYTEREGS h; };

В этих объявлениях содержатся описания двух структур, которые имитируют распределение в оперативной памяти машинных регистров процессора Intel-8086. На языке ассемблера эти регистры обозначаются как 16-битные регистры общего назначения (AX, BX, CX, DX), индексные регистры (SI, DI) и регистры флагов (CFLAG, FLAGS). Особенность регистров общего назначения в том, что каждый из них объединяет по 2 байта, к которым возможен автономный доступ – отдельно к старшему байту регистра (AH, BH, CH, DH), отдельно к младшему байту (AL, BL, CL, DL). При обращениях к функциям MS-DOS приходится оперировать и с каждым байтом того или иного регистра, и с общим содержимым обоих байтов. Например, функция перевода курсора дисплея в заданную позицию, реализуется следующим фрагментом программы на языке ассемблера:

MOV AH,2      ; номер функции 2 засылается в регистр AH
MOV BH,0      ; номер страницы в текстовом режиме
MOV DH,10     ; номер строки, в которую переводится курсор
MOV DL,25     ; номер колонки
INT 10H       ; вызов прерывания с номером 16

Для того чтобы выполнить аналогичные действия (не прибегая к библиотечной функции gotoxy ) на языке C надо проделать следующие операции:

union REGS r;        //заводим область регистров в памяти
...............
  r.h.ah=2;            //засылаем номер функции в "регистр" AH
  r.h.bh=0;            //засылаем номер страницы в "регистр" BH
  r.h.dh=y;            //засылаем номер строки в "регистр" DH
  r.h.dl=x;            //засылаем номер столбца в "регистр" DL
  int86(0x10,r,r);   //имитация прерывания с номером 10h

Функция int86 перепишет содержимое объединения r в машинные регистры, предварительно сохранив их содержимое, выполнит команду прерывания, передающую управление подфункции MS-DOS с номером 2, которая переместит курсор в заданную позицию. По окончании работы подфункции содержимое машинных регистров запомнится в объединении r, а их прежнее содержимое будет восстановлено.

Может быть, вам покажется, что приведенный фрагмент излишне усложнен, но реальная работа функции gotoxy(x,y) требует еще большего числа операций.

В языке C++ также была предпринята попытка использовать объединения для создания классов. Однако о деталях другого использования объединений в разделе "C++ и объектно-ориентированное программирование".