Advanced usage of C language -- function pointer: callback function; Conversion table

The two most common uses of function pointers ： Pass as argument to another function （ Callback function ） And conversion table （jump table）, This article will explore some skills in these two aspects .

One . Callback function

​ There is a simple function , It is used to find a value in a single linked list . Its parameter is a point to the list number 1 The pointer of the node and the value to be found .

Node*
search_list (Node *node, int const value)
{
    
    while (node != NULL)
    {
    
        if (node->value == value)
            break;
        node = node->link;
    }
    return node;
}

​ This function looks quite simple , But it only applies to linked lists with integer values . If you need to find in a string linked list , You have to write another function . Most of the code of this function is the same as that of the above function , Only the type of the second parameter and the comparison method of node values are different .

​ A more general approach is to make the lookup function type independent , In this way, it can be used for linked lists of values of any type . We have to modify two aspects of the function , Make it type independent .

​ First , We must change the way comparisons are performed , In this way, the function can compare any type of value . This goal sounds impossible , If you write statements to compare integer values , How can it also be used for comparison of other types such as strings ？ The solution is to use A function pointer . The caller writes a function , Used to compare two values , Then pass a pointer to this function as a parameter to the lookup function . Then the lookup function calls this function to perform a value comparison . Using this method , Any type of value can be compared .

​ secondly , Pass a pointer to the value to the function instead of the value itself . The function has one void * Shape parameter , Used to receive this parameter . Then a pointer to this value is passed to the comparison function . String and array objects can also be used in this modification . Strings and arrays cannot be passed as parameters to arrays , But the pointer to them can .

​ The function that uses this technique is called Callback function （callback function）, Because the user passes a function pointer as a parameter to other functions , The latter will “ Callback ” The user's function . anytime , If the function you write must be able to perform different types of work at different times, or perform work that can only be defined by the function caller , You can use this technique .

​ We cannot write an accurate prototype for the callback function in this context , Because we don't know the type of value to compare . in fact , We need to find functions that can act on any type of value . The way to solve this problem is to declare the parameter type as void *, Express “ A pointer to an unknown type ”

The following code is an implementation method of type independent lookup function . Notice that the third parameter of the function is a function pointer .

/* ** Find a function with a specified value in a single linked list . Its parameter is a pointer to the first node of the linked list  ** A pointer to the value we need to find and a function pointer , The function it points to is used to compare the values of types stored in the linked list  */
#include <stdio.h>
#include "node.h"

Node *
search_list (Node *node, void const *value,
            int (*compare)(void const *, void const*))
{
    
    while (node != NULL)
    {
    
        if (compare(&node->value, value) == 0)
            break;
        node = node->link;
    }
    return node;
}

int 
compare_ints (void const *a, void const *b)
{
    
    if (*(int *)a == *(int *)b)
        return 0;
    else
        return 1;
}

This function will be used as follows ：

desired_node = search_list(root, &desired_value, compare_ints);

Two . Transfer table

​ The transfer table is best explained by an example . The following code snippet is taken from a program , It is used to realize a pocket calculator . The rest of the program has read in two numbers （op1 and op2） And an operator （oper）. The following code tests the operator , Then decide which function to call .

switch (oper)
{
    
    case ADD:
        result = add(op1, op2);
        break;
    case SUB:
        result = sub(op1, op2);
        break;
    case MUL:
        result = mul(op1, op2);
        break;
    case DIV:
        result = div(op1, op2);
        break;
    ...
}

​ For a novel calculator with hundreds of operators , This article switch The statement will be very long .

​ Why call functions to perform these operations ？ It is a good design scheme to separate the code of specific operation and selection operation . More complex operations will be implemented by independent functions , Because they can be very long . But even simple operations can have side effects , For example, save a constant value for future operations .

​ In order to make switch sentence , The code representing the operator must be an integer . If they are consecutive integers starting from zero , We can use the transformation table to achieve the same task . The conversion table is an array of function pointers .

​ Creating a transformation table requires two steps . First , Declare and initialize an array of function pointers . The only thing to pay attention to is to ensure that the prototypes of these functions appear before the declaration of this array .

double add (double, double);
double sub (double, double);
double mul (double, double);
double div (double, double);
...
double (*oper_func[]) (double, double) = 
{
    add, sub, mul, div,...};   

The correct order of function names in the initialization list depends on the integer code used by the program to represent each operator . This example assumes that ADD yes 0,SUB yes 1,MUL yes 2, And so on .

The second step is to replace the whole previous sentence with the following sentence switch sentence ！

result = oper_func[oper] (op1, op2);

oper Select the correct function pointer from the array , The function call operator will execute this function .

Thank you for reading ：）

inner peace

Unity of

---------------------END---------------------