The magical functions of function pointers and array of function pointers

The magical functions of function pointers and array of function pointersI encountered such a problem in the development of a software process, the front-level module passed to my binary data, the input parameters of char* buffer and int length,buffer is the first address of the data, length represents the size of this batch of data. The data is characterized by a variable length, a variable type, and a 256 (28) Probability of identifying the type of the data by the first byte (Buffer[0]). My task is to have to deal with every possible data type, and my module contains several functions that are handled in a similar way within each function. If you follow the usual practice, you will write the following code:

void Myfuntion (char* buffer, int length)
{
__int8 nstreamtype = buffer[0];

Switch (nstreamtype)
{
Case 0:
Function1 ();
Break
Case 1:
......
Case 255:
function255 ();
Break
}
}

If this method is written down, then in each of my functions, must make so many judgments, write the code must be very long, and each processing, have to make many judgments before finding the correct processing function, code execution efficiency is not high. In response to the above problem, I think of the method of using a function pointer array to solve this problem.

The concept of function pointers, mentioned in the classic tutorial of Mr. Tam Hao's C language program, is not used in most cases and ignores its existence. The function name is actually a pointer to the entry address of the function, but it is also different from the normal, such as the int*, double* pointers, see the following example to understand the concept of function pointers:
int funtion (int x, int y);
void Main (void)
{
Int (*fun) (int x, int y);
int a = ten, B = 20;
function (A, b);
fun = function;
(*fun) (A, b);
......
}
Statement 1 defines a functional function whose input is two integers and returns an integer number (input parameter and return value can be any other data type); Statement 3 defines a function pointer, which is different from the int* or double* definition pointer. The definition of a function pointer must also indicate the input parameter, indicating that it is a function pointer, and that *fun must be enclosed in parentheses, and statement 6 assigns a function pointer to funtion, provided that the input and return values of *fun and functions must be consistent. Statement 5 calls function functions directly (), and statement 7 is called function pointers, which are equivalent.

Of course, from the above example can not see the advantages of function pointers, the purpose is to elicit the concept of function pointer array. We can tell from the above example that since function names can be saved by function pointers, it is also possible to define an array to hold several function names, which is the array of function pointers. The proper use of a function pointer array is that several functions that need to be saved through a function pointer array must have the same input and output values.

  In this way, the problems I face in my work can be resolved as follows:

first defines 256 processing functions (and their implementations).

void Funtion0 (void);
...
void funtion255 (void);
The
next defines an array of function pointers and assigns values to the array.
Void (*fun[256]) (void);

Fun[0] = function0;
...
fun[255] = function ();
Finally, the MyFunction () function can be modified as follows:

void Myfuntion (char 　　　　* buffer, int length)
{
__int8 nstreamtype = buffer[0];
(*fun[nstreamtype]) ();
}

as long as 2 lines of code, the completion of the 256 case statement to do, reduce the amount of work to write code, the Nstreamtype as an array subscript, directly call the function pointer, from the code execution efficiency, also higher than the cases. If you want to do this in more than one function, the function pointer array will show its advantages.