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

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

version.h

// First, undefine all macros associated with version.h
#undef DEBUG_VERSION
#undef RELEASE_VERSION
#undef INVALID_VERSION


// Define which version we want to use
#define DEBUG_VERSION       // The current version
// #define RELEASE_VERSION  // To be uncommented when finished debugging

#ifndef __VERSION_H_      /* prevent circular inclusions */
    #define __VERSION_H_  /* by using protection macros */
    void board_init();
    void noprintf(const char *c, ...); // mimic the printf prototype
#endif

// Mimics the printf function prototype. This is what I'll actually 
// use to print stuff to the screen
void (* zprintf)(const char*, ...); 

// If debug version, use printf
#ifdef DEBUG_VERSION
    #include <stdio.h>
#endif

// If both debug and release version, error
#ifdef DEBUG_VERSION
#ifdef RELEASE_VERSION
    #define INVALID_VERSION
#endif
#endif

// If neither debug or release version, error
#ifndef DEBUG_VERSION
#ifndef RELEASE_VERSION
    #define INVALID_VERSION
#endif
#endif

#ifdef INVALID_VERSION
    // Won't allow compilation without a valid version define
    #error "Invalid version definition"
#endif

В version.c я определяю прототипы 2-х функций, представленные в version.h

version.c

#include "version.h"

/*****************************************************************************/
/**
* @name board_init
*
* Sets up the application based on the version type defined in version.h.
* Includes allowing or prohibiting printing to STDOUT.
*
* MUST BE CALLED FIRST THING IN MAIN
*
* @return    None
*
*****************************************************************************/
void board_init()
{
    // Assign the print function to the correct function pointer
    #ifdef DEBUG_VERSION
        zprintf = &printf;
    #else
        // Defined below this function
        zprintf = &noprintf;
    #endif
}

/*****************************************************************************/
/**
* @name noprintf
*
* simply returns with no actions performed
*
* @return   None
*
*****************************************************************************/
void noprintf(const char* c, ...)
{
    return;
}

Обратите внимание на то, как указатель функции прототипирован в version.h как void (* zprintf)(const char *, ...);. Когда он ссылается в приложении, он начнет выполнение везде, где он указывает, что еще должно быть определены. В version.c уведомление в функции board_init(), где zprintf назначается уникальная функция (подпись функции которой соответствует) в зависимости от версии, определенной в version.h zprintf = &printf;, zprintf вызывает printf для целей отладки или zprintf = &noprint; zprintf просто возвращает и не будет запускать ненужный код

Запуск кода будет выглядеть следующим образом:

mainProg.c

#include "version.h"
#include <stdlib.h>
int main()
{
    // Must run board_init(), which assigns the function
    // pointer to an actual function
    board_init();

    void *ptr = malloc(100); // Allocate 100 bytes of memory
    // malloc returns NULL if unable to allocate the memory.

    if (ptr == NULL)
    {
        zprintf("Unable to allocate memory\n");
        return 1;
    }

    // Other things to do...
    return 0;
}

В приведенном выше коде будет использоваться printf в режиме отладки или ничего не делать, если в режиме деблокирования. Это намного проще, чем пройти весь проект и комментировать или удалять код. Все, что мне нужно сделать, это изменить версию в version.h, а код сделает все остальное!

Одним из больших применений для указателей функций в C является вызов функции, выбранной во время выполнения. Например, библиотека времени выполнения C имеет две процедуры: qsort и bsearch, которые принимают указатель на функцию, вызываемую для сравнения двух отсортированных элементов; это позволяет сортировать или искать, соответственно, что угодно, на основе любых критериев, которые вы хотите использовать.

Очень простой пример, если есть одна функция, называемая print (int x, int y), которая, в свою очередь, может потребовать вызова функции add () или sub (), которые имеют похожие типы, тогда мы будем do, мы добавим один аргумент указателя на функцию print (), как показано ниже: -

int add()
{
   return (100+10);
}

int sub()
{
   return (100-10);
}

void print(int x, int y, int (*func)())
{
    printf("value is : %d", (x+y+(*func)()));
}

int main()
{
    int x=100, y=200;
    print(x,y,add);
    print(x,y,sub);

    return 0;
}

Указатель функции обычно определяется typedef и используется как param & amp; возвращаемое значение,

Выше ответов уже много объяснено, я просто приведу полный пример:

#include <stdio.h>

#define NUM_A 1
#define NUM_B 2

// define a function pointer type
typedef int (*two_num_operation)(int, int);

// an actual standalone function
static int sum(int a, int b) {
    return a + b;
}

// use function pointer as param,
static int sum_via_pointer(int a, int b, two_num_operation funp) {
    return (*funp)(a, b);
}

// use function pointer as return value,
static two_num_operation get_sum_fun() {
    return &sum;
}

// test - use function pointer as variable,
void test_pointer_as_variable() {
    // create a pointer to function,
    two_num_operation sum_p = &sum;
    // call function via pointer
    printf("pointer as variable:\t %d + %d = %d\n", NUM_A, NUM_B, (*sum_p)(NUM_A, NUM_B));
}

// test - use function pointer as param,
void test_pointer_as_param() {
    printf("pointer as param:\t %d + %d = %d\n", NUM_A, NUM_B, sum_via_pointer(NUM_A, NUM_B, &sum));
}

// test - use function pointer as return value,
void test_pointer_as_return_value() {
    printf("pointer as return value:\t %d + %d = %d\n", NUM_A, NUM_B, (*get_sum_fun())(NUM_A, NUM_B));
}

int main() {
    test_pointer_as_variable();
    test_pointer_as_param();
    test_pointer_as_return_value();

    return 0;
}

полезны во многих ситуациях, например:

• Члены COM-объектов являются указателями на функцию ag: This->lpVtbl->AddRef(This); AddRef является указателем на функцию.
• функция callback, например, функция, определяемая пользователем, для сравнения двух переменных, которые должны передаваться как обратный вызов специальной функции сортировки.
• очень полезен для реализации плагина и SDK приложения.

Начиная с нуля функция имеет некоторый адрес памяти от того места, где они начинают выполняться. В языке сборки они называются (вызывают «адрес памяти функции»). Теперь вернитесь к функции C Если у функции есть адрес памяти, тогда с ними можно управлять указателями в C.So. По правилам C

1. Сначала вам нужно объявить указатель на функцию 2.Pass адрес желаемой функции

**** Примечание-> функции должны быть одного типа ****

Эта простая программа будет иллюстрировать каждую вещь.

#include<stdio.h>
void (*print)() ;//Declare a  Function Pointers
void sayhello();//Declare The Function Whose Address is to be passed
                //The Functions should Be of Same Type
int main()
{

 print=sayhello;//Addressof sayhello is assigned to print
 print();//print Does A call To The Function 
 return 0;
}

void sayhello()
{
 printf("\n Hello World");
}

[/g0] После этого позволяет увидеть, как машина понимает Them.Glimpse машинной инструкции вышеуказанной программы в 32-битной архитектуре.

В области красных отметок показано, как происходит обмен и хранение адреса в eax. Затем их команда вызова на eax. eax содержит желаемый адрес функции

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

C довольно изменчив и прощает одновременно:)