Программирование. Принципы и практика использования C++ Исправленное издание

Страуструп Бьерн

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

void f(int, const string&, double);

void f(int, const char*, int);

f(1,"hello",1); // OK: call f(int, const char*, int)

f(1,string("hello"),1.0); // OK: call f(int, const string&, double)

f(1, "hello",1.0); //

ошибка: неоднозначность

В последнем вызове строка "

hello

" соответствует типу

const char*

без преобразования, а типу

const string&

— только после преобразования. С другой стороны, число

1.0

соответствует типу

double

без преобразования, а число типа

int

— только после преобразования, поэтому ни один из вариантов функции

f

не соответствует правилам лучше других.

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

A.9.2. Аргументы по умолчанию

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

void f(int, int=0, int=0);

f(1,2,3);

f(1,2); // вызовы f(1,2,0)

f(1); // вызовы f(1,0,0)

Задавать по умолчанию можно только замыкающие аргументы. Рассмотрим пример.

void g(int, int =7, int); // ошибка: по умолчанию задан

// не замыкающий аргумент

f(1,,1); // ошибка: пропущен второй аргумент

Альтернативой аргументам, заданным по умолчанию, может быть перегрузка (и наоборот).

A.9.3. Неопределенные аргументы

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

printf

(см. разделы 27.6.1 и Б.10.2):

void printf(const char* format ...); // получает форматную строку и,

// может быть, что-то еще

int x = 'x';

printf("hello, world!");

printf("print a char '%c'\n",x); // печатает целое число x как

// символ

printf("print a string \"%s\"",x); // "выстрел

себе в ногу"

Спецификаторы формата в форматной строке, такие как

%c

и

%s

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

A.9.4. Спецификации связей

Код на языке С++ часто используется наряду с кодом на языке С в одной и той же программе; иначе говоря, одни части бывают написаны на языке С++ (и скомпилированы с помощью компилятора языка С++), а другие — на языке С (и скомпилированы с помощью компилятора языка С). Для того чтобы воспользоваться этой возможностью, язык С++ предлагает программистам спецификации связей (linkage specifications), указывающие, что та или иная функция может быть вызвана из модуля, написанного на языке С. Спецификацию связи с языком С можно поместить перед объявлением функции.

extern "C" void callable_from_C(int);

В качестве альтернативы ее можно применить ко всем объявлениям в блоке.

extern "C" {

void callable_from_C(int);

int and_this_one_also(double, int*);

/* ... */

}

Детали можно найти в разделе 27.2.3.

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

A.10. Типы, определенные пользователем

Есть два способа определить новый (пользовательский) тип: в виде класса (

class

,

struct

и

union

; см. раздел A.12) и в виде перечисления (

enum

; см. раздел A.11).

A.10.1. Перегрузка операций

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

operator

; например, имя функции, определяющей оператор

+

, выглядит как

operator +

.

Matrix operator+(const Matrix&, const Matrix&);

Примеры можно найти в определениях классов

std::ostream

(см. главы 10-11),

std::vector

(см. главы 17–19 и раздел Б.4),

std::complex

(см. раздел Б.9.3) и

Matrix

(см. главу 24).

Перегрузить можно все операторы за исключением следующих:

?: . .* :: sizeof typeid

Функции, определяющие следующие операторы, должны быть членами класса: