Перегруженные функции. Подставляемые (встраиваемые) функции
C ++ позволяет указать более одного определения для функции имени или оператора в той же области, что называется функция перегрузки и перегрузки операторов соответственно.
Перегруженное объявление представляет собой объявление, объявленное с тем же именем, что и ранее объявленное объявление в той же области видимости, за исключением того, что обе декларации имеют разные аргументы и, очевидно, другое определение (реализация).
Когда вы вызываете перегруженную функцию или оператор , компилятор определяет наиболее подходящее определение для использования, сравнивая типы аргументов, которые вы использовали для вызова функции или оператора, с типами параметров, указанными в определениях. Процесс выбора наиболее подходящей перегруженной функции или оператора называется разрешением перегрузки .
Перегрузка функций в C ++
Вы можете иметь несколько определений для одного и того же имени функции в той же области. Определение функции должно отличаться друг от друга по типам и / или количеству аргументов в списке аргументов. Вы не можете перегружать объявления функций, которые отличаются только возвращаемым типом.
Ниже приведен пример, когда одна и та же функция print () используется для печати разных типов данных -
#include
Printing int: 5 Printing float: 500.263 Printing character: Hello C++
Перегрузка операторов в C ++
Вы можете переопределить или перегрузить большинство встроенных операторов, доступных на C ++. Таким образом, программист может также использовать операторы с определенными пользователем типами.
Перегруженные операторы - это функции со специальными именами: ключевое слово «оператор», за которым следует символ для определяемого оператора. Как и любая другая функция, перегруженный оператор имеет тип возврата и список параметров.
Box operator+(const Box&);
объявляет оператор добавления, который можно использовать для добавления двух объектов Box и возвращает конечный объект Box. Большинство перегруженных операторов могут быть определены как обычные функции, не являющиеся членами, или как функции членов класса. В случае, если мы определяем функцию выше как функцию, не являющуюся членом класса, мы должны были бы передать два аргумента для каждого операнда следующим образом:
Box operator+(const Box&, const Box&);
Ниже приведен пример, показывающий концепцию оператора при загрузке с использованием функции-члена. Здесь объект передается как аргумент, свойства которого будут доступны с помощью этого объекта, к объекту, который вызовет этот оператор, можно получить доступ с помощью этого оператора, как описано ниже -
#include Когда приведенный выше код компилируется и выполняется, он производит следующий результат: Volume of Box1: 210
Volume of Box2: 1560
Volume of Box3: 5400
Ниже приведен список операторов, которые могут быть перегружены. Перегрузка функций
Перегрузка операций (операторов, функций, процедур)
- в программировании - один из способов реализации полиморфизма , заключающийся в возможности одновременного существования в одной области видимости нескольких различных вариантов операции (оператора, функции или процедуры), имеющих одно и то же имя, но различающихся типами параметров, к которым они применяются. Термин «перегрузка» - это калька английского «overloading», появившаяся в русских переводах книг по языкам программирования в первой половине 1990-х годов. Возможно, это не самый лучший вариант перевода, поскольку слово «перегрузка» в русском языке имеет устоявшееся собственное значение, кардинально отличающееся от вновь предложенного, тем не менее, он прижился и распространён достаточно широко. В изданиях советского времени аналогичные механизмы назывались по-русски «переопределением» или «повторным определением» операций, но и этот вариант небесспорен: возникают разночтения и путаница в переводах английских «override», «overload» и «redefine». В большинстве ранних языков программирования существовало ограничение, согласно которому одновременно в программе не может быть доступно более одной операции с одним и тем же именем. Соответственно, все функции и процедуры, видимые в данной точке программы, должны иметь различные имена. Имена и обозначения функций, процедур и операторов, являющихся частью языка программирования, не могут быть использованы программистом для именования собственных функций, процедур и операторов. В некоторых случаях программист может создать собственный программный объект с именем другого, уже имеющегося, но тогда вновь созданный объект «перекрывает» предыдущий, и одновременно использовать оба варианта становится невозможно. Подобное положение неудобно в некоторых, достаточно часто встречающихся случаях. Отчасти проблема решается средствами объектного программирования - когда новые типы данных объявляются как классы, операции над ними могут быть оформлены как методы классов, в том числе и одноимённые (поскольку методы разных классов не обязаны иметь различные имена), но, во-первых, оформление подобным образом операций над значениями разных типов неудобно, а во-вторых, это не решает проблему создания новых операторов. Сама по себе перегрузка операций - всего лишь «синтаксический сахар », хотя даже в таком качестве она может быть полезна, потому что она позволяет разработчику программировать более естественным образом и делает поведение пользовательских типов более похожим на поведение встроенных. Если же подойти к вопросу с более общих позиций, то можно заметить, что средства, позволяющие расширять язык, дополнять его новыми операциями и синтаксическими конструкциями (а перегрузка операций является одним из таких средств, наряду с объектами, макрокомандами, функционалами, замыканиями) превращают его уже в метаязык - средство описания языков, ориентированных на конкретные задачи. С его помощью можно для каждой конкретной задачи построить языковое расширение, наиболее ей соответствующее, которое позволит описывать её решение в наиболее естественной, понятной и простой форме. Например, в приложении к перегрузке операций: создание библиотеки сложных математических типов (векторы, матрицы) и описание операций с ними в естественной, «математической» форме, создаёт «язык для векторных операций», в котором сложность вычислений скрыта, и возможно описывать решение задач в терминах векторных и матричных операций, концентрируясь на сути задачи, а не на технике. Именно из этих соображений подобные средства были в своё время включены в язык Алгол-68 . Перегрузка операций предполагает введение в язык двух взаимосвязанных особенностей: возможности объявлять в одной области видимости несколько процедур или функций с одинаковыми именами и возможности описывать собственные реализации операций (то есть знаков операций, обычно записываемых в инфиксной нотации, между операндами). Принципиально реализация их достаточно проста: Перегрузка процедур и функций на уровне общей идеи, как правило, не представляет сложности ни в реализации, ни в понимании. Однако даже в ней имеются некоторые «подводные камни», которые необходимо учитывать. Разрешение перегрузки операций создаёт гораздо больше проблем как для реализатора языка, так и для работающего на этом языке программиста. Первый вопрос, с которым сталкивается разработчик транслятора языка, разрешающего перегрузку процедур и функций: каким образом из числа одноимённых процедур выбрать ту, которая должна быть применена в данном конкретном случае? Всё хорошо, если существует вариант процедуры, типы формальных параметров которого в точности совпадают с типами параметров фактических, применённых в данном вызове. Однако практически во всех языках в употреблении типов существует некоторая степень свободы, предполагающая, что компилятор в определённых ситуациях автоматически выполняет безопасные преобразования типов. Например, в арифметических операциях над вещественным и целым аргументами целый обычно приводится к вещественному типу автоматически, и результат получается вещественным. Предположим, что существует два варианта функции add: Int add(int a1, int a2);
float add(float a1, float a2);
Каким образом компилятор должен обработать выражение y = add(x, i) , где x имеет тип float, а i - тип int? Очевидно, что точного совпадения нет. Имеется два варианта: либо y=add_int((int)x,i) , либо как y=add_flt(x, (float)i) (здесь именами add_int и add_float обозначены соответственно, первый и второй варианты функции). Возникает вопрос: должен ли транслятор разрешать подобное использование перегруженных функций, а если должен, то на каком основании он будет выбирать конкретный используемый вариант? В частности, в приведённом выше примере, должен ли транслятор при выборе учитывать тип переменной y? Нужно отметить, что приведённая ситуация - простейшая, возможны гораздо более запутанные случаи, которые усугубляются тем, что не только встроенные типы могут преобразовываться по правилам языка, но и объявленные программистом классы при наличии у них родственных отношений допускают приведение один к другому. Решений у этой проблемы два: В отличие от процедур и функций, инфиксные операции языков программирования имеют два дополнительных свойства, существенным образом влияющих на их функциональность: приоритет и ассоциативность , наличие которых обуславливается возможностью «цепочной» записи операторов (как понимать a+b*c: как (a+b)*c или как a+(b*c) ? Выражение a-b+c - это (a-b)+c или a-(b+c) ?). Встроенные в язык операции всегда имеют наперёд заданные традиционные приоритеты и ассоциативность. Возникает вопрос: какие приоритеты и ассоциативность будут иметь переопределённые версии этих операций или, тем более, новые созданные программистом операции? Есть и другие тонкости, которые могут требовать уточнения. Например, в Си существуют две формы операций увеличения и уменьшения значения ++ и -- - префиксная и постфиксная, поведение которых различается. Как должны вести себя перегруженные версии таких операций? Различные языки по-разному решают приведённые вопросы. Так, в C++ приоритет и ассоциативность перегруженных версий операций сохраняются такими же, как и у определённых в языке; перегрузить отдельно префиксную и постфиксную форму операторов инкремента и декреманта возможно, используя специальные сигнатуры: Таким образом, int используется для внесения различия в сигнатуры Ещё сложнее обстоит дело с объявлением новых операций. Включить в язык саму возможность такого объявления несложно, но вот реализация его сопряжена со значительными трудностями. Объявление новой операции - это, фактически, создание нового ключевого слова языка программирования, осложнённое тем фактом, что операции в тексте, как правило, могут следовать без разделителей с другими лексемами. При их появлении возникают дополнительные трудности в организации лексического анализатора. Например, если в языке уже есть операции «+» и унарный «-» (изменение знака), то выражение a+-b можно безошибочно трактовать как a + (-b) , но если в программе объявляется новая операция +- , тут же возникает неоднозначность, ведь то же выражение можно уже разобрать и как a (+-) b . Разработчик и реализатор языка должен каким-то образом решать подобные проблемы. Варианты, опять-таки, могут быть различными: потребовать, чтобы все новые операции были односимвольными, постулировать, что при любых разночтениях выбирается «самый длинный» вариант операции (то есть до тех пор, пока очередной читаемый транслятором набор символов совпадает с какой-либо операцией, он продолжает считываться), пытаться обнаруживать коллизии при трансляции и выдавать ошибки в спорных случаях… Так или иначе, языки, допускающие объявление новых операций, решают эти проблемы. Не следует забывать, что для новых операций также стоит вопрос определения ассоциативности и приоритета. Здесь уже нет готового решения в виде стандартной языковой операции, и обычно приходится просто задать эти параметры правилами языка. Например, сделать все новые операции левоассоциативными и дать им один и тот же, фиксированный, приоритет, либо ввести в язык средства задания того и другого. Когда перегружаемые операции, функции и процедуры используются в языках со строгой типизацией, где каждая переменная имеет предварительно описанный тип, задача выбора варианта перегруженной операции, используемого в каждом конкретном случае, независимо от её сложности, решается транслятором. Это означает, что для компилируемых языков использование перегрузки операций не приводит к снижению быстродействия - в любом случае, в объектном коде программы присутствует вполне определённая операция или вызов функции. Иначе обстоит дело при возможности использования в языке полиморфных переменных, то есть переменных, которые могут в разные моменты времени содержать значения разных типов. Поскольку тип значения, к которому будет применяться перегруженная операция, неизвестен на момент трансляции кода, компилятор лишён возможности выбрать нужный вариант заранее. В этом случае он вынужден встраивать в объектный код фрагмент, который непосредственно перед выполнением данной операции определит типы находящихся в аргументах значений и динамически выберет вариант, соответствующий этому набору типов. Причём такое определение нужно производить при каждом исполнении операции, ведь даже тот же самый код, будучи вызван второй раз, вполне может исполняться по-другому. Таким образом, использование перегрузки операций в сочетании с полиморфными переменными делает неизбежным динамическое определение вызываемого кода. Использование перегрузки не всеми специалистами считается благом. Если перегрузка функций и процедур, в общем, не находит серьёзных возражений (отчасти, потому, что не приводит к некоторым типично «операторным» проблемам, отчасти - из-за меньшего соблазна её использования не по назначению), то перегрузка операций, как в принципе, так и в конкретных языковых реализациях, подвергается достаточно жёсткой критике со стороны многих теоретиков и практиков программирования. Критики отмечают, что приведённые выше проблемы идентификации, приоритета и ассоциативности часто делают работу с перегруженными операциями либо неоправданно сложной, либо неестественной: Насколько удобство от пользования собственными операциями способно перевесить неудобства от ухудшения управляемости программы - вопрос, не имеющий однозначного ответа. С позиции реализации языка те же самые проблемы приводят к усложнению трансляторов и понижению их эффективности и надёжности. А использование перегрузки совместно с полиморфными переменными, к тому же заведомо медленнее, чем вызов жёстко прошитой при компиляции операции, и даёт меньше возможностей для оптимизации объектного кода. Отдельной критике подвергаются конкретные особенности реализации перегрузки в различных языках. Так, в C++ объектом критики может стать отстутствие соглашения о внутреннем представление имён перегруженных функций, что порождает несовместимость на уровне бибилиотек, скомпилированных разными компиляторами C++. Часть критиков высказываются против перегрузки операций, исходя из общих принципов теории разработки программного обеспечения и реальной промышленной практики. Ниже приведена классификация некоторых языков программирования по тому, позволяют ли они перегрузку операторов, и ограничены ли операторы предопределённым набором: Wikimedia Foundation
.
2010
.
- (операторов, функций, процедур) в программировании один из способов реализации полиморфизма, заключающийся в возможности одновременного существования в одной области видимости нескольких различных вариантов операции (оператора, функции или… … Википедия
Есть ли способ добиться перегрузки функций в C? Я смотрю на простые функции, которые могут быть перегружены как Foo (int a)
foo (char b)
foo (float c , int d)
Я думаю, что нет прямого пути; Я ищу обходные пути, если таковые существуют. В смысле вы имеете в виду - нет, вы не можете. Вы можете объявить функцию va_arg как void my_func(char* format, ...); Но вам нужно будет передать некоторую информацию о количестве переменных и их типах в первом аргументе - например, printf() . Да, вроде. Здесь вы приводите пример: Void printA(int a){
printf("Hello world from printA: %d\n",a);
}
void printB(const char *buff){
printf("Hello world from printB: %s\n",buff);
}
#define Max_ITEMS() 6, 5, 4, 3, 2, 1, 0
#define __VA_ARG_N(_1, _2, _3, _4, _5, _6, N, ...) N
#define _Num_ARGS_(...) __VA_ARG_N(__VA_ARGS__)
#define NUM_ARGS(...) (_Num_ARGS_(_0, ## __VA_ARGS__, Max_ITEMS()) - 1)
#define CHECK_ARGS_MAX_LIMIT(t) if(NUM_ARGS(args)>t)
#define CHECK_ARGS_MIN_LIMIT(t) if(NUM_ARGS(args)
#define print(x , args ...) \
CHECK_ARGS_MIN_LIMIT(1) printf("error");fflush(stdout); \
CHECK_ARGS_MAX_LIMIT(4) printf("error");fflush(stdout); \
({ \
if (__builtin_types_compatible_p (typeof (x), int)) \
printA(x, ##args); \
else \
printB (x,##args); \
})
int main(int argc, char** argv) {
int a=0;
print(a);
print("hello");
return (EXIT_SUCCESS);
}
Он будет выводить 0 и привет.. из печатиA и печатьB. Если ваш компилятор - gcc, и вы не возражаете делать ручные обновления каждый раз, когда добавляете новую перегрузку, вы можете сделать макромассу и получить результат, который вы хотите с точки зрения звонящих, не так приятно писать... но это возможно посмотрите на __builtin_types_compatible_p, затем используйте его для определения макроса, который делает что-то вроде #define foo(a) \
((__builtin_types_compatible_p(int, a)?foo(a):(__builtin_types_compatible_p(float, a)?foo(a):)
но да, противно, просто не EDIT:
C1X получит поддержку выражений типа, которые они выглядят следующим образом: #define cbrt(X) _Generic((X), long double: cbrtl, \
default: cbrt, \
float: cbrtf)(X) Как уже было сказано, перегрузка в том смысле, что вы имеете в виду, не поддерживается C. Обычная идиома для решения проблемы заключается в том, что функция принимает меченый союз . Это реализуется с помощью параметра struct , где сама struct состоит из некоторого типа индикатора типа, такого как enum , и union различных типов значений. Пример: #include Не можете ли вы просто использовать C ++ и не использовать все другие возможности C ++, кроме этого? Если до сих пор не было строго строгого C, я бы рекомендовал вместо этого вариативные функции . Следующий подход похож на a2800276
, но с некоторыми макросами макросов C99: // we need `size_t`
#include За время, _Generic момента _Generic этого вопроса, стандартный C (без расширений) эффективно получил
поддержку перегрузки функций (а не операторов) благодаря добавлению _Generic слова _Generic в C11. (поддерживается в GCC с версии 4.9) (Перегрузка не является по-настоящему «встроенной» в способе, показанном в вопросе, но легко уничтожить то, что работает так.) Generic - это оператор времени компиляции в том же семействе, что и sizeof и _Alignof . Он описан в стандартном разделе 6.5.1.1. Он принимает два основных параметра: выражение (которое не будет оцениваться во время выполнения) и список ассоциаций типов / выражений, который немного похож на блок switch . _Generic получает общий тип выражения, а затем «переключается» на него, чтобы выбрать выражение конечного результата в списке для его типа: Generic(1, float: 2.0,
char *: "2",
int: 2,
default: get_two_object());
Вышеприведенное выражение оценивается как 2 - тип управляющего выражения - int , поэтому он выбирает выражение, связанное с int как значение. Ничто из этого не остается во время выполнения. (Предложение по default является обязательным: если вы его не укажете, а тип не совпадает, это вызовет ошибку компиляции.) Способ, который полезен для перегрузки функций, заключается в том, что он может быть вставлен препроцессором C и выбрать выражение результата, основанное на типе аргументов, переданных управляющему макросу. Итак (пример из стандарта C): #define cbrt(X) _Generic((X), \
long double: cbrtl, \
default: cbrt, \
float: cbrtf \)(X)
Этот макрос реализует перегруженную операцию cbrt , отправляя по типу аргумента макросу, выбирая подходящую функцию реализации и затем передавая исходную макрокоманду этой функции. Итак, чтобы реализовать ваш оригинальный пример, мы могли бы сделать это: Foo_int (int a)
foo_char (char b)
foo_float_int (float c , int d)
#define foo(_1, ...) _Generic((_1), \
int: foo_int, \
char: foo_char, \
float: _Generic((FIRST(__VA_ARGS__,)), \
int: foo_float_int))(_1, __VA_ARGS__)
#define FIRST(A, ...) A
В этом случае мы могли бы использовать связь по default: для третьего случая, но это не демонстрирует, как расширить принцип до нескольких аргументов. Конечным результатом является то, что вы можете использовать foo(...) в своем коде, не беспокоясь (много ) о типе своих аргументов. Для более сложных ситуаций, например функций, перегружающих большее количество аргументов или изменяющихся чисел, вы можете использовать макросы утилиты для автоматического создания статических структур отправки: Void print_ii(int a, int b) { printf("int, int\n"); }
void print_di(double a, int b) { printf("double, int\n"); }
void print_iii(int a, int b, int c) { printf("int, int, int\n"); }
void print_default(void) { printf("unknown arguments\n"); }
#define print(...) OVERLOAD(print, (__VA_ARGS__), \
(print_ii, (int, int)), \
(print_di, (double, int)), \
(print_iii, (int, int, int)) \)
#define OVERLOAD_ARG_TYPES (int, double)
#define OVERLOAD_FUNCTIONS (print)
#include "activate-overloads.h"
int main(void) {
print(44, 47); // prints "int, int"
print(4.4, 47); // prints "double, int"
print(1, 2, 3); // prints "int, int, int"
print(""); // prints "unknown arguments"
}
(реализация здесь). С некоторыми усилиями вы можете уменьшить количество шаблонов, чтобы выглядеть довольно похоже на язык с встроенной поддержкой перегрузки. В стороне уже можно было перегрузить количество
аргументов (а не тип) на C99. Обратите внимание, что способ оценки C может вас трогать. Это выберет foo_int если вы попытаетесь передать ему буквенный символ, например, и вам нужно немного foo_int если вы хотите, чтобы ваши перегрузки поддерживали строковые литералы. Тем не менее, в целом довольно прохладно. Ответ Леушенко действительно классный: только пример foo не компилируется с GCC, который не срабатывает при foo(7) , наткнувшись на макрос FIRST и фактический вызов функции ((_1, __VA_ARGS__) , оставаясь с добавочной запятой. Кроме того, у нас возникают проблемы, если мы хотим обеспечить дополнительные перегрузки, такие как foo(double) . Поэтому я решил подробнее ответить на этот вопрос, в том числе разрешить пустую перегрузку (foo(void) - что вызвало некоторые неприятности...). Идея теперь заключается в следующем: определите более одного генерика в разных макросах и позвольте выбрать правильный в соответствии с количеством аргументов! Количество аргументов довольно просто, основываясь на этом ответе: #define foo(...) SELECT(__VA_ARGS__)(__VA_ARGS__)
#define SELECT(...) CONCAT(SELECT_, NARG(__VA_ARGS__))(__VA_ARGS__)
#define CONCAT(X, Y) CONCAT_(X, Y)
#define CONCAT_(X, Y) X ## Y
Это хорошо, мы решаем либо SELECT_1 либо SELECT_2 (или больше аргументов, если вы хотите / нуждаетесь в них), поэтому нам просто нужны соответствующие определения: #define SELECT_0() foo_void
#define SELECT_1(_1) _Generic ((_1), \
int: foo_int, \
char: foo_char, \
double: foo_double \)
#define SELECT_2(_1, _2) _Generic((_1), \
double: _Generic((_2), \
int: foo_double_int \) \)
Во-первых, пустой вызов макроса (foo()) все еще создает токен, но пустой. Таким образом, счетный макрос фактически возвращает 1 вместо 0 даже при пустом вызове макроса. Мы можем «легко» устранить эту проблему, если мы __VA_ARGS__ запятую после __VA_ARGS__ условно
, в зависимости от того, что список пуст или нет: #define NARG(...) ARG4_(__VA_ARGS__ COMMA(__VA_ARGS__) 4, 3, 2, 1, 0)
Это выглядело
легко, но макрос COMMA довольно тяжелый; к счастью, эта тема уже освещена в блоге Йенса Густедта (спасибо, Йенс). Основной трюк заключается в том, что макросы функций не расширяются, если не следовать скобками, для дальнейших объяснений смотрите блог Jens ... Нам просто нужно немного модифицировать макросы для наших нужд (я буду использовать более короткие имена и меньше аргументов для краткости). #define ARGN(...) ARGN_(__VA_ARGS__)
#define ARGN_(_0, _1, _2, _3, N, ...) N
#define HAS_COMMA(...) ARGN(__VA_ARGS__, 1, 1, 1, 0)
#define SET_COMMA(...) ,
#define COMMA(...) SELECT_COMMA \
(\
HAS_COMMA(__VA_ARGS__), \
HAS_COMMA(__VA_ARGS__ ()), \
HAS_COMMA(SET_COMMA __VA_ARGS__), \
HAS_COMMA(SET_COMMA __VA_ARGS__ ()) \)
#define SELECT_COMMA(_0, _1, _2, _3) SELECT_COMMA_(_0, _1, _2, _3)
#define SELECT_COMMA_(_0, _1, _2, _3) COMMA_ ## _0 ## _1 ## _2 ## _3
#define COMMA_0000 ,
#define COMMA_0001
#define COMMA_0010 ,
// ... (all others with comma)
#define COMMA_1111 ,
И теперь мы в порядке... Полный код в одном блоке: /*
* demo.c
*
* Created on: 2017-09-14
* Author: sboehler
*/
#include Под перегрузкой функции понимается, определение нескольких функций (две или больше) с одинаковым именем, но различными параметрами. Наборы параметров перегруженных функций могут отличаться порядком следования, количеством, типом. Таким образом перегрузка функций нужна для того, чтобы избежать дублирования имён функций, выполняющих сходные действия, но с различной программной логикой. Например, рассмотрим функцию areaRectangle() , которая вычисляет площадь прямоугольника. Float areaRectangle(float, float) //функция, вычисляющая площадь прямоугольника с двумя параметрами a(см) и b(см)
{
return a * b; // умножаем длинны сторон прямоугольника и возвращаем полученное произведение
}
Итак, это функция с двумя параметрами типа float , причём аргументы передаваемые в функцию должны быть в сантиметрах, возвращаемое значение типа float — тоже в сантиметрах. Предположим, что наши исходные данные (стороны прямоугольника) заданы в метрах и сантиметрах, например такие: a = 2м 35 см; b = 1м 86 см. В таком случае, удобно было бы использовать функцию с четырьмя параметрами. То есть, каждая длинна сторон прямоугольника передаётся в функцию по двум параметрам: метры и сантиметры. Float areaRectangle(float a_m, float a_sm, float b_m, float b_sm) // функция, вычисляющая площадь прямоугольника с 4-мя параметрами a(м) a(см); b(м) b(cм)
{
return (a_m * 100 + a_sm) * (b_m * 100 + b_sm);
}
В теле функции значения, которые передавались в метрах (a_m и b_m)переводятся в сантиметры и суммируются с значениями a_sm b_sm , после чего перемножаем суммы и получаем площадь прямоугольника в см. Конечно же можно было перевести исходные данные в сантиметры и пользоваться первой функцией, но сейчас не об этом. Теперь, самое главное – у нас есть две функции, с разной сигнатурой, но одинаковыми именами (перегруженные функции). Сигнатура – это комбинация имени функции с её параметрами. Как же вызывать эти функции? А вызов перегруженных функций ничем не отличается от вызова обычных функций, например: AreaRectangle(32, 43); // будет вызвана функция, вычисляющая площадь прямоугольника с двумя параметрами a(см) и b(см)
areaRectangle(4, 43, 2, 12); // будет вызвана функция, вычисляющая площадь прямоугольника с 4-мя параметрами a(м) a(см); b(м) b(cм)
Как видите, компилятор самостоятельно выберет нужную функцию, анализируя только лишь сигнатуры перегруженных функций. Минуя перегрузку функций, можно было бы просто объявить функцию с другим именем, и она бы хорошо справлялась со своей задачей. Но представьте, что будет, если таких функций надо больше, чем две, например 10. И для каждой нужно придумать осмысленное имя, а сложнее всего их запомнить. Вот именно поэтому проще и лучше перегружать функции, если конечно в этом есть необходимость. Исходный код программы показан ниже. #include "stdafx.h"
#include // код Code::Blocks // код Dev-C++ #include Результат работы программы показан на рисунке 1. При определении функций в своих программах вы должны указать тип возвращаемого функцией значения, а также количество параметров и тип каждого из них. В прошлом (если вы программировали на языке С), когда у вас была функция с именем add_values, которая работала с двумя целыми значениями, а вы хотели бы использовать подобную функцию для сложения трех целых значений, вам следовало создать функцию с другим именем. Например, вы могли бы использовать add_two_values иadd_three_values. Аналогично если вы хотели использовать подобную функцию для сложения значений типа float, то вам была бы необходима еще одна функция с еще одним именем. Чтобы избежать дублирования функции, C++ позволяет вам определять несколько функций с одним и тем же именем. В процессе компиляции C++ принимает во внимание количество аргументов, используемых каждой функцией, и затем вызывает именно требуемую функцию. Предоставление компилятору выбора среди нескольких функций называется перегрузкой. В этом уроке вы научитесь использовать перегруженные функции. К концу данного урока вы освоите следующие основные концепции: Перегрузка функций позволяет вам использовать одно и то же имя для нескольких функций с разными типами параметров. Для перегрузки функций просто определите две функции с одним и тем же именем и типом возвращаемого значения, которые отличаются количеством параметров или их типом. Перегрузка функций является особенностью языка C++, которой нет в языке С. Как вы увидите, перегрузка функций достаточно удобна и может улучшить удобочитаемость ваших программ. Перегрузка функций позволяет вашим программам определять несколько функций с одним и тем же именем и типом возвращаемого значения. Например, следующая программа перегружает функцию с именемadd_values. Первое определение функции складывает два значения типаint. Второе определение функции складывает три значения. В процессе компиляции C++ корректно определяет функцию, которую необходимо использовать: #include int add_values(int a,int b) { int add_values (int a, int b, int c) ( { Как видите, программа определяет две функции с именами add_valuesПервая функция складывает два значения типа int, в то время как вторая складывает три значения. Вы не обязаны что-либо предпринимать специально для того, чтобы предупредить компилятор о перегрузке, просто используйте ее. Компилятор разгадает, какую функцию следует использовать, основываясь на предлагаемых программой параметрах. Подобным образом следующая программа MSG_OVR.CPP перегружает функцию show_message. Первая функция с именем show_message выводит стандартное сообщение, параметры ей не передаются. Вторая выводит передаваемое ей сообщение, а третья выводит два сообщения: #include void show_message(void) { void show_message(char *message) { void show_message(char *first, char *second) { { Одним из наиболее общих случаев использования перегрузки является применение функции для получения определенного результата, исходя из различных параметров. Например, предположим, что в вашей программе есть функция с именем day_of_week, которая возвращает текущий день недели (0 для воскресенья, 1 для понедельника, …, 6 для субботы). Ваша программа могла бы перегрузить эту функцию таким образом, чтобы она верно возвращала день недели, если ей передан юлианский день в качестве параметра, или если ей переданы день, месяц и год: int day_of_week(int julian_day) { int day_of_week(int month, int day, int year) { По мере изучения объектно-ориентированного программирования в C++, представленного в следующих уроках, вы будете использовать перегрузку функций для расширения возможностей своих программ. Перегрузка функций улучшает удобочитаемость программ Перегрузка функций C++ позволяет вашим программам определять несколько функций с одним и тем же именем. Перегруженные функции должны возвращать значения одинакового типа*, но могут отличаться количеством и типом параметров. До появления перегрузки функций в C++ программисты языка С должны были создавать несколько функций с почти одинаковыми именами. К сожалению программисты, желающие использовать такие функции, должны были помнить, какая комбинация параметров соответствует какой функции. С другой стороны, перегрузка функций упрощает задачу программистов, требуя, чтобы они помнили только одно имя функции.* Перегруженные функции не обязаны возвращать значения одинакового типа по той причине, что компилятор однозначно идентифицирует функцию по ее имени и набору ее аргументов. Для компилятора функции с одинаковыми именами, но различными типами аргументов - разные функции, поэтому тип возвращаемого значения - прерогатива каждой функции. - Прим.перев. Перегрузка функций позволяет вам указать несколько определений для одной и той же функции. В процессе компиляции C++ определит, какую функцию следует использовать, основываясь на количестве и типе передаваемых параметров. Из данного урока вы узнали, что перегружать функции достаточно просто. Из урока 14 вы узнаете, как ссылки C++ упрощают процесс изменения параметров внутри функций. Однако, прежде чем перейти к уроку 14, убедитесь, что вы изучили следующие основные концепции:Перегружаемый / Non-overloadableOperators
Терминология
Причины появления
Механизм перегрузки
Реализация
Варианты и проблемы
Проблема идентификации
Специфические вопросы перегрузки операций
Объявление новых операций
Перегрузка и полиморфные переменные
Критика
Классификация
Операции
Нет перегрузки
Есть перегрузка
Ограниченое множество операций
Возможно определение новых операций
См. также
Смотреть что такое "Перегрузка функций" в других словарях:
Как добиться перегрузки функций в C?
(10)
Я надеюсь, что приведенный ниже код поможет вам понять перегрузку функций
#include ПЕРВОЕ ЗНАКОМСТВО С ПЕРЕГРУЗКОЙ ФУНКЦИЙ
return(a + b);
)
return(a + b + c);
)
cout << «200 + 801 = » << add_values(200, 801) << endl;
cout << «100 + 201 + 700 = » << add_values(100, 201, 700) << endl;
}
cout << «Стандартное сообщение: » << «Учимся программировать на C++» << endl;
}
cout << message << endl;
}
cout << first << endl;
cout << second << endl;
}
show_message();
show_message(«Учимся программировать на языке C++!»);
show_message(«B C++ нет предрассудков!»,»Перегрузка — это круто!») ;
}КОГДА НЕОБХОДИМА ПЕРЕГРУЗКА
// Операторы
}
// Операторы
}ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ