Shulou(Shulou.com)06/03 Report--

This article will give you a detailed explanation on how to call back the function, the content of the article is of high quality, so the editor will share it with you for reference. I hope you will have a certain understanding of the relevant knowledge after reading this article.

1: the function name is pointer

First of all, in C language, function is a function-to-pointer way, that is, for a function, it is automatically converted to the type of pointer. Such as:

1 # include 2 3 void fun () 4 {5} 6 7 int main () 8 {9 printf ("% p% p% p\ n", & fun, fun, * fun); 10 return 0 * 11}

The result of these three values is the same. In fact, for the last * fun, even if there are many * signs in front of it, the result remains the same, that is, the result of * * fun, * fun is the same. For this problem, because it was mentioned earlier that the function is a function-to-pointer method, which is automatically converted to the pointer type, & fun is the address of the function, is the pointer type, fun is a function that is converted to its pointer type, and for * fun, because fun has become the pointer type

Point to this function, so * fun is the function that takes this address, and according to function-to-pointer, the function is converted to a pointer, so the results of the three values are the same.

2: callback function

Different functions are called dynamically by passing the address of the callback function to the caller. So when we want to implement different things through a unified interface, it is very appropriate to use the drop function.

To implement a callback function, the most important thing is to define the parameter of the calling function as the function pointer type. The definition of function pointer is a little bit here.

A little mention. For example:

Int (* ptr) (void); here ptr is a function pointer, where the parentheses of (* ptr) cannot be omitted because parentheses take precedence over asterisks, so it becomes a function declaration with an integer return type. Int is the return type, and the parentheses are the parameters of the function.

Here is an example to explain the use of the callback function:

1 # include 2 # include 3 int Test1 (int num) 4 {5 printf ("I am test1,the data is% d\ n", num); 6 return 0; 7} 8 int Test2 (int num) 9 {10 printf ("I am test2,the data is% d\ n", num); 11 return 0 12} 13 14 int Caller (int (* ptr) (int n), int n) / / the pointer to the function is used as the function parameter, where the second parameter is the function pointer parameter 15 {/ / cannot be written as void Caller2 (int (* ptr) (int n)). This definition is syntactically incorrect. 16 int a = (* ptr) (n); 17 return a; 18} 19 int main () 20 {21 22 Caller (Test1,20); 23 printf ("*\ n"); 24 Caller (Test2,10); 25 26 return 0; 27}

Here are some of the more confusing concepts of pointers:

1: function pointer

1: how function pointers are defined:

Return value type (* pointer variable name) (formal parameter list)

Return function definition with pointer value: return pointer type * function name (formal parameter list)

2: assignment of function pointer:

When assigning a value, you can point the function pointer directly to the function name (the function name represents the first address of the code), but only if the function pointer and the number and type of parameters of the function it points to must be the same. The return value type of the function pointer must be the same as that of the function.

3: call the function through the function pointer:

Plus the pointer f points to the function func. (* f) and func represent the same function.

The method of use is as follows:

Declaration function pointer: int (* f) (int x)

Function pointer assignment: f=func (int func (int x))

Function pointer calls function: (* f) (x) (x is an integer variable)

2: function pointer array

An array of function pointers is an array whose elements are function pointers. That is, the data structure is an array and its element is a pointer to the address of the function entry.

Definition method: return value (* array name [number]) (parameter list)

3: pointer to array

Type (* variable name) [number of elements]

4: pointer array

Type * variable name [number of elements]

Because [] has a better priority than *. So if the variable an is combined with *, it is a pointer, and if an is combined with [], it is an array.

Callback function with parameters:

/ / define the callback function void PrintfText (char* s) {printf (s);} / define the "calling function" void CallPrintfText (void (* callfuct) (char*), char* s) {callfuct (s);} / / implement the callback function int main (int argc,char* argv []) {CallPrintfText (PrintfText, "Hello World!\ n"); return 0;} C++ callback mechanism in the main function:

Non-static member function as callback function

Of course, if the static member function is similar to the global function, the world has not changed so far. For example, when you open a thread with AfxBeginThread in VC programming, you often define the parameter AFX_THREADPROC pfnThreadProc as a global function or a static member function, but neither of these is convenient to access the non-static members of the class. The reason for solemnly writing this article is that static callbacks used to be very uncomfortable before.

Is the callback function a nonstatic member function? We can't simply set it like this:

Class CCallback

{

Public:

Void Func (int a)

{

Cout

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.