все, но если функции в myprog.c вызывают только функции sqrt() и
cos(), то кажется, что будет достаточно
$ CC myprog.c sqrt.o cos.o
Но это не так, поскольку cos.c использует sin.c.
Компоновщик, вызываемый командой CC для обработки .a файла (в
данном случае, файла math.a) знает, как из того множества, которое
- стр 122 -
использовалось для создания .a файла, извлечь только необходимые .o
файлы.
Другими словами, используя библиотеку можно включать много
определений с помощью одного имени (включения определений функций и
переменных, используемых внутренними функциями, никогда не видны
пользователю), и, кроме того, обеспечить, что в результате в
программу будет включено минимальное количество определений.
4.6 Функции
Обычный способ сделать что-либо в C++ программе - это вызвать
функцию, которая это делает. Определение функции является способом
задать то, как должно делаться некоторое действие. Фукнция не может
быть вызвана, пока она не описана.
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;
}
- стр 123 -
Чтобы избежать расходов на вызов функции, функцию можно описать
как inline (#1.12), а чтобы обеспечить более быстрый доступ к
параметрам, их можно описать как register (#2.3.11). Оба средства
могут использоваться неправильно, и их следует избегать везде где
есть какие-либо сомнения в их полезности.
4.6.3 Передача Параметров
Когда вызывается функция, дополнительно выделяется память под ее
формальные параметры, и каждый формальный параметр инициализируется
соответствующим ему фактическим параметром. Семантика передачи
параметров идентична семантике инициализации. В частности, тип
фактического параметра сопоставляется с типом формального
параметра, и выполняются все стандартные и определеннные
пользователем преобразования типов. Есть особые правила для
передачи векторов (#4.6.5), средство передавать параметр без
проверки (#4.6.8) и средство для задания параметров по умолчанию
(#4.6.6). Рассмотрим
void f(int val, int& 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& arg)
{
// значение "arg" не может быть изменено
}
Аналогично, описание параметра указателя как const сообщает
читателю, что значение объекта, указываемого указателем, функцией
не изменяется. Например:
- стр 124 -
extern int strlen(const char*); // из
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 &local; // так не делайте
}
Эта ошибка менее обычна, чем эквивалентная ошибка при использовании
ссылок:
- стр 125 -
int& f() {
int local = 1;
// ...
return local; // так не делайте
}
К счастью, о таких возвращаемых значениях предупреждает компилятор.
Вот другой пример:
int& 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);
С многомерными массивами все хитрее, но часто можно вместо них
использовать векторы указателей, которые не требуют специального
рассмотрения. Например:
- стр 126 -
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
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**
Параметр по умолчанию проходит проверку типа во время описания
функции и вычисляется во время ее вызова. Задавать параметр по
умолчанию возможно только для последних параметров, поэтому
- стр 128 -
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 Перегрузка Имен Функций
Как правило, давать разным функциям разные имена - мысль хорошая,
но когда некоторые функции выполняют одинаковую работу над