Текст книги "C++"

Автор книги: Мюррей Хилл

Соавторы: Бьярн Страустрап
сообщить о нарушении

Текущая страница: 11 (всего у книги 26 страниц) [доступный отрывок для чтения: 11 страниц]

4.6 Функции

Обычный способ сделать что-либо в С++ программе – это вызвать функцию, которая это делает. Определение функции яляется способом задать то, как должно делаться некоторое действие. Функция не может быть вызвана, пока она не описана.

4.6.1 Описания функций

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

extern double sqrt(double); extern elem* next_elem(); extern char* strcpy(char* to, const char* from); extern void exit(int);

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

double sr2 = sqrt(2);

будет правильно обращаться к функции sqrt() со значением с плавающей точкой 2.0. Значение такой проверки типа и преоразования типа огромно.

Описание функции может содержать имена параметров. Это может помочь читателю, но компилятор эти имена просто игноррует.

4.6.2 Определения функций

Каждая функция, вызываемая в программе, должна быть гдто определена (только один раз). Определение функции – это описание функции, в котором приводится тело функции. Напрмер:

extern void swap(int*, int*); // описание

void swap(int*, int*) // определение (* int t = *p; *p =*q; *q = t; *)

Чтобы избежать расходов на вызов функции, функцию можно описать как inline (#1.12), а чтобы обеспечить более быстрый доступ к параметрам, их можно описать как register (#2.3.11). Оба средства могут использоваться неправильно, и их следует избегать везде где есть какие-либо сомнения в их полезности.

4.6.3 Передача параметров

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

стандартные и определенные пользователем преобразования тпов. Есть особые правила для передачи векторов (#4.6.5), средство передавать параметр без проверки типа параметра (#4.6.8) и средство для задания параметров по умолчанию (#4.6.6). Рассмотрим

void f(int val, int amp; ref) (* val++; ref++; *)

Когда вызывается f(), val++ увеличивает локальную копию первого фактического параметра, тогда как ref++ увеличивает второй фактический параметр. Например:

int i = 1; int j = 1; f(i,j);

увеличивает j, но не i. Первый параметр – i, передается по значению, второй параметр – j, передается по ссылке. Как уже отмечалось в #2.3.10, использование функций, которые именяют переданные по ссылке параметры, могут сделать програму трудно читаемой, и их следует избегать (но см. #6.5 и #8.4). Однако передача большого объекта по ссылке может быть гораздо эффективнее, чем передача его по значению. В этом случае параметр можно описать как const, чтобы указать, что ссылка применяется по соображениям эффективности, а также чтобы не позволить вызываемой функции изменять значение обекта:

void f(const large amp; arg) (* // значение «arg» не может быть изменено *)

Аналогично, описание параметра указателя как const соощает читателю, что значение объекта, указываемого указателем, функцией не изменяется. Например:

extern int strlen(const char*); // из «string.h» extern char* strcpy(char* to, const char* from); extern int strcmp(const char*, const char*);

Важность такой практики возрастает с размером программы.

Заметьте, что семантика передачи параметров отлична от семантики присваивания. Это важно для const параметров, сслочных параметров и параметров некоторых типов, определяемых пользователем (#6.6).

4.6.4 Возврат значения

Из функции, которая не описана как void, можно (и долно) возвращать значение. Возвращаемое значение задается опратором return. Например:

int fac(int n) (*return (n»1) ? n*fac(n-1) : 1; *)

В функции может быть больше одного оператора return: int fac(int n) (* if (n » 1) return n*fac(n-1); else return 1; *)

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

double f() (* // ... return 1; // неявно преобразуется к double(1) *)

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

int* f() (* int local = 1; // ... return amp;local; // так не делайте *)

Эта ошибка менее обычна, чем эквивалентная ошибка при использовании ссылок:

int amp; f() (* int local = 1; // ... return local; // так не делайте *)

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

int amp; f() (* return 1;*) // так не делайте

4.6.5 Векторные параметры

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

int strlen(const char*);

void f() (* char v[] = «a vector» strlen(v); strlen(«Nicholas»); *);

Иначе говоря, при передаче как параметр параметр типа T[] преобразуется к T*. Следовательно, присваивание элементу векторного параметра изменяет значение элемента вектора, кторый является параметром. Другими словами, вектор отличается от всех остальных типов тем, что вектор не передается (и не может передаваться) по значению.

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

параметр, который задает размер, или определить тип, содержщий указатель и индикатор длины, и передавать его вместо просто вектора (см. также #1.11). Например:

void compute1(int* vec_ptr, int vec_size); // один способ

struct vec (* // другой способ int* ptr; int size; *);

void compute2(vec v);

С многомерными массивами все хитрее, но часто можно вместо них использовать векторы указателей, которые не требют специального рассмотрения. Например:

char* day[] = (* «mon», «tue», «wed», «thu», «fri», «sat», «sun» *);

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

void print_m34(int m[3][4]) (* for (int i = 0; i«3; i++) (* for (int j = 0; j„4; j++) cout «« " " «« m[i][j]; cout «« «n“; *) *)

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

Первая размерность массива не имеет отношения к задаче поиска положения элемента (#2.3.6). Поэтому ее можно передвать как параметр:

void print_mi4(int m[][4], int dim1) (* for (int i = 0; i«dim1; i++) (* for (int j = 0; j„4; j++) cout «« " " «« m[i][j]; cout «« «n“; *) *)

Сложный случай возникает, когда нужно передавать обе размерности. «Очевидное решение» просто не работает:

void print_mij(int m[][], int dim1, int dim2) // ошибка (* for (int i = 0; i«dim1; i++) (* for (int j = 0; j„dim2; j++) cout «« " " «« m[i][j]; // сюрприз! cout «« «n“; *) *)

Во-первых, описание параметра m[][] недопустимо, покольку для нахождения положения элемента должна быть известна вторая размерность многомерного массива. Во-вторых, выражение m[i][j] интерпретируется (правильно) как *(*(m+i)+j), но нпохоже, чтобы это имел в виду программист. Вот правильное решение:

void print_mij(int** m, int dim1, int dim2) (* for (int i = 0; i«dim1; i++) (* for (int j = 0; j„dim2; j++) cout «« " " «« (int*)m[i*dim2+j]; // туманно cout «« «n“; *) *)

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

int* v = (int*)m; // ... v[i*dim2+j]

4.6.6 Параметры по умолчанию

Часто в самом общем случае функции требуется больше праметров, чем в самом простом и более употребительном случае. Например, в библиотеке потоков есть функция hex(), порождащая строку с шестнадцатиричным представлением целого. Второй параметр используется для задания числа символов для предтавления первого параметра. Если число символов слишком мало для представления целого, происходит усечение, если оно сликом велико, то строка дополняется пробелами. Часто програмист не заботится о числе символов, необходимых для предсталения целого, поскольку символов достаточно. Поэтому для нуля в качестве второго параметра определено значение «использвать столько символов, сколько нужно». Чтобы избежать засорния программы вызовами вроде hex(i,0), функция описывается так:

extern char* hex(long, int =0);

Инициализатор второго параметра является параметром по умолчанию. То есть, если в вызове дан только один параметр, в качестве второго используется параметр по умолчанию. Напрмер:

cout «„ „**“ «« hex(31) «« hex(32,3) «« «**“;

интерпретируется как

cout «„ „**“ «« hex(31,0) «« hex(32,3) «« «**“;

и напечатает:

** 1f 20**

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

int f(int, int =0, char* =0); // ok int g(int =0, int =0, char*); // ошибка int f(int =0, int, char* =0); // ошибка

Заметьте, что в этом контексте пробел между * и = явлется существенным (*= является операцией присваивания):

int nasty(char*=0); // синтаксическая ошибка

4.6.7 Перегрузка имен функций

Как правило, давать разным функциям разные имена – мысль хорошая, но когда некоторые функции выполняют одинаковую рботу над объектами разных типов, может быть более удобно дать им одно и то же имя. Использование одного имени для различных действий над различными типами называется перегрузкой (overloading). Метод уже используется для основных операций С ++: у сложения существует только одно имя, +, но его можно применять для сложения значений целых, плавающих и указателных типов. Эта идея легко расширяется на обработку операций, определенных пользователем, то есть, функций. Чтобы уберечь программиста от случайного повторного использования имени, имя может использоваться более чем для одной функции только если оно сперва описано как перегруженное имя функции. Напрмер:

overload print; void print(int); void print(char*);

Что касается компилятора, единственное общее, что имеют функции с одинаковым именем, это имя. Предположительно, они в каком-то смысле похожи, но в этом язык ни стесняет програмиста, ни помогает ему. Таким образом, перегруженные имена функций – это главным образом удобство записи. Это удобство значительно в случае функций с общепринятыми именами вроде sqrt, print и open. Когда имя семантически значимо, как это имеет место для операций вроде +, * и «« (#6.2) и в случае конструкторов (#5.2.4 и #6.3.1), это удобство становится сщественным. Когда вызывается перегруженная f(), компилятор должен понять, к какой из функций с именем f следует обртиться. Это делается путем сравнения типов фактических парметров с типами формальных параметров всех функций с именем f. Поиск функции, которую надо вызвать, осуществляется за три отдельных шага:

1. Искать функцию соответствующую точно, и использовать ее, если она найдена,

2. Искать соответствующую функцию используя встроенные преобразования и использовать любую найденную функцию и

3. Искать соответствующую функцию используя преобразвания, определенные пользователем (#6.3), и если множество преобразований единственно, использовать найденную функцию.

Например:

overload print(double), print(int);

void f(); (* print(1); print(1.0); *)

Правило точного соответствия гарантирует, что f напечтает 1 как целое и 1.0 как число с плавающей точкой. Ноль, char или short точно соответствуют параметру. Аналогично, float точно соответствует double.

К параметрам функций с перегруженными именами стандарные С++ правила неявного преобразования типа (#с.6.6) примняются не полностью. Преобразования, могущие уничтожить иформацию, не выполняются. Остаются int в long, int в double, ноль в long, ноль в double и преобразования указателей: преобразование ноль в указатель void*, и указатель на произвоный класс в указатель на базовый класс (#7.2.4).

Вот пример, в котором преобразование необходимо:

overload print(double), print(long);

void f(int a); (* print(a); *)

Здесь a может быть напечатано или как double, или как long. Неоднозначность разрешается явным преобразованием типа (или print(long(a)) или print(double(a))).

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

overload pow; int pow(int, int); double pow(double, double); // из «math.h» complex pow(double, complex); // из «complex.h» complex pow(complex, int); complex pow(complex, double); complex pow(complex, complex);

Процесс поиска подходящей функции игнорирует unsigned и const.

4.6.8 Незаданное число параметров

Для некоторых функций невозможно задать число и тип всех параметров, которые можно ожидать в вызове. Такую функцию описывают завершая список описаний параметров многоточием (...), что означает «и может быть, еще какие-то неописанные параметры». Например:

int printf(char* ...);

Это задает, что в вызове printf должен быть по меньшей мере один параметр, char*, а остальные могут быть, а могут и не быть. Например:

printf(«Hello, worldn»); printf(«Мое имя %s %sn», first_name, second_name); printf(«%d + %d = %dn»,2,3,5);

Такая функция полагается на информацию, которая недотупна компилятору при интерпретации ее списка параметров. В случае printf() первым параметром является строка формата, содержащая специальные последовательности символов, позволящие printf() правильно обрабатывать остальные параметры. %s означает «жди параметра char*», а %d означает «жди параметра int». Однако, компилятор этого не знает, поэтому он не может убедиться в том, что ожидаемые параметры имеют соответствущий тип. Например: printf(«Мое имя %s %sn»,2);

откомпилируется и в лучшем случае приведет к какой-нбудь странного вида выдаче. Очевиднще хуже, каждый вызов функции с автоматическим объектом класса включает по меньшей мере один вызов программ выделения и освобождения свободной памяти. Это сделало бы также невозможным реализацию inline-функций членов, которые обращаются к данным закрытой части. Более того, такое изменение сделает невозможным совместную компоновку C и С++ программ (поскольку C компилятор обрабатывает struct не так, как это будет делать С++ компилятор). Для С++ это было сочтено неприемлемым.

Глава 5
Классы

Эти типы не «абстрактны», они столь же реальны, как int и float

Дуг МакИлрой

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

5.1 Знакомство и краткий обзор

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

Тип есть конкретное представление некоторой концепции (понятия). Например, имеющийся в С++ тип float с его операцями +, -, * и т.д. обеспечивает ограниченную, но конкретную версию математического понятия действительного числа. Новый тип создается для того, чтобы дать специальное и конкретное определение понятия, которому ничто прямо и очевидно среди встроенных типов не отвечает. Например, в программе, которая работает с телефоном, можно было бы создать тип trunk_module (элемент линии), а в программе обработки текстов – тип list_of_paragraphs (список параграфов). Как правило, програму, в которой создаются типы, хорошо отвечающие понятиям прложения, понять легче, чем программу, в которой это не делется. Хорошо выбранные типы, определяемые пользователем, делают программу более четкой и короткой. Это также позволяет компилятору обнаруживать недопустимые использования объектов, которые в противном случае останутся необнаруженными до тетирования программы.

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

Эта глава состоит из четырех практически отдельных чатей:

#5.2 Классы и Члены. Этот раздел знакомит с основным понятием типа, определяемого пользователем, который называеся класс (class). Доступ к объектам класса может ограничваться набором функций, которые описаны как часть этого класа. Такие функции называются функциями членами. Объекты класса создаются и инициализируются функциями членами, спецально для этой цели описанными. Эти функции называются контрукторами. Функция член может быть специальным образом опсана для «очистки» каждого классового объекта при его уничтожении. Такая функция называется деструктором.

#5.3 Интерфейсы и Реализации. В этом разделе приводится два примера того, как класс проектируется, реализуется и ипользуется.

#5.4 Друзья и Объединения. В этом разделе приводится много дополнительных подробностей, касающихся классов. В нем показано, как предоставить доступ к закрытой части класса функции, которая не является членом этого класса. Такая фунция называется друг (friend). В этом разделе показано также, как определить дискриминирующее объединение.

#5.5 Конструкторы и Деструкторы. Объект может создаватся как автоматический, статический или как объект в свободной памяти. Объект может также быть членом некоторой совокупности (типа вектора или класса), которая в свою очередь может рамещаться одним из этих трех способов. Довольно подробно обясняется использование конструкторов и деструкторов.

5.2 Классы и члены

Класс – это определяемый пользователем тип. Этот раздел знакомит с основными средствами определения класса, создания объекта класса, работы с такими объектами и, наконец, уничтжения таких объектов после использования.

5.2.1 Функции члены

Рассмотрим реализацию понятия даты с использованием struct для того, чтобы определить представление даты date и множества функций для работы с переменными этого типа:

struct date (* int month, day, year; *); // дата: месяц, день, год *) date today; void set_date(date*, int, int, int); void next_date(date*); void print_date(date*); // ...

Никакой явной связи между функциями и типом данных нет. Такую связь можно установить, описав функции как члены:

struct date (* int month, day, year;

void set(int, int, int); void get(int*, int*, int*); void next(); void print(); *);

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

date today; // сегодня date my_burthday; // мой день рождения

void f() (* my_burthday.set(30,12,1950); today.set(18,1,1985);

my_burthday.print();

today.next(); *)

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

void date::next() (* if ( ++day » 28 ) (* // делает сложную часть работы *) *)

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