Функция (function) — это именованный фрагмент кода, получающий (возможно, пустой) набор аргументов и (необязательно) возвращающий значение. Функция объявляется с помощью указания типа возвращаемого значения, за которым следует ее имя и список параметров.
char f(string, int);
Также вам может показаться, что такая тема как
http://www.schungit.ru/auxpage_3
никак не связана и даже не тематична с программированием. Хотя, может быть и связана.
В любом случае все-таки зайдите на сайт schungit.ru
Тема шунгит купить в Москве там представлена весьма широко.
Итак, f — это функция, принимающая объекты типа string и int и возвращающая объект типа char. Если функция должна быть просто объявлена, но не определена, то ее объявление завершается точкой с запятой. Если функция должна быть определена, то за объявлением аргументов следует тело функции.
char f(string s, int i) { return s[i]; }
Телом функции должен быть блок или блок try. Функция, в объявлении которой указано, что она возвращает какое-то значение, должна его возвращать (используя оператор return).
char f(string s, int i) { char c = s[i]; } // ошибка: ничего
// не возвращается
Функция main() представляет собой странное исключение из этого правила. За исключением функции main(), если не хотите возвращать значение, то поставьте перед именем функции ключевое слово void. Другими словами, используйте слово void как тип возвращаемого значения.
void increment(int& x) { ++x; } // OK: возвращать значение
// не требуется
Функция вызывается с помощью оператора вызова () с соответствующим списком аргументов.
char x1 = f(1,2); // ошибка: первый аргумент функции f() должен // быть строкой string s = "Battle of Hastings";
char x2 = f(s); // ошибка: функция f() требует двух аргументов
char x3 = f(s,2); // OK
Разрешение перегрузки
Разрешение перегрузки (overload resolution) — это процесс выбора функции
для вызова на основе набора аргументов. Рассмотрим пример.
void print(int);
void print(double);
void print(const std::string&);
print(123); // вызывается print(int)
print(1.23); // вызывается print(double)
print("123"); // вызывается print(const string&)
Компилятор, руководствуясь правилами языка, может самостоятельно выбрать правильную функцию. К сожалению, эти правила довольно сложные, поскольку они пытаются учесть максимально сложные примеры. Здесь мы приведем их упрощенный вариант.
Выбор правильного варианта перегруженной функции осуществляется на основе поиска наилучшего соответствия между типами аргументов функции и типами ее параметров (формальных аргументов).
Для конкретизации нашего представления о выборе наилучшего соответствия сформулируем несколько критериев.
1. Точное совпадение, т. е. совпадение при полном отсутствии преобразований типов или при наличии только самых простых преобразований (например, преобразование имени массива в указатель, имени функции — в указатель на функцию и типа T — в тип const T).
2. Совпадение после продвижения, т.е. целочисленные продвижения (bool — в int, char — в int, short — в int и их аналоги без знака;, а также преобразование типа float в double.
3. Совпадение после стандартных преобразований, например, int — в double, double — в int, double — в long double, Derived* — в Base*, T* — в void*, int — в unsigned int.
4. Совпадение после преобразований, определенных пользователем.
5. Совпадение на основе эллипсиса ... в объявлении функции.
Если найдено два совпадения, то вызов отменяется как неоднозначный. Правила
разрешения перегрузки ориентированы в основном на встроенные числовые типы.
Для разрешения перегрузки на основе нескольких аргументов мы сначала должны найти наилучшее совпадение для каждого аргумента. Выбирается та из функций, которая по каждому аргументу подходит так же хорошо, как и остальные функции, но лучше всех остальных соответствует вызову по одному из аргументов; в противном случае вызов считается неоднозначным. Рассмотрим пример.
void f(int, const string&, double); void f(int, const char*, int);
f(1,"helloM,1); // OK: call f(int, const char*, int)
f(1,string(Mhello"),1.0); // OK: call f(int, const string&, double) f(1, "hello",1.0); // ошибка: неоднозначность
В последнем вызове строка "hello" соответствует типу const char* без преобразования, а типу const string& — только после преобразования. С другой стороны, число 1.0 соответствует типу double без преобразования, а число типа int — только после преобразования, поэтому ни один из вариантов функции f() не соответствует правилам лучше других.
Если эти упрощенные правила не соответствуют правилам вашего компилятора и вашим представлениям, в первую очередь следует предположить, что ваша программа сложнее, чем требуется. Постарайтесь упростить код, в противном случае проконсультируйтесь с экспертами.
Аргументы по умолчанию
Иногда функции имеют больше аргументов, чем это требуется в наиболее часто встречающихся распространенных ситуациях. Для того чтобы учесть это обстоятельство, программист может предусмотреть аргументы по умолчанию, которые будут использоваться, если при вызове соответствующие аргументы не будут заданы. Рассмотрим пример.
void f(int, int=0, int=0); f(1,2,3);
f(1,2); // вызовы f(1,2,0) f(1); // вызовы f(1,0,0)
Задавать по умолчанию можно только замыкающие аргументы. Рассмотрим пример.
A.9. ФУНКЦИИ
1113
void g(int, int =7, int); // ошибка: по умолчанию задан
// не замыкающий аргумент f(1,,1); // ошибка: пропущен второй аргумент
Альтернативой аргументам, заданным по умолчанию, может быть перегрузка (и наоборот).
|
Главная
Каталог файлов
