Шилдт c++_базовый_курс издание 3. Герберт Шилдт С базовый курс

• Название: Герберт Шилдт С базовый курс
• Анкор: Шилдт c++_базовый_курс издание 3.pdf
• Дата: 13.02.2017
• Размер: 9.37 Mb.
• Имя файла: Шилдт c++_базовый_курс издание 3.pdf
• Тип: Книга; #2637
• страница: 9 из 33

Глава 8: Функции, часть вторая: ссылки, перегрузка и
использование аргументов по умолчанию
В этой главе мы продолжим изучение функций, а именно рассмотрим три самые важные темы, связанные с функциями C++: ссылки, перегрузка функций и использование аргументов
по умолчанию. Эти три средства в значительной степени расширяют возможности функций.
Как будет показано ниже, ссылка — это неявный указатель. Перегрузка функций представляет собой свойство, которое позволяет одну функцию реализовать несколькими способами, причем в каждом случае возможно выполнение отдельной задачи. Поэтому есть все основания считать перегрузку функций одним из путей поддержки полиморфизма в
C++. Используя возможность задания аргументов по умолчанию, можно определить значение для параметра, которое будет автоматически применено в случае, если соответствующий аргумент не задан.
Поскольку к параметрам функций часто применяются ссылки (это основная причина их существования), начнем эту главу с краткого рассмотрения способов передачи аргументов функциям.
Два способа передачи аргументов
При вызове по значению функции передается значение аргумента.
Чтобы понять происхождение ссылки, необходимо знать теорию процесса передачи аргументов. В общем случае в языках программирования, как правило, предусматривается два способа, которые позволяют передавать аргументы в подпрограммы (функции, методы,
процедуры). Первый называется вызовом по значению (call-by-value). В этом случае
значение аргумента копируется в формальный параметр подпрограммы. Следовательно,
изменения, внесенные в параметры подпрограммы, не влияют на аргументы, используемые при ее вызове.
При вызове по ссылке функции передается адрес аргумента.
Второй способ передачи аргумента подпрограмме называется вызовом по ссылке (call- by-reference). В этом случае в параметр копируется адрес аргумента (а не его значение). В
пределах вызываемой подпрограммы этот адрес используется для доступа к реальному аргументу, заданному при ее вызове. Это значит, что изменения, внесенные в параметр,
окажут воздействие на аргумент, используемый при вызове подпрограммы.
Как в C++ реализована передача аргументов
По умолчанию для передачи аргументов в C++ используется метод вызова по значению.
Это означает, что в общем случае код функции не может изменить аргументы,
используемые при вызове функции. Во всех программах этой книги, представленных до сих пор, использовался метод вызова по значению.
Рассмотрим следующую функцию.
#include
using namespace std;

int sqr_it(int x);
int main()
{
int t=10;
cout << sqr_it(t) << ' ' << t;
return 0;
}
int sqr_it(int x)
{
x = x*x;
return x;
}
В этом примере значение аргумента, передаваемого функции sqr_it(), 10, копируется в параметр х. При выполнении присваивания х = х*х изменяется лишь локальная переменная
х. Переменная t, используемая при вызове функции sqr_it(), по-прежнему будет иметь значение 10, и на нее никак не повлияют операции, выполняемые в этой функции.
Следовательно, после запуска рассматриваемой программы на экране будет выведен такой результат: 100 10.
Узелок на память. По умолчанию функции передается копия аргумента. То, что
происходит внутри функции, никак не отражается на значении переменной, используемой
при вызове функции.
Использование указателя для обеспечения вызова по ссылке
Несмотря на то что в качестве С++-соглашения о передаче параметров по умолчанию действует вызов по значению, существует возможность "вручную" заменить его вызовом по ссылке. В этом случае функции будет передаваться адрес аргумента (т.е. указатель на аргумент). Это позволит внутреннему коду функции изменить значение аргумента, которое хранится вне функции. Пример такого "дистанционного" управления значениями переменных вы видели в предыдущей главе при рассмотрении возможности вызова функции с указателями (в примере программы функции передавался указатель на целочисленную переменную). Как вы знаете, указатели передаются функциям подобно значениям любого другого типа. Безусловно, для этого необходимо объявить параметры с типом указателей.
Чтобы понять, как передача указателя позволяет вручную обеспечить вызов по ссылке,

рассмотрим следующую версию функции swap(). (Она меняет значения двух переменных, на которые указывают ее аргументы.)
void swap(int *х, int *у)
{
int temp;
temp = *x; // Временно сохраняем значение, расположенное по адресу х.
*х = *у; // Помещаем значение, хранимое по адресу у, в адрес х.
*у = temp; // Помещаем значение, которое раньше хранилось по адресу х, в адрес у.
}
Здесь параметры *х и *у означают переменные, адресуемые указателями х и у, которые попросту являются адресами аргументов, используемых при вызове функции swap().
Следовательно, при выполнении этой функции будет совершен реальный обмен содержимым переменных, используемых при ее вызове.
Поскольку функция swap() ожидает получить два указателя, вы должны помнить, что функцию swap() необходимо вызывать с адресами переменных, значения которых вы хотите обменять. Корректный вызов этой функции продемонстрирован в следующей программе.
#include
using namespace std;
// Объявляем функцию swap(), которая использует указатели.
void swap(int *х, int *у);
int main()
{
int i, j;
i = 10;
j = 20;
cout << "Исходные значения переменных i и j: ";

cout << i << ' ' << j << '\n';
swap(&j, &i); // Вызываем swap() с адресами переменных i и j.
cout << "Значения переменных i и j после обмена: ";
cout << i << ' ' << j << '\n';
return 0;
}
// Обмен аргументами.
void swap(int *x, int *y)
{
int temp;
temp = *x; // Временно сохраняем значение, расположенное по адресу х.
*х = *у; // Помещаем значение, хранимое по адресу у, в адрес х.
*у = temp; // Помещаем значение, которое раньше хранилось по адресу х, в адрес у.
}
Результаты выполнения этой программы таковы.
Исходные значения переменных i и j: 10 20
Значения переменных i и j после обмена: 20 10
В этом примере переменной i было присвоено начальное значение 10, а переменной j —
20. Затем была вызвана функция swap() с адресами переменных i и j. Для получения адресов здесь используется унарный оператор Следовательно, функции swap() при вызове были переданы адреса переменных i и j, а не их значения. После выполнения функции swap()
переменные i и j обменялись своими значениями.
Ссылочные параметры
Ссылочный параметр автоматически получает адрес соответствующего аргумента.

Несмотря на возможность "вручную" организовать вызов по ссылке с помощью оператора получения адреса, такой подход не всегда удобен. Во-первых, он вынуждает программиста выполнять все операции с использованием указателей. Во-вторых, вызывая функцию, программист должен не забыть передать ей адреса аргументов, а не их значения.
К счастью, в C++ можно сориентировать компилятор на автоматическое использование вызова по ссылке (вместо вызова по значению) для одного или нескольких параметров конкретной функции. Такая возможность реализуется с помощью ссылочного параметра
(reference parameter). При использовании ссылочного параметра функции автоматически передается адрес (а не значение) аргумента. При выполнении кода функции, а именно при выполнении операций над ссылочным параметром, обеспечивается его автоматическое разыменование, и поэтому программисту не нужно использовать операторы, работающие с указателями.
Ссылочный параметр объявляется с помощью символа который должен предшествовать имени параметра в объявлении функции. Операции, выполняемые над ссылочным параметром, оказывают влияние на аргумент, используемый при вызове функции, а не на сам ссылочный параметр.
Чтобы лучше понять механизм действия ссылочных параметров, рассмотрим для начала простой пример. В следующей программе функция f() принимает один ссылочный параметр типа int.
// Использование ссылочного параметра.
#include
using namespace std;
void f(int &i);
int main()
{
int val = 1;
cout << "Старое значение переменной val: " << val << '\n';
f(val); // Передаем адрес переменной val функции f().
cout << "Новое значение переменной val: " << val << '\n';
return 0;

}
void f(int &i)
{
i = 10; // Модификация аргумента, заданного при вызове.
}
При выполнении этой программы получаем такой результат.
Старое значение переменной val: 1
Новое значение переменной val: 10
Обратите особое внимание на определение функции f().
void f (int &i)
{
i = 10; // Модификация аргумента, заданного при вызове.
}
Итак, рассмотрим объявление параметра i. Его имени предшествует символ который "превращает" переменную i в ссылочный параметр. (Это объявление также используется в прототипе функции.) Инструкция i = 10;
(в данном случае она одна составляет тело функции) не присваивает переменной i
значение 10. В действительности значение 10 присваивается переменной, на которую ссылается переменная i (в нашей программе ею является переменная val). Обратите внимание на то, что в этой инструкции не используется оператор который необходим при работе с указателями. Применяя ссылочный параметр, вы тем самым уведомляете С++- компилятор о передаче адреса (т.е. указателя), и компилятор автоматически разыменовывает его за вас. Более того, если бы вы попытались "помочь" компилятору,
использовав оператор то сразу же получили бы сообщение об ошибке (и вправду "ни одно доброе дело не остается безнаказанным").
Поскольку переменная i была объявлена как ссылочный параметр, компилятор автоматически передает функции f() адрес любого аргумента, с которым вызывается эта функция. Таким образом, в функции main() инструкция f(val); // Передаем адрес переменной val функции f().
передает функции f() адрес переменной val (а не ее значение). Обратите внимание на то,
что при вызове функции f() не нужно предварять переменную val оператором "&". (Более того, это было бы ошибкой.) Поскольку функция f() получает адрес переменной val в форме

ссылки, она может модифицировать значение этой переменной.
Чтобы проиллюстрировать реальное применение ссылочных параметров (и тем самым продемонстрировать их достоинства), перепишем нашу старую знакомую функцию swap() с использованием ссылок. В следующей программе обратите внимание на то, как функция
swap() объявляется и вызывается.
#include
using namespace std;
//
Объявляем функцию swap() с использованием ссылочных параметров.
void swap(int &х, int &у);
int main()
{
int i, j;
i = 10; j = 20;
cout << " Исходные значения переменных i и j: ";
cout << i << ' ' << j << '\n';
swap (j, i);
cout << " Значения переменных i и j после обмена: ";
cout << i << ' ' << j << '\n';
return 0;
}
/* Здесь функция swap() определяется в расчете на вызов по ссылке, а не на вызов по значению. Поэтому она может выполнить

обмен значениями двух аргументов, с которыми она вызывается.
*/
void swap(int &х, int &у)
{
int temp;
temp = x; // Сохраняем значение, расположенное по адресу х.
х = у; // Помещаем значение, хранимое по адресу у, в адрес х.
у = temp; // Помещаем значение, которое раньше хранилось по адресу х, в адрес у.
}
Опять таки, обратите внимание на то, что объявление х и у ссылочными параметрами избавляет вас от необходимости использовать оператор при организации обмена значениями. Как уже упоминалось, такая "навязчивость" с вашей стороны стала бы причиной ошибки. Поэтому запомните, что компилятор автоматически генерирует адреса аргументов, используемых при вызове функции swap(), и автоматически разыменовывает ссылки х и у.
Итак, подведем некоторые итоги. После создания ссылочный параметр автоматически ссылается (т.е. неявно указывает) на аргумент, используемый при вызове функции. Более того, при вызове функции не нужно применять к аргументу оператор Кроме того, в теле функции ссылочный параметр используется непосредственно, т.е. без использования оператора Все операции, включающие ссылочный параметр, автоматически выполняются над аргументом, используемым при вызове функции.
Узелок на память. Присваивая некоторое значение ссылке, вы в действительности
присваиваете это значение переменной, на которую указывает эта ссылка. Поэтому,
применяя ссылку в качестве аргумента функции, при вызове функции вы в
действительности используете такую переменную.
Объявление ссылочных параметров
В изданной в 1986 г. книге Язык программирования C++ (в которой был впервые описан синтаксис C++) Бьерн Страуструп представил стиль объявления ссылочных параметров,
одобренный другими программистами. В соответствии с этим стилем оператор "&"
связывается с именем типа, а не с именем переменной. Например, вот как выглядит еще один способ записи прототипа функции swap().
void swap(int& х, int& у);
Нетрудно заметить, что в этом объявлении символ "&" прилегает вплотную к имени типа int, а не к имени переменной х.
Некоторые программисты определяют в таком стиле и указатели, связывая символ "*" с

типом, а не с переменной, как в этом примере.
float* р;
Приведенные объявления отражают желание некоторых программистов иметь в C++
отдельный тип ссылки или указателя. Но дело в том, что подобное связывание символа "&"
или "*" с типом (а не с переменной) не распространяется, в соответствии с формальным синтаксисом C++, на весь список переменных, приведенных в объявлении, что может привести к путанице. Например, в следующем объявлении создается один указатель (а не два) на целочисленную переменную.
int* а, b;
Здесь b объявляется как целочисленная переменная (а не как указатель на целочисленную переменную), поскольку, как определено синтаксисом C++, используемый в объявлении символ "*" или "&" связывается с конкретной переменной, которой он предшествует, а не с типом, за которым он следует.
Важно понимать, что для С++-компилятора абсолютно безразлично, как именно вы напишете объявление: int *р или int* р. Таким образом, если вы предпочитаете связывать символ "*" или "&" с типом, а не переменной, поступайте, как вам удобно. Но, чтобы избежать в дальнейшем каких-либо недоразумений, в этой книге мы будем связывать символ "*" или "&" с именем переменной, а не с именем типа.
Важно! В языке С ссылки не поддерживаются. Поэтому единственный способ
обеспечить в языке С вызов по ссылке состоит в использовании указателей, как было
показано выше (см. первую версию функции swap()). Преобразуя С-код в С++-код, вам
стоит вместо параметров-указателей использовать, где это возможно, ссылки.
Возврат ссылок
Функция может возвращать ссылку. В программировании на C++ предусмотрено несколько применений для ссылочных значений, возвращаемых функциями. Сейчас мы продемонстрируем только некоторые из них, а другие рассмотрим ниже в этой книге, когда познакомимся с перегрузкой операторов.
Если функция возвращает ссылку, это означает, что она возвращает неявный указатель на значение, передаваемое ею в инструкции return. Этот факт открывает поразительные возможности: функцию, оказывается, можно использовать в левой части инструкции присваивания! Например, рассмотрим следующую простую программу.
// Возврат ссылки.
#include
using namespace std;
double &f();
double val = 100.0;

int main()
{
double newval;
cout << f() << '\n'; // Отображаем значение val.
newval = f(); // Присваиваем значение val переменной newval.
cout << newval << '\n'; // Отображаем значение newval.
f() = 99.1; // Изменяем значение val.
cout << f() << '\n'; // Отображаем новое значение val.
return 0;
}
double &f()
{
return val; // Возвращаем ссылку на val.
}
Вот как выглядят результаты выполнения этой программы.
100 100 99.1
Рассмотрим эту программу подробнее. Судя по прототипу функции f(), она должна возвращать ссылку на double-значение. За объявлением функции f() следует объявление глобальной переменной val, которая инициализируется значением 100. При выполнении следующей инструкции выводится исходное значение переменной val.
cout << f() << '\n'; // Отображаем значение val.

После вызова функция f() возвращает ссылку на переменную val. Поскольку функция f()
объявлена с "обязательством" вернуть ссылку, при выполнении строки return val; // Возвращаем ссылку на val.
автоматически возвращается ссылка на глобальную переменную val. Эта ссылка затем используется инструкцией cout для отображения значения val.
При выполнении строки newval = f(); //Присваиваем значение val переменной newval.
ссылка на переменную val, возвращенная функцией f(), используется для присвоения значения val переменной newval.
А вот самая интересная строка в программе.
f() = 99.1; // Изменяем значение val.
При выполнении этой инструкции присваивания значение переменной val становится равным числу 99,1. И вот почему: поскольку функция f() возвращает ссылку на переменную
val, эта ссылка и является приемником инструкции присваивания. Таким образом, значение
99,1 присваивается переменной val косвенно, через ссылку на нее, которую возвращает функция f().
Наконец, при выполнении строки cout << f() << '\n'; // Отображаем новое значение val.
отображается новое значение переменной val (после того, как ссылка на переменную val
будет возвращена в результате вызова функции f() в инструкции cout).
Приведем еще один пример программы, в которой в качестве значения, возвращаемого функцией, используется ссылка (или значение ссылочного типа).
#include
using namespace std;
double &change_it(int i);
// Функция возвращает ссылку.
double vals[] = {1.1, 2.2, 3.3, 4.4, 5.5};
int main()
{
int i;
cout << "Вот исходные значения: ";

for(i=0; i<5; i++)
cout << vals[i] << ' ';
cout << '\n';
change_it(1) = 5298.23; // Изменяем 2-й элемент.
change_it(3) = -98.8; // Изменяем 4-й элемент.
cout << "Вот измененные значения: ";
for(i=0; i<5; i++)
cout << vals[i] << ' ';
cout << '\n';
return 0;
}
double &change_it(int i)
{
return vals[i]; // Возвращаем ссылку на i-й элемент.
}
Эта программа изменяет значения второго и четвертого элементов массива vals.
Результаты ее выполнения таковы.
Вот исходные значения: 1.1 2.2 3.3 4.4 5.5
Вот измененные значения: 1.1 5298.23 3.3 -98.8 5.5
Давайте разберемся, как они были получены. Функция change_it() объявлена как возвращающая ссылку на значение типа double. Говоря более конкретно, она возвращает ссылку на элемент массива vals, который задан ей в качестве параметра i. Таким образом,
при выполнении следующей инструкции функции main()

change_it(1) = 5298.23; // Изменяем 2-й элемент.
функция change_it() возвращает ссылку на элемент vals[1]. Через эту ссылку элементу
vals[1] теперь присваивается значение 5298,23. Аналогичные события происходят при выполнении и этой инструкции.
change_it(3) = -98.8; // Изменяем 4-й элемент.
Поскольку функция change_it() возвращает ссылку на конкретный элемент массива vals,
ее можно использовать в левой части инструкции для присвоения нового значения соответствующему элементу массива.
Однако, организуя возврат функцией ссылки, необходимо позаботиться о том, чтобы объект, на который она ссылается, не выходил за пределы действующей области видимости.
Например, рассмотрим такую функцию.
// Здесь ошибка: нельзя возвращать ссылку
// на локальную переменную.
int &f()
{
int i=10;
return i;
}
При завершении функции f() локальная переменная i выйдет за пределы области видимости. Следовательно, ссылка на переменную i, возвращаемая функцией f(), будет неопределенной. В действительности некоторые компиляторы не скомпилируют функцию
f() в таком виде, и именно по этой причине. Однако проблема такого рода может быть создана опосредованно, поэтому нужно внимательно отнестись к тому, на какой объект будет возвращать ссылку ваша функция.
Создание ограниченного массива
Ссылочный тип в качестве типа значения, возвращаемого функцией, можно с успехом применить для создания ограниченного массива. Как вы знаете, при выполнении С++-кода проверка нарушения границ при индексировании массивов не предусмотрена. Это означает,
что может произойти выход за границы области памяти, выделенной для массива. Другими словами, может быть задан индекс, превышающий размер массива. Однако путем создания
ограниченного, или безопасного, массива выход за его границы можно предотвратить. При работе с таким массивом любой выходящий за установленные границы индекс не допускается для индексирования массива.
Один из способов создания ограниченного массива иллюстрируется в следующей программе.
// Простой способ организации безопасного массива.

#include
using namespace std;
int &put(int i); // Помещаем значение в массив.
int get(int i); // Считываем значение из массива.
int vals[10];
int error = -1;
int main()
{
put(0) = 10; // Помещаем значения в массив.
put(1) = 20;
put(9) = 30;
cout << get(0) << ' ';
cout << get(1) << ' ';
cout << get(9) << ' ';
// А теперь специально генерируем ошибку.
put(12) =1; // Индекс за пределами границ массива.
return 0;
}
// Функция занесения значения в массив.

int &put(int i)
{
if(i>=0 && i<10)
return vals[i]; // Возвращаем ссылку на i-й элемент.
else {
cout << "Ошибка нарушения границ!\n";
return error; // Возвращаем ссылку на error.
}
}
// Функция считывания значения из массива.
int get(int i)
{
if(i>=0 && i<10)
return vals[i]; // Возвращаем значение i-го элемента.
else {
cout << "Ошибка нарушения границ!\n";
return error; // Возвращаем значение переменной error.
}
}
Результат, полученный при выполнении этой программы, выглядит так.
10 20 30 Ошибка нарушения границ!
В этой программе создается безопасный массив, предназначенный для хранения десяти целочисленных значений. Чтобы поместить в него значение, используйте функцию put(), а чтобы прочитать нужный элемент массива, вызовите функцию get(). При использовании обеих функций индекс интересующего вас элемента задается в виде аргумента. Как видно из текста программы, функции get() и put() не допускают выход за границы области памяти,
выделенной для массива. Обратите внимание на то, что функция put() возвращает ссылку на

заданный элемент и поэтому законно используется в левой части инструкции присваивания.
Несмотря на то что метод реализации безопасного массива, представленный в предыдущей программе, вполне корректен, возможен более удачный вариант. Как будет показано ниже в этой книге (при рассмотрении темы перегрузки операторов), программист может создать собственный безопасный массив, при работе с которым достаточно использовать стандартную систему обозначений.
Независимые ссылки
Понятие ссылки включено в C++ главным образом для поддержки способа передачи параметров "по ссылке" и для использования в качестве ссылочного типа значения,
возвращаемого функцией. Несмотря на это, можно объявить независимую переменную ссылочного типа, которая и называется независимой ссылкой. Однако, справедливости ради,
необходимо сказать, что эти независимые ссылочные переменные используются довольно редко, поскольку они могут "сбить с пути истинного" вашу программу. Сделав (для очистки совести) эти замечания, мы все же можем уделить независимым ссылкам некоторое внимание.
Независимая ссылка — это просто еще одно название для переменных некоторого
иного типа.
Независимая ссылка должна указывать на некоторый объект. Следовательно,
независимая ссылка должна быть инициализирована при ее объявлении. В общем случае это означает, что ей будет присвоен адрес некоторой ранее объявленной переменной. После этого имя такой ссылочной переменной можно применять везде, где может быть использована переменная, на которую она ссылается. И в самом деле, между ссылкой и переменной, на которую она ссылается, практически нет никакой разницы. Рассмотрим,
например, следующую программу.
#include
using namespace std;
int main()
{
int j, k;
int &i = j; // независимая ссылка j = 10;
cout << j << " " << i; // Выводится: 10 10
k = 121;

i = k; // Копирует в переменную j значение переменной k, а не адрес переменной k.
cout << "\n" << j; // Выводится: 121
return 0;
}
При выполнении эта программа выводит следующие результаты.
10 10 121
Адрес, который содержит ссылочная переменная, фиксирован и его нельзя изменить.
Следовательно, при выполнении инструкции i = k в переменную j (адресуемую ссылкой i)
копируется значение переменной k, а не ее адрес. В качестве еще одного примера отметим,
что после выполнения инструкции i++ ссылочная переменная i не станет содержать новый адрес, как можно было бы предположить. В данном случае на 1 увеличится содержимое переменной j.
Как было отмечено выше, независимые ссылки лучше не использовать, поскольку чаще всего им можно найти замену, а их неаккуратное применение может исказить ваш код.
Согласитесь: наличие двух имен для одной и той же переменной, по сути, уже создает ситуацию, потенциально порождающую недоразумения.
Ограничения при использовании ссылок
На применение ссылочных переменных накладывается ряд следующих ограничений.
■ Нельзя ссылаться на ссылочную переменную.
■ Нельзя создавать массивы ссылок.
■ Нельзя создавать указатель на ссылку, т.е. нельзя к ссылке применять оператор "&"
■ Ссылки не разрешено использовать для битовых полей структур. (Битовые поля рассматриваются ниже в этой книге.)
Перегрузка функций
Перегрузка функций — это механизм, который позволяет двум родственным
функциям иметь одинаковые имена.
В этом разделе мы узнаем об одной из самых удивительных возможностей языка C++ —
перегрузке функций. В C++ несколько функций могут иметь одинаковые имена, но при условии, что их параметры будут различными. Такую ситуацию называют перегрузкой
функций (function overloading), а функции, которые в ней задействованы, —
перегруженными (overloaded). Перегрузка функций — один из способов реализации полиморфизма в C++.
Рассмотрим простой пример перегрузки функций.
// "Трехкратная" перегрузка функции f().
#include

using namespace std;
void f(int i); // один целочисленный параметр void f(int i, int j); // два целочисленных параметра void f(double k); // один параметр типа double int main()
{
f (10); // вызов функции f(int)
f(10, 20); // вызов функции f (int, int)
f(12.23); // вызов функции f(double)
return 0;
}
void f(int i)
{
cout << "В функции f(int), i равно " << i << '\n';
}
void f(int i, int j)
{
cout << "В функции f(int, int), i равно " << i;
cout << ", j равно " << j << '\n';
}

void f(double k)
{
cout << "В функции f(double), k равно " << k << ' \n';
}
При выполнении эта программа генерирует следующие результаты.
В функции f(int), i равно 10
В функции f(int, int), i равно 10, j равно 20
В функции f(double), к равно 12.23
Как видите, функция f() перегружается три раза. Первая версия принимает один целочисленный параметр, вторая — два целочисленных параметра, а третья — один double- параметр. Поскольку списки параметров для всех трех версий различны, компилятор обладает достаточной информацией, чтобы вызвать правильную версию каждой функции. В
общем случае для создания перегрузки некоторой функции достаточно объявить различные ее версии.
Для определения того, какую версию перегруженной функции вызвать, компилятор использует тип и/или количество аргументов. Таким образом, перегруженные функции должны отличаться типами и/или числом параметров. Несмотря на то что перегруженные методы могут отличаться и типами возвращаемых значений, этого вида информации недостаточно для C++, чтобы во всех случаях компилятор мог решить, какую именно функцию нужно вызвать.
Чтобы лучше понять выигрыш от перегрузки функций, рассмотрим три функции из стандартной библиотеки: abs(), labs() и fabs(). Они были впервые определены в языке С, а затем ради совместимости включены в C++. Функция abs() возвращает абсолютное значение
(модуль) целого числа, функция labs() возвращает модуль длинного целочисленного значения (типа long), a fabs() — модуль значения с плавающей точкой (типа double).
Поскольку язык С не поддерживает перегрузку функций, каждая функция должна иметь собственное имя, несмотря на то, что все три функции выполняют, по сути, одно и то же действие. Это делает ситуацию сложнее, чем она есть на самом деле. Другими словами, при одних и тех же действиях программисту необходимо помнить имена всех трех (в данном случае) функций вместо одного. Но в C++, как показано в следующем примере, можно использовать только одно имя для всех трех функций.
// Создание функций myabs() — перегруженной версии функции abs().
#include
using namespace std;

// Функция myabs() перегружается тремя способами.
int myabs(int i);
double myabs(double d);
long myabs(long l);
int main()
{
cout << myabs(-10) << "\n";
cout << myabs(-11.0) << "\n";
cout << myabs(-9L) << "\n";
return 0;
}
int myabs(int i)
{
cout << "Использование int-функции myabs(): ";
if(i<0) return -i;
else return i;
}
double myabs(double d)
{

cout << "Использование double-функции myabs(): ";
if(d<0.0) return -d;
else return d;
}
long myabs(long l)
{
cout << "Использование long-функции myabs(): ";
if(1<0) return -1;
else return 1;
}
Результаты выполнения этой программы таковы.
Использование int-функции myabs(): 10
Использование double-функции myabs(): 11
Использование long-функции myabs(): 9
При выполнении эта программа создает три похожие, но все же различные функции,
вызываемые с использованием "общего" (одного на всех) имени myabs. Каждая из них возвращает абсолютное значение своего аргумента. Во всех ситуациях вызова компилятор "знает", какую именно функцию ему использовать. Для принятия решения ему достаточно "взглянуть" на тип аргумента, передаваемого функции. Принципиальная значимость перегрузки состоит в том, что она позволяет обращаться к связанным функциям посредством одного, общего для всех, имени. Следовательно, имя myabs представляет общее действие, которое выполняется во всех случаях. Компилятору остается правильно выбрать конкретную версию при конкретных обстоятельствах.
Благодаря полиморфизму программисту нужно помнить не три различных имени, а только одно. Несмотря на простоту приведенного примера, он позволяет понять, насколько перегрузка способна упростить процесс программирования.
Каждая версия перегруженной функции может выполнять любые действия. Другими словами, не существует правила, которое бы обязывало программиста связывать перегруженные функции общими действиями. Однако с точки зрения стилистики перегрузка функций все-таки подразумевает определенное "родство" его версий. Таким образом, несмотря на то, что одно и то же имя можно использовать для перегрузки не связанных общими действиями функций, этого делать не стоит. Например, в принципе можно использовать имя sqr для создания функции, которая возвращает квадрат целого

числа, и функции, которая возвращает значение квадратного корня из вещественного числа
(типа double). Но, поскольку эти операции фундаментально различны, применение механизма перегрузки методов в этом случае сводит на нет его первоначальную цель.
(Такой стиль программирования, наверное, подошел бы лишь для того, чтобы ввести в заблуждение конкурента.) На практике перегружать имеет смысл только тесно связанные операции.
Анахронизм в виде ключевого слова overload
На заре создания C++ перегруженные функции необходимо было явным образом объявлять таковыми с помощью ключевого слова overload. Это ключевое слово больше не требуется в C++. В действительности стандартом C++ оно даже не включено в список ключевых слов. Однако время от времени его можно встретить в каком-нибудь С++-коде,
особенно в старых книгах и статьях.
Общая форма использования ключевого слова overload такова.
overload func_name;
Здесь элемент func_name представляет собой имя перегружаемой функции. Эта инструкция должна предшествовать объявлениям перегруженных функций. (В общем случае оно встречается в начале программы.) Например, если функция Counter() является перегруженной, то в программу могла быть включена такая строка.
overload Counter;
Если вы встретите overload-объявления при работе со старыми программами, их можно просто удалить: они больше не нужны. Поскольку ключевое слово overload — анахронизм,
его не следует использовать в новых С++-программах. На самом деле большинство компиляторов его попросту не воспримет.
Аргументы, передаваемые функции по умолчанию
В C++ мы можем придать параметру некоторое значение, которое будет автоматически использовано, если при вызове функции не задается аргумент, соответствующий этому параметру. Аргументы, передаваемые функции по умолчанию, можно использовать, чтобы упростить обращение к сложным функциям, а также в качестве "сокращенной формы"
перегрузки функций.
Задание аргументов, передаваемых функции по умолчанию, синтаксически аналогично инициализации переменных. Рассмотрим следующий пример, в котором объявляется функция myfunc(), принимающая один аргумент типа double с действующим по умолчанию значением 0.0 и один символьный аргумент с действующим по умолчанию значением 'Х'.
void myfunc(double num = 0.0, char ch = 'Х')
{

}
После такого объявления функцию myfunc() можно вызвать одним из трех следующих способов.
myfunc(198.234, 'A'); // Передаем явно заданные значения.
myfunc(10.1); // Передаем для параметра num значение 10.1, а для параметра ch позволяем применить аргумент, задаваемый по умолчанию ('Х').
myfunc(); // Для обоих параметров num и ch позволяем применить аргументы, задаваемые по умолчанию.
При первом вызове параметру num передается значение 198.234, а параметру ch —
символ 'А'. Во время второго вызова параметру num передается значение 10.1, а параметр ch
по умолчанию устанавливается равным символу 'Х'. Наконец, в результате третьего вызова как параметр num, так и параметр ch по умолчанию устанавливаются равными значениям,
заданным в объявлении функции.
Включение в C++ возможности передачи аргументов по умолчанию позволяет программистам упрощать код программ. Чтобы предусмотреть максимально возможное количество ситуаций и обеспечить их корректную обработку, функции часто объявляются с большим числом параметров, чем необходимо в наиболее распространенных случаях.
Поэтому благодаря применению аргументов по умолчанию программисту нужно указывать не все аргументы (используемые в общем случае), а только те, которые имеют смысл для определенной ситуации.
Аргумент, передаваемый функции по умолчанию, представляет собой значение, которое
будет автоматически передано параметру функции в случае, если аргумент,
соответствующий этому параметру, явным образом не задан.
Насколько полезна возможность передачи аргументов по умолчанию, показано на примере функции clrscr(), представленной в следующей программе. Функция clrscr()
очищает экран путем вывода последовательности символов новой строки (это не самый эффективный способ, но он очень подходит для данного примера). Поскольку в наиболее часто используемом режиме представления видеоизображений на экран дисплея выводится
25 строк текста, то в качестве аргумента по умолчанию используется значение 25. Но так как в других видеорежимах на экране может отображаться больше или меньше 25 строк,
аргумент, действующий по умолчанию, можно переопределить, явно указав нужное значение.
#include
using namespace std;
void clrscr(int size=25);

int main()
{
int i;
for(i=0; i<30; i++ ) cout << i << '\n';
clrscr(); // Очищаем 25 строк.
for(i=0; i<30; i++ ) cout << i << '\n';
clrscr(10); // Очищаем 10 строк.
return 0;
}
void clrscr(int size)
{
for(; size; size--) cout << '\n';
}
Как видно из кода этой программы, если значение, действующее по умолчанию,
соответствует ситуации, при вызове функции clrscr() аргумент указывать не нужно. Но в других случаях аргумент, действующий по умолчанию, можно переопределить и передать параметру size нужное значение.
При создании функций, имеющих значения аргументов, передаваемых по умолчанию,
необходимо помнить две вещи. Эти значения по умолчанию должны быть заданы только однажды, причем при первом объявлении функции в файле. В предыдущем примере аргумент по умолчанию был задан в прототипе функции clrscr(). При попытке определить новые (или даже те же) передаваемые по умолчанию значения аргументов в определении функции clrscr() компилятор отобразит сообщение об ошибке и не скомпилирует вашу программу.
Несмотря на то что передаваемые по умолчанию аргументы должны быть определены только один раз, для каждой версии перегруженной функции для передачи по умолчанию можно задавать различные аргументы. Таким образом, разные версии перегруженной функции могут иметь различные значения аргументов, действующие по умолчанию.
Важно понимать, что все параметры, которые принимают значения по умолчанию,

должны быть расположены справа от остальных. Например, следующий прототип функции содержит ошибку.
// Неверно!
void f(int а = 1, int b);
Если вы начали определять параметры, которые принимают значения по умолчанию,
нельзя после них указывать параметры, задаваемые при вызове функции только явным образом. Поэтому следующее объявление также неверно и не будет скомпилировано.
int myfunc(float f, char *str, int i=10, int j);
Поскольку для параметра i определено значение по умолчанию, для параметра j также нужно задать значение по умолчанию.
Сравнение возможности передачи аргументов по умолчанию с перегрузкой
функций
Как упоминалось в начале этого раздела, одним из применений передачи аргументов по умолчанию является "сокращенная форма" перегрузки функций. Чтобы понять это,
представьте, что вам нужно создать две "адаптированные" версии стандартной функции
strcat(). Одна версия должна присоединять все содержимое одной строки к концу другой.
Вторая же принимает третий аргумент, который задает количество конкатенируемых
(присоединяемых) символов. Другими словами, эта версия должна конкатенировать только заданное количество символов одной строки к концу другой.
Допустим, что вы назвали свои функции именем mystrcat() и предложили такой вариант их прототипов.
void mystrcat(char *s1, char *s2, int len);
void mystrcat(char *s1, char *s2);
Первая версия должна скопировать len символов из строки s2 в конец строки s1. Вторая версия копирует всю строку, адресуемую указателем s2, в конец строки, адресуемой указателем s1, т.е. действует подобно стандартной функции strcat().
Несмотря на то что для достижения поставленной цели можно реализовать две версии функции mystrcat(), есть более простой способ решения этой задачи. Используя возможность передачи аргументов по умолчанию, можно создать только одну функцию
mystrcat(), которая заменит обе задуманные ее версии. Реализация этой идеи продемонстрирована в следующей программе.
// Применение пользовательской версии функции strcat().
#include
#include
using namespace std;

void mystrcat(char *s1, char *s2, int len = -1);
int main()
{
char str1[80] = "Это тест.";
char str2[80] = "0123456789";
mystrcat(str1, str2, 5); // Присоединяем 5 символов.
cout << str1 << '\n';
strcpy(str1, "Это тест."); // Восстанавливаем str1.
mystrcat(str1, str2); // Присоединяем всю строку.
cout << str1 << '\n';
return 0;
}
// Пользовательская версия функции strcat().
void mystrcat(char *s1, char *s2, int len)
{
// Находим конец строки s1.
while(*s1) s1++;
if(len == -1) len = strlen(s2);
while(*s2 && len) {

*s1 = *s2; // Копируем символы.
s1++; s2++; len--;
}
*s1 = '\0'; // Завершаем строку s1 нулевым символом.
}
Здесь функция mystrcat() присоединяет len символов строки, адресуемой параметром s2,
к концу строки, адресуемой параметром s1. Но если значение len равно -1, как и в случае разрешения передачи этого аргумента по умолчанию, функция mystrcat() присоединит к строке s1 всю строку, адресуемую параметром s2. (Другими словами, если значение len
равно -1, функция mystrcat() действует подобно стандартной функции strcat().) Используя для параметра len возможность передачи аргумента по умолчанию, обе операции можно объединить в одной функции.
Этот пример позволил продемонстрировать, как аргументы, передаваемые функции по умолчанию, обеспечивают основу для сокращенной формы объявления перегруженных функций.
Об использовании аргументов, передаваемых по умолчанию
Несмотря на то что аргументы, передаваемые функции по умолчанию, — очень мощное средство программирования (при их корректном использовании), с ними могут иногда возникать проблемы. Их назначение — позволить функции эффективно выполнять свою работу, обеспечивая при всей простоте этого механизма значительную гибкость. В этом смысле все передаваемые по умолчанию аргументы должны отражать способ наиболее общего использования функции или альтернативного ее применения. Если не существует некоторого единого значения, которое обычно присваивается тому или иному параметру, то и нет смысла объявлять соответствующий аргумент по умолчанию. На самом деле объявление аргументов, передаваемых функции по умолчанию, при недостаточном для этого основании деструктуризирует код, поскольку такие аргументы способны сбить с толку любого, кому придется разбираться в такой программе. Наконец, основным принципом использования аргументов по умолчанию должен быть, как у врачей, принцип "не
навредить". Другими словами, случайное использование аргумента по умолчанию не должно привести к необратимым отрицательным последствиям. Ведь такой аргумент можно просто забыть указать при вызове некоторой функции, и, если это случится,
подобный промах не должен вызвать, например, потерю важных данных!
Перегрузка функций и неоднозначность
Неоднозначность возникает тогда, когда компилятор не может определить различие
между двумя перегруженными функциями.
Прежде чем завершить эту главу, мы должны исследовать вид ошибок, уникальный для
C++: неоднозначность. Возможны ситуации, в которых компилятор не способен сделать выбор между двумя (или более) корректно перегруженными функциями. Такие ситуации и называют
неоднозначными.
Инструкции, создающие неоднозначность, являются

ошибочными, а программы, которые их содержат, скомпилированы не будут.
Основной причиной неоднозначности в C++ является автоматическое преобразование типов. В C++ делается попытка автоматически преобразовать тип аргументов, используемых для вызова функции, в тип параметров, определенных функцией. Рассмотрим пример.
int myfunc(double d);
cout << myfunc('c'); // Ошибки нет, выполняется преобразование типов.
Как отмечено в комментарии, ошибки здесь нет, поскольку C++ автоматически преобразует символ 'c' в его double-эквивалент. Вообще говоря, в C++ запрещено довольно мало видов преобразований типов. Несмотря на то что автоматическое преобразование типов — это очень удобно, оно, тем не менее, является главной причиной неоднозначности.
Рассмотрим следующую программу.
// Неоднозначность вследствие перегрузки функций.
#include
using namespace std;
float myfunc(float i);
double myfunc(double i);
int main()
{
// Неоднозначности нет, вызывается функция myfunc(double).
cout << myfunc (10.1) << " ";
// Неоднозначность.
cout << myfunc(10);

return 0;
}
float myfunc(float i)
{
return i;
}
double myfunc(double i)
{
return -i;
}
Здесь благодаря перегрузке функция myfunc() может принимать аргументы либо типа
float, либо типа double. При выполнении строки кода cout << myfunc (10.1) << " ";
не возникает никакой неоднозначности: компилятор "уверенно" обеспечивает вызов функции myfunc(double), поскольку, если не задано явным образом иное, все литералы с плавающей точкой в C++ автоматически получают тип double. Но при вызове функции
myfunc() с аргументом, равным целому числу 10, в программу вносится неоднозначность,
поскольку компилятору неизвестно, в какой тип ему следует преобразовать этот аргумент:
float или double. Оба преобразования допустимы. В такой неоднозначной ситуации будет выдано сообщение об ошибке, и программа не скомпилируется.
На примере предыдущей программы хотелось бы подчеркнуть, что неоднозначность в ней вызвана не перегрузкой функции myfunc(), объявленной дважды для приема double- и
float-аргумента, а использованием при конкретном вызове функции myfunc() аргумента неопределенного для преобразования типа. Другими словами, ошибка состоит не в перегрузке функции myfunc(), а в конкретном ее вызове.
А вот еще один пример неоднозначности, вызванной автоматическим преобразованием типов в C++.
// Еще одна ошибка, вызванная неоднозначностью.
#include
using namespace std;

char myfunc(unsigned char ch);
char myfunc(char ch);
int main()
{
cout << myfunc('c'); // Здесь вызывается myfunc(char).
cout << myfunc(88) << " "; // Вносится неоднозначность.
return 0;
}
char myfunc(unsigned char ch)
{
return ch-1;
}
char myfunc(char ch)
{
return ch+1;
}
В C++ типы unsigned char и char не являются существенно неоднозначными. (Это —
различные типы.) Но при вызове функции myfunc() с целочисленным аргументом 88
компилятор "не знает", какую функцию ему выполнить, т.е. в значение какого типа ему следует преобразовать число 88: типа char или типа unsigned char? Оба преобразования здесь вполне допустимы.
Неоднозначность может быть также вызвана использованием в перегруженных функциях аргументов, передаваемых по умолчанию. Для примера рассмотрим следующую программу.
// Еще один пример неоднозначности.

#include
using namespace std;
int myfunc(int i);
int myfunc(int i, int j=1);
int main()
{
cout << myfunc(4, 5) << " "; // неоднозначности нет cout << myfunc(10); // неоднозначность return 0;
}
int myfunc(int i)
{
return i;
}
int myfunc(int i, int j)
{
return i*j;
}
Здесь в первом обращении к функции myfunc() задается два аргумента, поэтому у компилятора нет никаких сомнений в выборе нужной функции, а именно myfunc(int i, int j),
т.е. никакой неоднозначности в этом случае не привносится. Но при втором обращении к функции myfunc() мы получаем неоднозначность, поскольку компилятор "не знает", то ли ему вызвать версию функции myfunc(), которая принимает один аргумент, то ли

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

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