46019 (Turbo C++ Programer`s guide), страница 11

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

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

int f(); /* В С это функция, возвращащая int, без информации о параметрах. Это "классический стиль" Кернигэна и Ритчи */

int f(); /* В С++ это функция, не принимающая аргументов */

int f(void); /* Функция, возвращающая int и не принимающая параметров */

int p(int,long) /* Функция с типомвозврата int,принимающая два параметра, первый типа int, и второй типа long */

int pascal q(void); /* функция типа pascal, возвращающая int и не принимающая параметров */

char far *s(char *source, int kind); /* Функция, возвращающая дальний указатель на char и принимающая два параметра: превый - дальний указатель на char, а второй int */

int printf(char *format,...); /* Функция, возвращающая int и принимающая фиксированный параметр типа указатель на char и любое число дополнительных параметров неизвестного типа */

int (*fp)(int); /* Указатель на функцию, возвращающую int и принимающую один параметр int */

Объявления

Общий синтаксис для определений внешних функций приводится в следующей таблице:

Определения внешних функций Таблица 1.18

файл:

внешнее-определение

файл внешнее-определение

внешнее-определение:

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

объявление

asm-оператор

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

декларатор

составной-оператор

В целом, определение функции состоит из следующих разделов (грамматика позволяет создание и более сложных конструкций):

1. Опциональные спецификаторы класса памяти: extern или static. Умолчанием является extern.

2. Тип возврата, возможно void. Умолчанием является int.

Элементы из пунктов 1 и 2 можно взаимно комбинировать.

3. Опциональные модификаторы: pascal, cdecl, interrupt, near, far, huge. Умолчание зависит от модели памяти и установленных опций компилятора.

4. Имя функции.

5. Список объявления параметров, который может быть пустым, заключенный в круглые скобки. В с предпочтительно обозначать отсутствие параметров записью func(void). В С допускается и старый стиль записи func(), но это может приводить к неоднозначностям и возможным ошибкам. В С++ выдается соответствующее предупреждение.

6. Тело функции, представляющее собой коды, выполняемые при вызове функции.

Объявления формальных параметров

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

int func(void) (* // аргументы отсутствуют

С++int func(T! t1, T2 t2, T3 t3=1) (*

// три простых параметра,

// один из которых с аргументо

// по умолчанию

C++int func(T1* ptr1, T2& tref) (*

// аргументы указатель и ссылк

int func(register int i) (* // запрос регистра для аргумен

int func(char *str,...) (* /* один строковый аргумент ипеременное число прочих аргументов, либо фиксированное число аргументов с переменными типами */

В С++ вы можете задавать, как показано, аргументы по умолчанию. Параметры со значениями по умолчанию должны являться последними параметрами в списке. Типы аргументов могут быть скалярными, структурами,объединениями, перечислимого типа, указателямиили ссылками на структуры или объединения, или указателями на функции или классы.

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

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

В деклараторах формальных параметров могут использоваться модификаторы const и volatile.

Вызовы функций и преобразования аргументов

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

Ниже приводится краткое изложение правил, управляющих обработкой в Turbo C++ модификаторов языка и формальных параметров при вызове функций, как при наличии прототипа, так и при его отсутствии:

1. Модификаторы языка для определения функции должны соответствовать модификаторам, используемым в объявлении функции, при всех вызовах функции.

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

Если ранее не был объявлен прототип функции, Turbo C++ преобразует интегральные аргументы при вызове функции в соответствии с правилами интегрального расширения, описанными в разделе "Стандартные преобразования" на стр.41 оригинала. При наличии в контексте прототипа функции Turbo C++ преобразует данные аргументы к объявленным типам параметров, как при операции присвоения.

Если прототип функции включает в себя многоточие (...), то Turbo C++ преобразует все данные аргументы функции, как и в любом другом прототипе (использующем многоточие). Компилятор расширяет любые аргументы, заданные помимо фиксированных параметров, по обычным правилам для аргументов функции без прототипов.

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

Важное замечание

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

Структуры

Инициализация структуры описана на стр.42 оригинала.

Структура - это производный тип данных, обычно представляющий собой определяемый пользователем набор именованных компонентов. Эти компоненты могут быть любого типа, как фундаментального, так и производного (с некоторыми описываемыми далее ограничениями), и располагаться в любой последовательности. Кроме того, компонент структуры может иметь тип битового поля, более нигде не разрешаемого. Тип струтуры в Turbo C++ позволяет обрабатывать сложные структуры данных так же легко, как и простые переменные.

В С++ тип структуры рассматривается как тип класса (с определенными различиями: доступ по умолчанию устанавливается public, а умолчание для базового класса также public). Это позволяет организовывать более сложное управление компонентами структуры при помощи спецификаторов доступа С++: public (это умолчание), private и protected. Помимо данного опционального механизма управления доступом и упомянутых исключений, далее рассматриваемые синтаксис и применение структур относятся равно к структурам С и С++.

Объявление структур выполняется при помощи ключевого слова struct. Например,

struct mystruct (* ... *); // mystruct - это тег структуры

...

struct mystruct s, *ps, arrs[10];

/* s имеет тип структуры mystruct; ps это указатель на тип struct mystruct */

Структуры без тегов и определения типов (typedef)

Структуры без компонентов и компоненты объединений при инициализации игнорируются.

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

struct (* ...*) s, *ps, arrs[10]; //структура без тега

При объявлении структуры, как с тегом, так и без него, можно создать typedef:

typedef struct mystruct (* ... *) MYSTRUCT;

MYSTRUCT s, *ps, arrs[10]; // то же, что и

// struct mystruct s и т.д.

typedef struct (* ... *) YRSTRUCT; // тег отсутствует YRSTRUCT y, *yp, arry[20];

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

Объявления компонентов структуры

Список-объявления-компонентов вфигурных скобках объявляет типы и имена компонентов структуры при помощи синтаксиса декларатора, показанного в таблице 1.11 на стр.36 оригинала.

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

1. Тип компонента не может быть тот же, что и объявляемая в текущий момент структура:

struct mystruct (* mystruct s *) s1, s2;// недопустимо

Компонент структуры может являться указателем на объявляемую структуру, как в следующем примере:

struct mystruct (* mystruct *ps *) s1, s2; // так можно

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

В С++ ключевое слово struct может быть опущено.

2. Кроме С++, компонент структуры нигде не может иметь тип "функция, возвращающая ...", но тип "указатель на функцию, возвращающую ..." допустим. В С++ struct может иметь компоненты-функции.

Структуры и функции

Функция может иметь возвращаемое значение типа структуры или указателя структуры.

mystruct func1(void); // func1() возвращает структуру mystruct

*func29void); // func2() возвращает указатель структуры

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

void func1 (mystruct s); // непосредственно

void func2 (mystruct *sptr); // через указатель

void func3 (mystruct &sref); // по ссылке (только С++) Доступ к компоненту структуры

Доступ к компонентам структур и объединений выполняется операторами выбора . и ->. Предположим, что объект имеет тип структуры S, а sptr это указатель на S. Тогда, если m это идентификатор типа M, объявленного в S, то выражения s.m и sptr->m имеют тип M и представляют объект m - компонент структуры s. Выражение s->sptr является удобным синонимом (* sptr).m.

Операция . называется прямым селектором компонента структуры; операция -> называется косвенным селектором компонента (или указателем) структуры; например,

struct mystruct (*

int i;

char str[21];

double d;

*) s, *sptr=&s;

...

s.i = 3; // присвоению члему i структуры mystruct s sptr->d = 1.23; // присвоение компоненту d структуры mystruct s

Выражение s.m является именуемым значением (lvalue), если s это не именуемое значение и s не имеет тип массива. Выражение sptr->m является именуемым выражением, если m не имеет тип массива.

Если структура B содержит поле, тип которого есть структура A, то доступ к компонентам A выполняется через два одновременно задаваемых селектора компонента структуры:

struct A (*

int j;

double x;

*)

struct B (*

int i;

struct A a;

double d;

*) s, *sptr;

...

s.i = 3; // присвоение компоненту i структуры B s.a.j = 2; // присвоение компоненту j структуры A sptr->d = 1.23; // присвоение компоненту d структуры B (sptr->).x = 3.14 // присвоение компоненту x структуры A

Каждое объявление структуры вводит уникальный тип структуры, поэтому в

struct A (*

int i,j;

double d;

*) a, a1;

struct B (*

int i,j;

double d;

*) b;

объекты a и a1 оба имеют тип struct A, но объекты a и b имеют различные типы структуры. Структурам может выполняться присваивание только в том случае, если и исходная структура, и структура назначения имеют один и тот же тип:

a = a1;// так можно; тип один и тот же, поэтому может быть // выполнено покомпонентное присвоение структур

a = b;// так нельзя; разные компоненты

a.1 = b.1; a.j = b.j; a.d = b.d; // однако присвоение можно // выполнять на уровне компонентов структуры

Выравнивание по границе слова