| 词条 | Function pointer |
| 释义 |
A function pointer, also called a subroutine pointer or procedure pointer, is a pointer that points to a function. As opposed to referencing a data value, a function pointer points to executable code within memory. Dereferencing the function pointer yields the referenced function, which can be invoked and passed arguments just as in a normal function call. Such an invocation is also known as an "indirect" call, because the function is being invoked indirectly through a variable instead of directly through a fixed identifier or address. Function pointers can be used to simplify code by providing a simple way to select a function to execute based on run-time values. Function pointers are supported by third-generation programming languages (such as PL/I, COBOL, Fortran,[1] dBASE dBL, and C) and object-oriented programming languages (such as C++ and D).[2] Simple function pointersThe simplest implementation of a function (or subroutine) pointer is as a variable containing the address of the function within executable memory. Older third-generation languages such as PL/I and COBOL, as well as more modern languages such as Pascal and C generally implement function pointers in this manner.[3] Example in CThe following C program illustrates the use of two function pointers:
double cm_to_inches(double cm) { return cm / 2.54; } // "strchr" is part of the C string handling (i.e., no need for declaration) // See https://en.wikipedia.org/wiki/C_string_handling#Functions int main(void) { double (*func1)(double) = cm_to_inches; char * (*func2)(const char *, int) = strchr; printf("%f %s", func1(15.0), func2("Wikipedia", 'p')); /* prints "5.905512 pedia" */ return 0; } The next program uses a function pointer to invoke one of two functions (
// Function taking a function pointer as an argument double compute_sum(double (*funcp)(double), double lo, double hi) { // Add values returned by the pointed-to function '*funcp' int i; for(i = 0; i <= 100; i++) { // Use the function pointer 'funcp' to invoke the function double x = i / 100.0 * (hi - lo) + lo; double y = funcp(x); sum += y; } return sum / 101.0;} double square(double x) { } int main(void) { // Use standard library function 'sin()' as the pointed-to function sum = compute_sum(sin, 0.0, 1.0); printf("sum(sin): %g\", sum); // Use standard library function 'cos()' as the pointed-to function sum = compute_sum(cos, 0.0, 1.0); printf("sum(cos): %g\", sum); // Use user-defined function 'square()' as the pointed-to function sum = compute_sum(square, 0.0, 1.0); printf("sum(square): %g\", sum);} Functors{{main|Function object}}Functors, or function objects, are similar to function pointers, and can be used in similar ways. A functor is an object of a class type that implements the function-call operator, allowing the object to be used within expressions using the same syntax as a function call. Functors are more powerful than simple function pointers, being able to contain their own data values, and allowing the programmer to emulate closures. They are also used as callback functions if it is necessary to use a member function as a callback function.[4] Many "pure" object-oriented languages do not support function pointers. Something similar can be implemented in these kinds of languages, though, using references to interfaces that define a single method (member function). CLI languages such as C# and Visual Basic .NET implement type-safe function pointers with delegates. In other languages that support first-class functions, functions are regarded as data, and can be passed, returned, and created dynamically directly by other functions, eliminating the need for function pointers. Extensively using function pointers to call functions may produce a slow-down for the code on modern processors, because branch predictor may not be able to figure out where to branch to (it depends on the value of the function pointer at run time) although this effect can be overstated as it is often amply compensated for by significantly reduced non-indexed table lookups. Method pointersC++ includes support for object-oriented programming, so classes can have methods (usually referred to as member functions). Non-static member functions (instance methods) have an implicit parameter (the this pointer) which is the pointer to the object it is operating on, so the type of the object must be included as part of the type of the function pointer. The method is then used on an object of that class by using one of the "pointer-to-member" operators: Although function pointers in C and C++ can be implemented as simple addresses, so that typically In C++In C++, in addition to the method used in C, it is also possible to use the C++ standard library class template std::function, of which the instances are function objects:
static double derivative(const std::function double eps2 = eps / 2; double lo = x0 - eps2; double hi = x0 + eps2; return (f(hi) - f(lo)) / eps; } static double f(double x) { } int main() { double x = 1; std::cout << "d/dx(x ^ 2) [@ x = " << x << "] = " << derivative(f, x, 1e-5) << std::endl; return 0; } Pointers to member functions in C++This is how C++ uses function pointers when dealing with member functions of classes or structs. These are invoked using an object pointer or a this call. They are type safe in that you can only call members of that class (or derivatives) using a pointer of that type. This example also demonstrates the use of a typedef for the pointer to member function added for simplicity. Function pointers to static member functions are done in the traditional 'C' style because there is no object pointer for this call required.
using namespace std; class Foo { public: int add(int i, int j) { return i+j; } int mult(int i, int j) { return i*j; } static int negate(int i) { return -i; }}; int bar1(int i, int j, Foo* pFoo, int(Foo*pfn)(int,int)) { } typedef int(Foo*Foo_pfn)(int,int); int bar2(int i, int j, Foo* pFoo, Foo_pfn pfn) { } typedef int(*PFN)(int); int bar3(int i, PFN pfn) { } int main() { Foo foo; cout << "Foo::add(2,4) = " << bar1(2,4, &foo, &Foo::add) << endl; cout << "Foo::mult(3,5) = " << bar2(3,5, &foo, &Foo::mult) << endl; cout << "Foo::negate(6) = " << bar3(6, &Foo::negate) << endl; return 0; } See also
References1. ^{{cite web|url=http://www.esm.psu.edu/~ajm138/fortranexamples.html#ex1|title=Fortran Examples|author=Andrew J. Miller|location=http://www.esm.psu.edu/~ajm138/fortranexamples.html|accessdate=2013-09-14}} 2. ^{{cite web|url=http://www.newty.de/fpt/intro.html#what|title=The Function Pointer Tutorials|publisher=logo|location=http://www.newty.de/|accessdate=2011-04-13|quote=Function Pointers are pointers, i.e. variables, which point to the address of a function}} 3. ^{{cite web| accessdate = 2011-04-13| location = http://www.newty.de/| publisher = logo| title = The Function Pointer Tutorials| quote = Important note: A function pointer always points to a function with a specific signature! Thus all functions, you want to use with the same function pointer, must have the same parameters and return-type!| url = http://www.newty.de/fpt/intro.html#top}} 4. ^{{cite web| accessdate = 2011-04-13| date = 2005-01-31| location = http://www.devx.com/| publisher = DevX.com| title = Expertise: Intermediate Language: C++: Use Functor for Callbacks in C++| quote = If you want to use a member function as a callback function, then the member function needs to be associated with an object of the class before it can be called. In this case, you can use functor [with an example on this page].| url = http://www.devx.com/tips/Tip/27126}} External links
4 : Data types|Subroutines|Articles with example C code|Articles with example C++ code |
| 随便看 |
|
开放百科全书收录14589846条英语、德语、日语等多语种百科知识，基本涵盖了大多数领域的百科知识，是一部内容自由、开放的电子版国际百科全书。