C Урок 30. Указатели на функции. Часть 1

В четырёх последних уроках мы плотно занимаемся адресацией данных в языке C, изучили почти всё по указателям и адресам: разыменование, доступ к адресам массивов, поработали с указателями на структуры и их поля, с указателями в аргументах функций на различные данные, с указателями типа void.

Но оказалось, что это ещё не всё. Существуют ещё указатели на функции.

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

Давайте для начала зададимся вопросом, откуда вообще взялся указатель на функцию. Функция для процессора – это подпрограмма, она также, как и остальные данные, располагается где-то в памяти, соответственно, данная память только для чтения, то есть мы не можем изменить код подпрограммы во время её выполнения (хотя это тоже ещё не факт, есть некоторые костыли, но нам это сейчас и не нужно и урок не о том). Вот поэтому и вопрос. А обязательно ли мы должны вызывать функцию по её имени? Ведь получали же мы данные. используя адрес их нахождения в памяти. Оказывается, тоже не обязательно. Вполне мы можем использовать и указатели. И от этого есть тоже своя польза.

Например, в C++ кроме структур существуют классы, объекты или экземпляры которых мы потом используем в программе. Как и в структурах, в классах есть поля, только, правда там они именуются свойства, а есть ещё и методы. Это такие функции, которые принадлежат данному классу и доступны только из объектов, созданных на основе него.

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

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

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

Как это не удивительно, самым распространённым указателем на функцию является её имя.

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

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

Кроме указателя в виде имени функции мы можем также объявить указатель на функцию отдельной переменной

Как мы можем использовать указатель на функцию?

Классический способ такой.

Представим, что у нас есть функция, вот её прототип

void print_str( const char *c_str);

Мы объявляем переменную-указатель на функцию, например с таким именем, при этом используя строго все те же параметры, как и у оригинальной функции, на адрес которой впоследствии наш указатель будет указывать

void (*print_str_new)( const char *c_str);

У нас появилось теперь новое имя print_str_new.

Теперь мы простейшим способом присваиваем адрес оригинальной функции нашему новому указателю (а мы помним, что имя функции – это и есть указатель)

print_str_new = print_str;

И далее этим указателем мы пользуемся также, как и оригинальным именем функции

print_str_new( «Hello, World. » );

Всё оказалось просто.

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

Откроем наш проект в Eclipse, произведём его первоначальную настройку и удалим весь наш код из функции main() за исключением возврата. Функция main() приобретёт вот такой вид

int main()

return 0; //Return an integer from a function

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

Оказывается, вот как. Раз мы знаем то, что имя функции и есть указатель на неё, то мы этим и воспользуемся.

В функции main объявим обычный указатель на целочисленный 4-байтовый тип, так как у нас адреса памяти 32-разрядных приложений именно такие

Источник

Указатели на функции как параметры функции

Определение указателя на функцию имеет вид:

int (*pf)(); // без контроля параметров вызова

int (* pf )( void ); // без параметров, с контролем по прототипу

int (*pf)(int, char*); // с контролем по прототипу

pf = INC; // присваивание указателя

int (*pp)(int) = &DEC; // инициализация указателя

n = (*pf)(1) + (*pp)(n); // эквивалентно

Как и обычный указатель, указатель на функцию имеет размерность адреса, т.е. на уровне архитектуры является машинным словом, содержащим адрес функции в соответствии с системой формирования адресов процессором (системой адресации памяти). Это позволяет, в свою очередь, опускаться до таких машинно-зависимых действий как вызов функции по заданному адресу памяти, преобразуя целую константу к указателю на функцию.

void main () < (* pf )(); >// функции, которую вызывает main

// указатель на функцию

Указатель на функцию прежде всего имеет отношение к системному программированию. Достаточно сказать, что кроме Си в явном виде он встречается только в Паскале (процедурный тип), но во многих случаях входит в скрытые механизмы управления программной средой, известные как динамическое связывание функций. Динамическое и статическое связывание мы уже обсуждали в 5.6., но там это относилось к переменным. По отношению к функции термин динамическое связывание следует понимать как установление соответствия между именем функции и ее адресом. Если рассматривать этот вопрос по отношению обычным функциям на Си, то можно выделить три этапа связывания:

· если определение функции и ее вызов находятся в одном модуле (файле), то транслятору ничего не мешает вычислить относительный адрес функций внутри объектного модуля во время трансляции – статическое связывание;

· при вызове внешней функции, определение которой находится в другом файле (а программный код – в другом объектном модуле), адрес функции становится известен при компоновке программного файла из объектных модулей. Хотя процедура компоновки выполняется после трансляции, данное связывание также называется статическим;

· набор внешних функций (объектный модуль целиком) может быть оформлен в виде динамически связываемой библиотеки – DLL (dynamic linking library). Она загружается в память одновременно с программным модулем и связывание имени внешней функции с ее адресом в адресном пространстве DLL происходит при загрузке. Это связывание уже считается динамическим. При наличии в каждом приложении отображаемого адресного пространства (виртуальной памяти) программный код DLL может одновременно использоваться (разделяться) несколькими приложениями.

Если на уровне среды программирования или непосредственно в Си-программах имеет место элемент динамического связывания, то с уверенностью можно сказать, что в том или ином виде (явно или неявно) используется указатель на функцию:

· уже упомянутые нами DLL, а также все возможные виды динамической загрузки внутреннего (исполняемого) программного кода;

· виртуальные функции в Си++ (см. 12.4.) – при конструировании объекта производного класса в базовый класс помещается указатель на таблицу виртуальных функций для производного класса (массив указателей на функции);

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

Таблицы функций, вызов по имени

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

extern double sin(double);

extern double cos(double);

extern double tan(double);

char * names [] = < "sin","cos","tan",NULL>; // Массив имен (указатели на строки)

double (*pf[])(double) = < sin, cos, tan>; // Таблица функций (адреса функций)

//—- Вызов функции по имени из заданного списка

double call_by_name(char *pn, double arg) <

for ( int i=0; names[i]!=NULL; i++)

> // указателю в массиве pf

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

Указатель на функцию как средство параметризации алгоритма

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

«Функция, вычисляющая функцию, предается в виде указателя на функцию»

//——Численное интегрирование произвольной функции

double INTEG(double a, double b, int n, double(*pf)(double))

for (s=0., x=a, h = (b-a)/n; x

extern double sin(double);

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

//——Сортировка массива структур по разным критериям

void sort(user A[], int (*cmp)(user&,user&))<

for (int i=1;A[i].name[0]!=0;i++)

for(int j=i; j>0 && (*cmp)(A[j],A[j-1])

A[j-1]=c; > // структурированных переменных

//——— функция сравнения по имени

int cmp_name(user &u1, user &u2)<

//——— функция сравнения по account

int cmp_account(user &u1, user &u2)<

//——— функция сравнения по time

int cmp_time(user &u1, user &u2)<

Этот пример можно обобщить на случай использования данных любого типа. В Си отсутствует понятие произвольный (неопределенный) тип, но понятие указатель на неопределенный (произвольный) тип существует – это void*. Однако прямое использование этого указателя невозможно. Какой же здесь выход?

Типичными итераторами являются:

· итераторы проверки и поиска по условию ( firstthat), возвращающие указатель на первую (последнюю, очередную) переменную, которая удовлетворяет условию, проверяемому в функции;

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

Итератор являет собой пример универсализации алгоритма, основанный на разделении «компетенций» между различенными его частями:

· структура данных, обрабатываемая итератором, содержит в своих элементах указатели на переменные произвольного (неизвестного для итератора) типа void*, но одинакового в каждом экземпляре структуры данных. Структура данных «знает», где хранятся переменные, но «не знает», как их обработать;

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

· действие, которое надлежит выполнить над хранимыми объектами произвольного типа, реализуется вызовом внешней функции через указатель. Итератор извлекает из структуры данных указатели void* на хранимые данные и передает их внешней функции.

· прототип (схема формальных параметров и результата) внешней функции различна для разных типов итераторов. Для foreach – указатель имеет вид void (* pf )( void *), для firstthat – int (* pf )( void *), для итераторов, использующих сравнение – int (* cmp )( void *, void *).

//—— Итераторы foreach, firstthat и поиска минимального для списка

void *pdata; >; // Указатель на данные

//—— Итератор: для каждого элемента списка

void ForEach(list *pv, void (*pf)(void*) ) <

//—— Итератор: поиск первого в списке по условию

void *FirstThat(list *pv, int (*pf)(void*)) <

//—— Итератор: поиск минимального в списке

//—— Функция вывода строки

//—— Функция проверки : длины строки >5

//—— Функция сравнения строк по длине

int scmp(void *p1, void *p2)

//—— Вызов итераторов для статического списка,

// содержащего указатели на строки

//—— Итератор сортировки для массива указателей

void Sort(void **pp, int (*pf)(void*,void*))

if ( (*pf)(pp[i-1],pp[i])>=0) // вызов функции сравнения

k++; q = pp[i-1]; pp[i-1] = pp[i]; pp[i] = q;

// Пример вызова итератора сортировки для массива

// указателей на целые переменные

int cmp_int(void *p1, void *p2)

int b1=5, b2=6, b3=3, b4=2;

pp = (char*) FirstThat(PH,bigstr);

pp = (char*) FindMin(PH,scmp);

for (int i=0; PP[i]!=NULL;i++) printf(«%d «,*(int*)PP[i]);

Лабораторный практикум

Головоломка

Результат здесь очевиден, потому что не может быть другим. Будет выведена строка » I ‘ m foo » или значение 6. Значительно труднее объяснить :

Источник

Указатели на функции

Указатели на функции

К ак уже обсуждалось ранее функции – это набор команд, которые расположены в соответствующей области памяти. Вызов функции – это сохранение состояния, передача аргументов и переход по адресу, где располагается функция. В си есть возможность создавать указатели на функции. Указатели на функции позволяют упростить решение многих задач. Совместно с void указателями можно создавать функции общего назначения (например, сортировки и поиска). Указатели позволяют создавать функции высших порядков (функции, принимающие в качестве аргументов функции): отображение, свёртки, фильтры и пр. Указатели на функции позволяют уменьшать цикломатическую сложность программ, создавать легко масштабируемые конструкции. Рассмотрим пример. Создадим функцию и указатель на эту функцию

Синтаксис объявления указателей на функцию
(* )( );

В этом примере мы создали функцию отображения, которая применяет ко всем элементам массива функцию, которая передаётся ей в качестве аргумента. Когда мы вызываем функцию map, достаточно просто передавать имена функций (они подменяются указателями). Запишем теперь функцию map, которая получает в качестве аргумента массив типа void:

Вот где нам понадобились указатели типа void. Так как map получает указатель на функцию, то все функции должны иметь одинаковые аргументы и возвращать один и тот же тип. Но аргументы функций должны быть разного типа, поэтому мы делаем их типа void. Функция map получает указатель типа void (*)(void*), поэтому ей теперь можно передавать любую из четырёх функций.
Пример другой функции: функция filter получает указатель на массив и возвращает размер нового массива, оставляя в нём только те элементы, для которых переданный предикат возвращает логическую истину (предикат – функция, которая возвращает истину или ложь). Сначала напишем для массива типа int:

Теперь для массива типа void

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

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

Массив указателей на функции

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

Точно также можно было создать массив динамически

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

Ещё один пример: функция any возвращает 1, если в переданном массиве содержится хотя бы один элемент, удовлетворяющий условию pred и 0 в противном случае.

qsort и bsearch

Функция bsearch проводит бинарный поиск в отсортированном массиве и получает указатель на функцию сравнения, такую же, как и функция qsort. В случае, если элемент найден, то она возвращает указатель на этот элемент, если элемент не найден, то NULL.

Источник

Указатели на функции

Указатели на функции [1] — очень мощное средство языка С. Хотя нельзя не отметить, что это весьма трудный для понимания термин. Функция располагается в памяти по определенному адресу, который можно присвоить указателю в качестве его значения. Адресом функции является ее точка входа. Именно этот адрес используется при вызове функции. Так как указатель хранит адрес функции, то она может быть вызвана с помощью этого указателя. Он позволяет также передавать ее другим функциям в качестве аргумента.

Проанализируем эту программу подробно. В первую очередь рассмотрим объявление указателя p в main() :

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

Вызов функции check() можно записать, используя непосредственно имя strcmp() :

В этом случае вводить в программу дополнительный указатель p нет необходимости.

У читателя может возникнуть вопрос: какая польза от вызова функции с помощью указателя на функцию? Ведь в данном случае никаких преимуществ не достигнуто, этим мы только усложнили программу. Тем не менее, во многих случаях оказывается более выгодным передать имя функции как параметр или даже создать массив функций. Например, в программе интерпретатора синтаксический анализатор (программа, анализирующая выражения) часто вызывает различные вспомогательные функции, такие как вычисление математических функций, процедуры ввода-вывода и т.п. В таких случаях чаще всего создают список функций и вызывают их с помощью индексов.

Альтернативный подход — использование оператора switch с длинным списком меток case — делает программу более громоздкой и подверженной ошибкам.

В следующем примере рассматривается расширенная версия предыдущей программы. В этой версии функция check() устроена так, что может выполнять разные операции над строками s1 и s2 (например, сравнивать каждый символ с соответствующим символом другой строки или сравнивать числа, записанные в строках) в зависимости от того, какая функция указана в списке аргументов. Например, строки «0123» и «123» отличаются, однако представляют одно и то же числовое значение.

Сравнение строк 0123 [2] и 123 показывает равенство их значений.

[2] Обратите внимание, что в языке С нулем начинаются восьмеричные константы. Если бы эта запись была в выражении, то 0123 не было бы равно 123. Однако здесь функция atoi() обрабатывает это число как десятичное.

Источник

Функции

Параметры функции

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

При передаче по значению объявление параметра похоже на объявление переменной :

При передаче по ссылке объявление параметра представляет собой объявление ссылки без инициализации:

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

Пример передачи параметров:

Результат работы программы:

Если требуется запретить изменение параметра, используется модификатор const :

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

Передача массивов в качестве параметров

Массив всегда передается по адресу. При этом информация о количестве элементов массива теряется, и следует передавать его размерность через отдельный параметр:

Для того чтобы работать с двумерным массивом естественным образом, можно применить альтернативный способ выделения памяти:

Передача имен функций в качестве параметров

Функцию можно вызвать через указатель на нее. Для этого объявляется указатель соответствующего типа и ему с помощью операции взятия адреса присваивается адрес функции:

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

Указатели на функции передаются в подпрограмму таким же образом, как и параметры других типов:

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

Параметры со значениями по умолчанию

Источник