Функции в С++
Обычный способ сделать что-либо в C++ программе - это
вызвать функцию, которая это делает. Определение функции является способом
задать то, как должно делаться некоторое действие. Функция не может быть
вызвана, пока она не описана.
Описания Функций
Описание функции задает имя функции, тип возвращаемого
функцией значения (если таковое есть) и число и типы параметров, которые должны
быть в вызове функции.
Например:
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. Значение такой проверки типа и преобразования типа
огромно.
Описание функции может содержать имена параметров. Это может
помочь читателю, но компилятор эти имена просто игнорирует.
Определения Функций
Каждая функция, вызываемая в программе, должна быть
где-то определена (только один раз). Определение функции - это описание
функции, в котором приводится тело функции.
Например:
extern void swap(int*, int*); // описание
void swap(int*, int*) // определение
{
int t = *p;
*p =*q;
*q = t;
}
Чтобы избежать расходов на вызов функции, функцию можно
описать как inline , а чтобы обеспечить более быстрый доступ к параметрам, их
можно описать как register . Оба средства могут использоваться неправильно, и
их следует избегать везде где есть какие-либо сомнения в их полезности.
Передача Параметров
Когда вызывается функция, дополнительно выделяется память
под ее формальные параметры, и каждый формальный параметр инициализируется
соответствующим ему фактическим параметром. Семантика передачи параметров
идентична семантике инициализации. В частности, тип фактического параметра
сопоставляется с типом формального параметра, и выполняются все стандартные и
определенные пользователем преобразования типов. Есть особые правила для
передачи векторов , средство передавать параметр без проверки и средство для задания параметров по умолчанию
.
Рассмотрим
void f(int val, int& ref)
{
val++;
ref++;
}
Когда вызывается f(), val++ увеличивает локальную копию
первого фактического параметра, тогда как ref++ увеличивает второй фактический
параметр.
Например:
int i = 1;
int j = 1;
f(i,j);
увеличивает j, но не i. Первый параметр, i, передается по
значению, второй параметр, j, передается по ссылке. Как уже отмечалось в этом
разделе, использование функций, которые изменяют переданные по ссылке
параметры, могут сделать программу трудно читаемой, и их следует избегать .
Однако передача большого объекта по ссылке может быть гораздо эффективнее, чем
передача его по значению. В этом случае параметр можно описать как const, чтобы
указать, что ссылка применяется по соображениям эффективности, а также чтобы не
позволить вызываемой функции изменять значение объекта:
void f(const large& arg)
{
// значение
"arg" не может быть изменено
}
Аналогично, описание параметра указателя как const
сообщает читателю, что значение объекта, указываемого указателем, функцией не
изменяется.
Например:
extern int strlen(const char*); // из
extern char* strcpy(char* to, const char* from);
extern int strcmp(const char*, const char*);
Важность такой практики растет с размером программы.
Заметьте, что семантика передачи параметров отлична от семантики
присваивания. Это важно для const параметров, ссылочных параметров и параметров
некоторых типов, определяемых пользователем.
Возврат Значения
Из функции, которая не описана как 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; // так не делайте
}
Эта ошибка менее обычна, чем эквивалентная ошибка при
использовании ссылок:
int& f() {
int local = 1;
// ...
return local; // так не делайте
}
К счастью, о таких возвращаемых значениях предупреждает
компилятор.
Вот другой пример:
int& f() { return 1;} // так не делайте
Векторные Параметры
Если в качестве параметра функции используется вектор, то
передается указатель на его первый элемент.
Например:
int strlen(const char*);
void f()
{
char v[] = "a vector"
strlen(v);
strlen("Nicholas");
};
Иначе говоря, при передаче как параметр типа T[] преобразуется
к T*. Следовательно, присваивание элементу векторного параметра изменяет
значение элемента вектора, который является параметром. Другими словами, вектор
отличается от всех остальных типов тем, что вектор не передается (и не может
передаваться) по значению.
Размер вектора недоступен вызываемой функции. Это может
быть неудобно, но эту сложность можно обойти несколькими способами. Строки
оканчиваются нулем, поэтому их размер можно легко вычислить. Для других
векторов можно передавать второй параметр, который задает размер, или
определить тип, содержащий указатель и индикатор длины, и передавать его вместо
просто вектора .
Например:
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
for (int j = 0; j
cout
cout
}
}
Матрица, конечно, все равно передается как указатель, а
размерности используются просто для удобства записи.
Первая размерность массива не имеет отношения к задаче
отыскания положения элемента . Поэтому ее можно передавать как параметр:
void print_mi4(int m[][4], int dim1)
{
for (int i = 0; i
Параметры по Умолчанию
Часто в самом общем случае функции требуется больше
параметров, чем в самом простом и более употребительном случае. Например, в
библиотеке потоков есть функция hex(), порождающая строку с шестнадцатиричным
представлением целого. Второй параметр используется для задания числа символов
для представления первого параметра. Если число символов слишком мало для
представления целого, происходит усечение, если оно слишком велико, то строка
дополняется пробелами. Часто программист не заботится о числе символов,
необходимых для представления целого, поскольку символов достаточно. Поэтому
для нуля в качестве второго параметра определено значение "использовать
столько символов, сколько нужно". Чтобы избежать засорения программы
вызовами вроде hex(i,0), функция описывается так:
extern char* hex(long, int =0);
Инициализатор второго параметра является параметром по
умолчанию. То есть, если в вызове дан только один параметр, в качестве второго
используется параметр по умолчанию.
Например:
cout
интерпретируется как
cout
и напечатает:
** 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); // синтаксическая ошибка
Перегрузка Имен Функций
Как правило, давать разным функциям разные имена - мысль
хорошая, но когда некоторые функции выполняют одинаковую работу над объектами
разных типов, может быть более удобно дать им одно и то же имя. Использование
одного имени для различных действий над различными типами называется
перегрузкой (overloading). Метод уже используется для основных операций C++: у
сложения существует только одно имя, +, но его можно применять для сложения
значений целых, плавающих и указательных типов. Эта идея легко расширяется на
обработку операций, определенных пользователем, то есть, функций. Чтобы уберечь
программиста от случайного повторного использования имени, имя может
использоваться более чем для одной функции только если оно сперва описано как
перегруженное.
Например:
overload print;
void print(int);
void print(char*);
Что касается компилятора, единственное общее, что имеют
функции с одинаковым именем, это имя. Предположительно, они в каком-то смысле
похожи, но в этом язык ни стесняет программиста, ни помогает ему. Таким
образом, перегруженные имена функций - это главным образом удобство записи. Это
удобство значительно в случае функций с общепринятыми именами вроде sqrt, print
и open. Когда имя семантически значимо, как это имеет место для операций вроде
+, * и
Когда вызывается перегруженная f(), компилятор должен
понять, к какой из функций с именем f следует обратиться. Это делается путем
сравнения типов фактических параметров с типами формальных параметров всех
функций с именем f. Поиск функции, которую надо вызвать, осуществляется за три
отдельных шага:
Искать функцию соответствующую точно, и использовать ее,
если она найдена;
Искать соответствующую функцию используя встроенные
преобразования и использовать любую найденную функцию; и
Искать соответствующую функцию используя преобразования, определенные
пользователем, и если множество преобразований единственно, использовать
найденную функцию.
Например:
overload print(double), print(int);
void f();
{
print(1);
print(1.0);
}
Правило точного соответствия гарантирует, что f
напечатает 1 как целое и 1.0 как число с плавающей точкой. Ноль, char или short
точно соответствуют параметру int. Аналогично, float точно соответствует
double.
К параметрам функций с перегруженными именами стандартные
C++ правила преобразования применяются не полностью. Преобразования, могущие
уничтожить информацию, не выполняются. Остаются int в long, int в double, ноль
в long, ноль в double и преобразования указателей: ноль в указатель, ноль в
void*, и указатель на производный класс в указатель на базовый класс .
Вот пример, в котором преобразование необходимо:
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); // из
complex pow(double, complex); // из
complex pow(complex, int);
complex pow(complex, double);
complex pow(complex, complex);
Процесс поиска подходящей функции игнорирует unsigned и const.
Незаданное Число Параметров
Для некоторых функций невозможно задать число и тип всех
параметров, которые можно ожидать в вызове. Такую функцию описывают завершая
список описаний параметров многоточием (...), что означает "и может быть,
еще какие-то параметры".
Например:
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);
откомпилируется и в лучшем случае приведет к какой-нибудь
странного вида выдаче.
Очевидно, если параметр не был описан, то у компилятора
нет информации, необходимой для выполнения над ним проверки типа и
преобразования типа. В этом случае char или short передаются как int, а float
передается как double. Это не обязательно то, чего ждет пользователь.
Чрезмерное использование многоточий, вроде wild(...),
полностью выключает проверку типов параметров, оставляя программиста открытым
перед множеством неприятностей, которые хорошо знакомы программистам на C. В
хорошо продуманной программе требуется самое большее несколько функций, для
которых типы параметров не определены полностью. Для того, чтобы позаботиться о
проверке типов, можно использовать перегруженные функции и функции с
параметрами по умолчанию в большинстве тех случаев, когда иначе пришлось бы
оставить типы параметров незаданными. Многоточие необходимо только если
изменяются и число параметров, и тип параметров. Наиболее обычное применение многоточия
в задании интерфейса с функциями C библиотек, которые были определены в то
время, когда альтернативы не было:
extern int fprintf(FILE*, char* ...); // из
extern int execl(char* ...); // из
extern int abort(...); // из
Разберем случай написания функции ошибок, которая
получает один целый параметр, указывающий серьезность ошибки, после которого
идет произвольное число строк. Идея состоит в том, чтобы составлять сообщение
об ошибке с помощью передачи каждого слова как отдельного строкового параметра:
void error(int ...);
main(int argc, char* argv[])
{
switch(argc) {
case 1:
error(0,argv[0],0);
break;
case 2:
error(0,argv[0],argv[1],0);
default:
error(1,argv[0],"с",dec(argc-1),"параметрами",0);
}
}
Функцию ошибок можно определить так:
#include
void error(int n ...)
/*
"n" с последующим списком char*, оканчивающихся
нулем
*/
{
va_list ap;
va_start(ap,n); // раскрутка
arg
for (;;) {
char* p = va_arg(ap,char*);
if(p == 0) break;
cerr
}
va_end(ap); // очистка
arg
cerr
if (n) exit(n);
}
Первый из va_list определяется и инициализируется вызовом
va_start(). Макрос va_start получает имя va_list"а и имя последнего
формального параметра как параметры. Макрос va_arg используется для выбора
неименованных параметров по порядку. При каждом обращении программист должен
задать тип; va_arg() предполагает, что был передан фактический параметр, но
обычно способа убедиться в этом нет. Перед возвратом из функции, в которой был
использован va_start(), должен быть вызван va_end(). Причина в том, что va_start()
может изменить стек так, что нельзя будет успешно осуществить возврат; va_end()
аннулирует все эти изменения.
Указатель на Функцию
С функцией можно делать только две вещи: вызывать ее и
брать ее адрес. Указатель, полученный взятием адреса функции, можно затем
использовать для вызова этой функции.
Например:
void error(char* p) { /* ... */ }
void (*efct)(char*); // указатель на функцию
void f()
{
efct = &error; // efct указывает на error
(*efct)("error"); // вызов error через efct
}
Чтобы вызвать функцию через указатель, например, efct,
надо сначала этот указатель разыменовать, *efct. Поскольку операция вызова
функции () имеет более высокий приоритет, чем операция разыменования *, то
нельзя писать просто *efct("error"). Это означает *efct("error"),
а это ошибка в типе. То же относится и к синтаксису описаний .
Заметьте, что у указателей на функции типы параметров
описываются точно также, как и в самих функциях. В присваиваниях указателя
должно соблюдаться точное соответствие полного типа функции.
Например:
void (*pf)(char*); // указатель на void(char*)
void f1(char*); // void(char*)
int f2(char*); // int(char*)
void f3(int*); // void(int*)
void f()
{
pf = &f1; // ok
pf = &f2; // ошибка: не подходит возвращаемый тип
pf = &f3; // ошибка: не подходит тип параметра
(*pf)("asdf"); // ok
(*pf)(1); // ошибка: не подходит тип параметра
int i = (*pf)("qwer"); // ошибка: void
присваивается int"у
}
Правила передачи параметров для непосредственных вызовов
функции и для вызовов функции через указатель одни и те же.
Часто, чтобы избежать использования какого-либо
неочевидного синтаксиса, бывает удобно определить имя типа
указатель-на-функцию.
Например:
typedef int (*SIG_TYP)(); // из
typedef void (*SIG_ARG_TYP);
SIG_TYP signal(int,SIG_ARG_TYP);
Бывает часто полезен вектор указателей на функцию.
Например, система меню для моего редактора с мышью*4 реализована с помощью
векторов указателей на функции для представления действий. Подробно эту систему
здесь описать не получится, но вот общая идея:
typedef void (*PF)();
PF edit_ops[] = { // операции редактирования
cut, paste, snarf, search
};
PF file_ops[] = { // управление файлом
open, reshape, close, write
};
Затем определяем и инициализируем указатели, определяющие
действия, выбранные в меню, которое связано с кнопками (button) мыши:
PF* button2 = edit_ops;
PF* button3 = file_ops;
В полной реализации для определения каждого пункта меню
требуется больше информации. Например, где-то должна храниться строка, задающая
текст, который высвечивается. При использовании системы значение кнопок мыши
часто меняется в зависимости от ситуации. Эти изменения осуществляются
(частично) посредством смены значений указателей кнопок. Когда пользователь
выбирает пункт меню, например пункт 3 для кнопки 2, выполняется связанное с ним
действие:
(button2[3])();
Один из способов оценить огромную мощь указателей на
функции - это попробовать написать такую систему не используя их. Меню можно
менять в ходе использования программы, внося новые функции в таблицу действий.
Во время выполнения можно также легко сконструировать новое меню.
Указатели на функции можно использовать для задания
полиморфных подпрограмм, то есть подпрограмм, которые могут применяться к
объектам многих различных типов:
typedef int (*CFT)(char*,char*);
int sort(char* base, unsigned n, int sz, CFT cmp)
/*
Сортирует "n" элементов вектора
"base"
в возрастающем порядке
с помощью функции сравнения, указываемой "cmp".
Размер элементов "sz".
Очень неэффективный алгоритм: пузырьковая сортировка
*/
{
for (int i=0; iname, Puser(q)->name);
}
int cmp2(char*p, char* q) // Сравнивает числа dept
{
return Puser(p)->dept-Puser(q)->dept;
}
Эта программа сортирует и печатает:
main ()
{
sort((char*)heads,6,sizeof(user),cmp1);
print_id(heads,6); // в алфавитном порядке
cout
sort((char*)heads,6,sizeof(user),cmp2);
print_id(heads,6); // по порядку подразделений
}
Можно взять адрес inline-функции, как, впрочем, и адрес
перегруженной функции.
Список литературы
Для подготовки данной работы были использованы материалы
с сайта http://www.realcoding.net