Покажчик функції - це змінна, яка містить адресу функції. Оскільки це змінна вказівник, хоча з деякими обмеженими властивостями, ви можете використовувати її майже так само, як і будь-яку іншу змінну вказівника в структурах даних.
Єдиним винятком, про який я можу подумати, є трактування функції покажчика як вказівки на щось інше, ніж на одне значення. Виконання арифметики вказівника шляхом збільшення або зменшення покажчика функції або додавання / віднімання зміщення до вказівника функції насправді не є корисною, оскільки покажчик функції вказує лише на одну річ, точку входу функції.
Розмір змінної вказівника функції, кількість байтів, зайнятих змінною, може змінюватися в залежності від базової архітектури, наприклад x32 або x64 або будь-якої іншої.
Декларація змінної вказівника на функцію повинна вказувати той самий вид інформації, що і декларація функції, щоб компілятор C здійснював типи перевірок, які він зазвичай робить. Якщо у декларації / визначенні вказівника функції не вказати список параметрів, компілятор C не зможе перевірити використання параметрів. Є випадки, коли ця відсутність перевірки може бути корисною, проте пам’ятайте лише, що запобіжну сітку було видалено.
Деякі приклади:
int func (int a, char *pStr); // declares a function
int (*pFunc)(int a, char *pStr); // declares or defines a function pointer
int (*pFunc2) (); // declares or defines a function pointer, no parameter list specified.
int (*pFunc3) (void); // declares or defines a function pointer, no arguments.
Перші дві декларації дещо подібні до цього:
funcце функція, яка приймає intі, char *і повертаєintpFunc- покажчик функції, якому присвоюється адреса функції, яка приймає a intі a char *і повертає anint
Отже, з вищесказаного ми могли б мати вихідний рядок, у якому адреса функції func()присвоюється змінній вказівника функції, pFuncяк у pFunc = func;.
Зверніть увагу на синтаксис, який використовується з декларацією / визначенням вказівника функції, в яких дужки використовуються для подолання природних правил пріоритетності оператора.
int *pfunc(int a, char *pStr); // declares a function that returns int pointer
int (*pFunc)(int a, char *pStr); // declares a function pointer that returns an int
Кілька різних прикладів використання
Деякі приклади використання покажчика функції:
int (*pFunc) (int a, char *pStr); // declare a simple function pointer variable
int (*pFunc[55])(int a, char *pStr); // declare an array of 55 function pointers
int (**pFunc)(int a, char *pStr); // declare a pointer to a function pointer variable
struct { // declare a struct that contains a function pointer
int x22;
int (*pFunc)(int a, char *pStr);
} thing = {0, func}; // assign values to the struct variable
char * xF (int x, int (*p)(int a, char *pStr)); // declare a function that has a function pointer as an argument
char * (*pxF) (int x, int (*p)(int a, char *pStr)); // declare a function pointer that points to a function that has a function pointer as an argument
Ви можете використовувати списки параметрів змінної довжини у визначенні вказівника функції.
int sum (int a, int b, ...);
int (*psum)(int a, int b, ...);
Або ви взагалі не можете вказати список параметрів. Це може бути корисно, але це виключає можливість компілятора C здійснювати перевірки в наданому списку аргументів.
int sum (); // nothing specified in the argument list so could be anything or nothing
int (*psum)();
int sum2(void); // void specified in the argument list so no parameters when calling this function
int (*psum2)(void);
C Стилі ролях
Ви можете використовувати касти в стилі C з функціональними покажчиками. Однак майте на увазі, що компілятор C може мати менший ступінь щодо перевірок або надання попереджень, а не помилок.
int sum (int a, char *b);
int (*psplsum) (int a, int b);
psplsum = sum; // generates a compiler warning
psplsum = (int (*)(int a, int b)) sum; // no compiler warning, cast to function pointer
psplsum = (int *(int a, int b)) sum; // compiler error of bad cast generated, parenthesis are required.
Порівняйте функціональний покажчик на рівність
Ви можете перевірити, що покажчик функції дорівнює певній адресі функції, використовуючи ifоператор, хоча я не впевнений, наскільки це було б корисно. Інші оператори порівняння, здається, мають ще меншу корисність.
static int func1(int a, int b) {
return a + b;
}
static int func2(int a, int b, char *c) {
return c[0] + a + b;
}
static int func3(int a, int b, char *x) {
return a + b;
}
static char *func4(int a, int b, char *c, int (*p)())
{
if (p == func1) {
p(a, b);
}
else if (p == func2) {
p(a, b, c); // warning C4047: '==': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
} else if (p == func3) {
p(a, b, c);
}
return c;
}
Масив функціональних покажчиків
І якщо ви хочете мати масив покажчиків функцій, кожен з елементів яких у списку аргументів має відмінності, то ви можете визначити покажчик функції зі списком аргументів не визначеним (не voidце означає відсутність аргументів, а просто не визначений), як-от наступне, хоча ви можуть з’явитися попередження від компілятора C. Це також працює для параметра вказівника функції на функцію:
int(*p[])() = { // an array of function pointers
func1, func2, func3
};
int(**pp)(); // a pointer to a function pointer
p[0](a, b);
p[1](a, b, 0);
p[2](a, b); // oops, left off the last argument but it compiles anyway.
func4(a, b, 0, func1);
func4(a, b, 0, func2); // warning C4047: 'function': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
func4(a, b, 0, func3);
// iterate over the array elements using an array index
for (i = 0; i < sizeof(p) / sizeof(p[0]); i++) {
func4(a, b, 0, p[i]);
}
// iterate over the array elements using a pointer
for (pp = p; pp < p + sizeof(p)/sizeof(p[0]); pp++) {
(*pp)(a, b, 0); // pointer to a function pointer so must dereference it.
func4(a, b, 0, *pp); // pointer to a function pointer so must dereference it.
}
C стиль namespaceВикористання глобального structз функціональними покажчиками
Ви можете використовувати staticключове слово, щоб вказати функцію, ім'я якої - область файлу, а потім призначити це глобальній змінній як спосіб надання чогось подібного до namespaceфункціональності C ++.
У файлі заголовка визначте структуру, яка буде нашим простором імен разом із глобальною змінною, яка її використовує.
typedef struct {
int (*func1) (int a, int b); // pointer to function that returns an int
char *(*func2) (int a, int b, char *c); // pointer to function that returns a pointer
} FuncThings;
extern const FuncThings FuncThingsGlobal;
Потім у вихідному файлі C:
#include "header.h"
// the function names used with these static functions do not need to be the
// same as the struct member names. It's just helpful if they are when trying
// to search for them.
// the static keyword ensures these names are file scope only and not visible
// outside of the file.
static int func1 (int a, int b)
{
return a + b;
}
static char *func2 (int a, int b, char *c)
{
c[0] = a % 100; c[1] = b % 50;
return c;
}
const FuncThings FuncThingsGlobal = {func1, func2};
Потім це буде використано, вказавши повне ім'я глобальної змінної структури та ім’я члена для доступу до функції. constМодифікатор використовується на глобальному , так що він не може бути змінений випадково.
int abcd = FuncThingsGlobal.func1 (a, b);
Області застосування функціональних покажчиків
Компонент бібліотеки DLL може зробити щось подібне до namespaceпідходу в стилі C, в якому конкретний інтерфейс бібліотеки запитується від заводського методу в інтерфейсі бібліотеки, який підтримує створення structпокажчиків, що містять функції. Цей інтерфейс бібліотеки завантажує запитувану версію DLL, створює структура з необхідними вказівниками функції, а потім повертає структуру запитувальному абоненту для використання.
typedef struct {
HMODULE hModule;
int (*Func1)();
int (*Func2)();
int(*Func3)(int a, int b);
} LibraryFuncStruct;
int LoadLibraryFunc LPCTSTR dllFileName, LibraryFuncStruct *pStruct)
{
int retStatus = 0; // default is an error detected
pStruct->hModule = LoadLibrary (dllFileName);
if (pStruct->hModule) {
pStruct->Func1 = (int (*)()) GetProcAddress (pStruct->hModule, "Func1");
pStruct->Func2 = (int (*)()) GetProcAddress (pStruct->hModule, "Func2");
pStruct->Func3 = (int (*)(int a, int b)) GetProcAddress(pStruct->hModule, "Func3");
retStatus = 1;
}
return retStatus;
}
void FreeLibraryFunc (LibraryFuncStruct *pStruct)
{
if (pStruct->hModule) FreeLibrary (pStruct->hModule);
pStruct->hModule = 0;
}
і це можна використовувати як:
LibraryFuncStruct myLib = {0};
LoadLibraryFunc (L"library.dll", &myLib);
// ....
myLib.Func1();
// ....
FreeLibraryFunc (&myLib);
Цей же підхід може бути використаний для визначення абстрактного апаратного рівня для коду, який використовує певну модель базового обладнання. Покажчики функцій фабрикою заповнюються певними апаратними функціями для забезпечення функціональних можливостей обладнання, що реалізують функції, визначені в абстрактній апаратній моделі. Це може бути використано для надання абстрактного апаратного рівня, який використовується програмним забезпеченням, яке викликає фабричну функцію, щоб отримати специфічний апаратний функціональний інтерфейс, а потім використовує покажчики функцій, що надаються для виконання дій для базового обладнання, без необхідності знати деталі реалізації конкретної цілі .
Покажчики функцій для створення делегатів, обробників та зворотних викликів
Ви можете використовувати функціональні покажчики як спосіб делегувати якусь задачу чи функціональність. Класичний приклад на C - це вказівник функції делегата порівняння, який використовується з функціями бібліотеки Standard C, qsort()та bsearch()надання порядку порівняння для сортування списку елементів або здійснення двійкового пошуку за відсортованим списком елементів. Делегат функції порівняння вказує алгоритм зіставлення, який використовується у сортуванні або у двійковому пошуку.
Інше використання аналогічне застосуванню алгоритму до контейнера стандартної бібліотеки шаблонів C ++.
void * ApplyAlgorithm (void *pArray, size_t sizeItem, size_t nItems, int (*p)(void *)) {
unsigned char *pList = pArray;
unsigned char *pListEnd = pList + nItems * sizeItem;
for ( ; pList < pListEnd; pList += sizeItem) {
p (pList);
}
return pArray;
}
int pIncrement(int *pI) {
(*pI)++;
return 1;
}
void * ApplyFold(void *pArray, size_t sizeItem, size_t nItems, void * pResult, int(*p)(void *, void *)) {
unsigned char *pList = pArray;
unsigned char *pListEnd = pList + nItems * sizeItem;
for (; pList < pListEnd; pList += sizeItem) {
p(pList, pResult);
}
return pArray;
}
int pSummation(int *pI, int *pSum) {
(*pSum) += *pI;
return 1;
}
// source code and then lets use our function.
int intList[30] = { 0 }, iSum = 0;
ApplyAlgorithm(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), pIncrement);
ApplyFold(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), &iSum, pSummation);
Інший приклад - вихідний код GUI, в якому реєструється обробник для певної події, надаючи покажчик функції, який насправді викликається, коли подія відбувається. Рамка Microsoft MFC зі своїми картами повідомлень використовує щось подібне для обробки повідомлень Windows, які доставляються у вікно або потік.
Асинхронні функції, які потребують зворотного дзвінка, схожі на обробник подій. Користувач асинхронної функції викликає асинхронну функцію для початку якоїсь дії та надає вказівник функції, який асинхронна функція буде викликати після завершення дії. У цьому випадку подія є асинхронною функцією, що виконує своє завдання.
Після цього давайте подивіться, як машина розуміє Them.Glimpse машинного навчання вищевказаної програми в 32-бітовій архітектурі.