Встроенные функции. Категории встроенных функций Excel Какие встроенные функции используют диапазон данных

Использование функций имеет много преимуществ, в том числе:

Код внутри функции может быть повторно использован.

Гораздо проще изменить или обновить код в функции (что делается один раз), нежели искать и изменять все части кода в функции main() «на месте». Дублирование кода — хороший рецепт для ошибок и ухудшения производительности.

Упрощается чтение и понимание кода, так как вам не нужно знать реализацию функции, чтобы её использовать (предполагается наличие информативного названия функции и ).

В функциях поддерживается проверка типов данных для гарантии того, что передаваемые аргументы соответствуют параметрам функции.

Однако, одним из главных недостатков использования функций является то, что каждый раз, когда она вызывается, происходит расход ресурсов, что влияет на производительность программы. Это связано с тем, что ЦП должен хранить адрес текущей команды (инструкции или стейтмента), которую он выполняет (чтобы знать, куда нужно будет вернуться позже) вместе с другими данными. Затем точка выполнения перемещается в другое место программы. Дальше все параметры функции должны быть созданы и им должны быть присвоены значения. И только потом, после выполнения функции, точка выполнения возвращается обратно. Код, написанный «на месте», выполняется значительно быстрее.

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

C++ предлагает способ сочетания преимуществ функций со скоростью кода, написанного «на месте»: встроенные функции . Ключевое слово inline используется для запроса, чтобы компилятор рассматривал вашу функцию как встроенную. При компиляции вашего кода, все встроенные функции раскрываются «на месте», то есть вызов функции заменяется копией содержимого самой функции, и ресурсы, которые могли бы быть потрачены на вызов этой функции, сохраняются! Минусом является лишь увеличение компилируемого кода за счёт того, что встроенная функция раскрывается в коде при каждом вызове (особенно если она длинная и/или её вызывают много раз). Рассмотрим следующий фрагмент кода:

#include int max(int a, int b) { return a < b ? b: a; } int main() { std::cout << max(7, 8) << "\n"; std::cout << max(5, 4) << "\n"; return 0; }

Эта программа дважды вызывает функцию max(), т.е. дважды расходуются ресурсы на вызов функции. Поскольку max() является довольно таки короткой функцией, то это идеальный вариант для её конвертации во встроенную функцию:

inline int max(int a, int b) { return a < b ? b: a; }

int main() { std::cout << (7 < 8 ? 8: 7) << "\n"; std::cout << (5 < 4 ? 4: 5) << "\n"; return 0; }

Такой код выполниться быстрее ценой несколько увеличенного объёма.

Из-за возможности подобного «раздувания», встроенные функции лучше всего использовать только для коротких функций (не более нескольких строк), которые обычно вызываются внутри циклов и не имеют . Также, обратите внимание, ключевое слово inline является лишь рекомендацией — компилятор может игнорировать ваш запрос на встроенную функцию. Подобное произойдёт, если вы попытаетесь сделать встроенной длинную функцию!

Наконец, современные компиляторы автоматически конвертируют соответствующие функции во встроенные - этот процесс автоматизирован настолько, что даже лучше ручной выборочной конвертации программистом. Даже если вы не пометите функцию как встроенную, то компилятор автоматически выполнит её как таковую, если посчитает, что это способствует улучшению производительности. Таким образом, в большинстве случаев нет особой необходимости использовать ключевое слово inline. Компилятор всё сделает сам.

Аннотация: В лекции рассматриваются понятия, объявление и использование в программах подставляемых и перегруженных функций в С++, механизмы выполнения подстановки и перегрузки функций, рекомендации по повышению эффективности программ за счет перегрузки или подстановки функций.

Цель лекции : изучить подставляемые (встраиваемые) функции и перегрузки функций, научиться разрабатывать программы с использованием перегрузки функций на языке C++.

Подставляемые функции

Вызов функции , передача в нее значений, возврат значения – эти операции занимают довольно много процессорного времени. Обычно при определении функции компилятор резервирует в памяти только один блок ячеек для сохранения ее операторов. После вызова функции управление программой передается этим операторам, а по возвращении из функции выполнение программы возобновляется со строки, следующей после вызова функции.

При неоднократных вызовах каждый раз программа будет отрабатывать один и тот же набор команд, не создавая копий для каждого вызова в отдельности.

Каждый переход к области памяти, содержащей операторы функции, замедляет выполнение программы. Если функция занимает небольшой объем, то можно получить выигрыш во времени при многократных вызовах, дав компилятору команду встроить код функции непосредственно в программу по месту вызова. Такие функции называется подставляемыми . В этом случае, говоря об эффективности, прежде всего, подразумевается скорость выполнения программы.

Подставляемые или встраиваемые (inline) функции – это функции, код которых вставляется компилятором непосредственно на место вызова, вместо передачи управления единственному экземпляру функции.

Если функция является подставляемой, компилятор не создает данную функцию в памяти, а копирует ее строки непосредственно в код программы по месту вызова. Это равносильно вписыванию в программе соответствующих блоков вместо вызовов функций. Таким образом, спецификатор inline определяет для функции так называемое внутреннее связывание , которое заключается в том, что компилятор вместо вызова функции подставляет команды ее кода. Подставляемые функции используют, если тело функции состоит из нескольких операторов.

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

Например:

/*функция возвращает расстояние от точки с координатами(x1,y1) до точки с координатами (x2,y2)*/ inline float Line(float x1,float y1,float x2, float y2) { return sqrt(pow(x1-x2,2)+pow(y1-y2,2)); }

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

Пример 1 .

#include "stdafx.h" #include using namespace std; inline int Cube(int x); int _tmain(int argc, _TCHAR* argv){ int x=2; float y=3; double z=4; cout<

Перечислим причины, по которым функция со спецификатором inline будет трактоваться как обычная не подставляемая функция :

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

Ограничения на выполнение подстановки в основном зависят от реализации. Если же для функции со спецификатором inline компилятор не может выполнить подстановку из-за контекста, в который помещено обращение к ней, то функция считается статической и выдается предупреждающее сообщение .

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

Перегрузка функции

При определении функций в программах необходимо указывать тип возвращаемого функцией значения, а также количество параметров и тип каждого из них. Если на языке С++ была написана функция с именем add_values , которая работала с двумя целыми значениями, а в программе было необходимо использовать подобную функцию для передачи трех целых значений, то тогда следовало бы создать функцию с другим именем. Например, add_two_values и add_three_values . Аналогично, если необходимо использовать подобную функцию для работы со значениями типа float , то нужна еще одна функция с еще одним именем. Чтобы избежать дублирования функции, C++ позволяет определять несколько функций с одним и тем же именем. В процессе компиляции C++ принимает во внимание количество аргументов, используемых каждой функцией, и затем вызывает именно требуемую функцию. Предоставление компилятору выбора среди нескольких функций называется перегрузкой .

Перегрузка функций – это создание нескольких функций с одним именем, но с разными параметрами. Под разными параметрами понимают, что должно быть разным количество аргументов функции и/или их тип . То есть перегрузка функций позволяет определять несколько функций с одним и тем же именем и типом возвращаемого значения.

Перегрузка функций также называется полиморфизмом функций . "Поли" означает много, "морфе" – форма, то есть полиморфическая функция – это функция , отличающаяся многообразием форм.

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

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

Например, следующая программа перегружает функцию с именем add_values . Первое определение функции складывает два значения типа int . Второе определение функции складывает три значения типа int . В процессе компиляции C++ корректно определяет функцию, которую необходимо использовать:

#include "stdafx.h" #include using namespace std; int add_values(int a,int b); int add_values (int a, int b, int c); int _tmain(int argc, _TCHAR* argv){ cout << "200+801=" << add_values(200,801) << "\n"; cout << "100+201+700=" << add_values(100,201,700) << "\n"; system("pause"); return 0; } int add_values(int a,int b) { return(a + b); } int add_values (int a, int b, int c) { return(a + b + c); }

Таким образом, программа определяет две функции с именами add_values . Первая функция складывает два значения, в то время как вторая складывает три значения одного типа int . Компилятор языка С++ определяет, какую функцию следует использовать, основываясь на предлагаемых программой параметрах.

Использование перегрузки функции

Одним из наиболее общих случаев использования перегрузки является применение функции для получения определенного результата, исходя из различных параметров. Например, предположим, что в программе есть функция с именем day_of_week , которая возвращает текущий день недели (0 для воскресенья, 1 для понедельника, ... , 6 для субботы). Программа могла бы перегрузить эту функцию таким образом, чтобы она верно возвращала день недели, если ей передан юлианский день в качестве параметра, или если ей переданы день, месяц и год.

int day_of_week(int julian_day) { // операторы } int day_of_week(int month, int day, int year) { // операторы }

При использовании перегруженных функций часто допускается ряд ошибок. Например, если функции отличаются только типом возвращаемого значения, но не типами аргументов, такие функции не могут иметь одинаковое имя. Также недопустим следующий вариант перегрузки :

int имя_функции(int имя_аргумента); int имя_функции(int имя_аргумента); /*недопустимая перегрузка имени: аргументы имеют одинаковое количество и одинаковый тип*/

Преимущества перегрузки функции:

• перегрузка функций улучшает удобочитаемость программ;
• перегрузка функций C++ позволяет программам определять несколько функций с одним и тем же именем;
• перегруженные функции возвращают значения одинакового типа, но могут отличаться количеством и типом параметров;
• перегрузка функций упрощает задачу программистов, требуя, чтобы они помнили только одно имя функции , но тогда они должны знать, какая комбинация параметров соответствует какой функции.

Пример 2 .

/*Перегруженные функции имеют одинаковые имена, но разные списки параметров и возвращаемые значения*/ #include "stdafx.h" #include using namespace std; int average(int first_number, int second_number, int third_number); int average(int first_number, int second_number); int _tmain(int argc, _TCHAR* argv){// главная функция int number_A = 5, number_B = 3, number_C = 10; cout << "Целочисленное среднее чисел " << number_A << " и "; cout << number_B << " равно "; cout << average(number_A, number_B) << ".\n\n"; cout << "Целочисленное среднее чисел " << number_A << ", "; cout << number_B << " и " << number_C << " равно "; cout << average(number_A, number_B, number_C) << ".\n"; system("PAUSE"); return 0; }// конец главной функции /*функция для вычисления целочисленного среднего значения 3-х целых чисел*/ int average(int first_number, int second_number, int third_number) { return((first_number + second_number + third_number)/3); } // конец функции /*функция для вычисления целочисленного среднего значения 2-х целых чисел*/ int average(int first_number, int second_number) { return((first_number + second_number)/2); } // конец функции

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

Как это делает программу быстрее? Легко, вызовы функций занимают больше времени, чем написание всего кода без функции. Просмотр вашей программы и замена функции, которую вы использовали 100 раз с кодом из функции, займет очень много времени. Конечно, используя встроенные функции для замены обычных вызовов функций, вы также значительно увеличите размер вашей программы.

Использовать ключевое слово inline легко, просто поставьте его перед именем функции. Затем, используйте её как обычную функцию.

Пример встроенной функции