�ݺ�ߣ

3/7/2016 Function pointer Wikipedia, the free encyclopedia
https://en.wikipedia.org/wiki/Function_pointer 1/6
Function pointer
From Wikipedia, the free encyclopedia
A function pointer (or subroutine pointer or procedure pointer) is a type of pointer 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]
Instead of referring to data values, a function pointer points to executable code within memory. When
dereferenced, a function pointer can be used to invoke the function it points to and pass it arguments just
like 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 name or address.
Function pointers can be used to simplify code by providing a simple way to select a function to execute
based on runtime values.
Contents
1 Simple function pointers
1.1 Example in C
2 Functors
3 Method pointers
4 In C++
5 Pointers to Member Functions in C++
6 See also
7 References
8 External links
Simple function pointers
The simplest implementation of a function (or subroutine) pointer is as a variable containing the address of
the function within executable memory. Older thirdgeneration 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. Such
pointers in older languages are generally less typesafe than in more modern languages since the latter
associate more typing information with a function pointer variable, such as the data type of the return value
of the function and the data type information of the parameters to the function.[3]

Example in C
The following C program illustrates the use of two function pointers:
func1 takes one doubleprecision (double) parameter and returns another double, and is assigned to a
function which converts centimetres to inches
func2 takes a pointer to a constant character array as well as an integer and returns a pointer to a
character, and is assigned to a string library function which returns a pointer to the first occurrence of
a given character in a character array
#include <stdio.h>  /* for printf */
#include <string.h> /* for strchr */
double cm_to_inches(double cm) {
return cm / 2.54;
}
int main(void) {
double (*func1)(double) = cm_to_inches;
char * (*func2)(const char *, int) = strchr;
printf("%f %s", func1(15.0), func2("Wikipedia", 'i'));
/* prints "5.905512 ikipedia" */
        return 0;
}
The next program uses a function pointer to invoke one of two functions (sin or cos) indirectly from
another function (compute_sum, computing an approximation of the function's Riemann integration). The
program operates by having function main call function compute_sum twice, passing it a pointer to the library
function sin the first time, and a pointer to function cos the second time. Function compute_sum in turn
invokes one of the two functions indirectly by dereferencing its function pointer argument funcp multiple
times, adding together the values that the invoked function returns and returning the resulting sum. The two
sums are written to the standard output by main.
#include <math.h>
#include <stdio.h>
// Function taking a function pointer as an argument
double compute_sum(double (*funcp)(double), double lo, double hi) {
    double  sum = 0.0;
    // Add values returned by the pointed‐to function '*funcp'
    for (int i = 0;  i <= 100;  i++) {
        double  x, y;
        // Use the function pointer 'funcp' to invoke the function
        x = i / 100.0 * (hi ‐ lo) + lo;
        y = (*funcp)(x);
        sum += y;
    }
    return sum / 101.0;
}
int main(void) {
    double  (*fp)(double);      // Function pointer
    double  sum;
    // Use 'sin()' as the pointed‐to function
    fp = sin;
    sum = compute_sum(fp, 0.0, 1.0);

    printf("sum(sin): %fn", sum);
    // Use 'cos()' as the pointed‐to function
    fp = cos;
    sum = compute_sum(fp, 0.0, 1.0);
    printf("sum(cos): %fn", sum);
    return 0;
}
Functors
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 functioncall 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" objectoriented 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 member
function. CLI languages such as C# and Visual Basic .NET implement typesafe function pointers with
delegates.
In other languages that support firstclass 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 slowdown for the code on modern
processors, because branch prediction 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 pointers
C++ is objectoriented, so classes can have methods. Nonstatic 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 "pointertomember" operators: .* or ‐>* (for an object or a pointer to object,
respectively).
Although function pointers in C and C++ can be implemented as simple addresses, so that typically
sizeof(Fx)==sizeof(void *), member pointers in C++ are often implemented as "fat pointers", typically
two or three times the size of a simple function pointer, in order to deal with virtual inheritance.
In C++
A C++ typical use of "pointers to functions" is for passing a function as an argument to another function,
since these cannot be passed dereferenced:
// Pointer to functions

#include <iostream>
using namespace std;
int add(int first, int second) {
    return first + second;
}
int subtract(int first, int second) {
    return first ‐ second;
}
int operation(int first, int second, int (*functocall)(int, int)) {
    return (*functocall)(first, second);
}
int main() {
    int  a, b;
    int  (*plus)(int, int) = add;
    int (*minus)(int, int) = subtract;
    a = operation(7, 5, plus);
    b = operation(20, a, minus);
    cout << "a = " << a << " and b = " << b << endl;
    return 0;
}
Alternatively, it is possible to use the C++ standard library class template std::function, of which the
instances are function objects:
#include <iostream>
#include <functional>
static double derivative(const std::function<double(double)> &f, double x0, double eps) {
    double eps2 = eps / 2;
    double lo = x0 ‐ eps2;
    double hi = x0 + eps2;
    return (f(hi) ‐ f(lo)) / eps;
}
static double f(double x) {
    return x * 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 add for simplicity. Function pointers to static member functions are done in
the traditional 'C' style because there is no object pointer or this call required.
#include <iostream>
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)) {
    return (pFoo‐>*pfn)(i,j);
}
typedef int(Foo::*Foo_pfn)(int,int);
int bar2(int i, int j, Foo* pFoo, Foo_pfn pfn) {
    return (pFoo‐>*pfn)(i,j);
}
typedef int(*PFN)(int);
int bar3(int i, PFN pfn) {
    return pfn(i);
}
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
Delegation (programming)
Function object
Higherorder function
Procedural parameter
References
1. Andrew J. Miller. "Fortran Examples". http://www.esm.psu.edu/~ajm138/fortranexamples.html. Retrieved
20130914.
2. "The Function Pointer Tutorials". http://www.newty.de/: logo. Retrieved 20110413. "Function Pointers are
pointers, i.e. variables, which point to the address of a function"
3. "The Function Pointer Tutorials". http://www.newty.de/: logo. Retrieved 20110413. "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 returntype!"
4. "Expertise: Intermediate Language: C++: Use Functor for Callbacks in C++". http://www.devx.com/: DevX.com.
20050131. Retrieved 20110413. "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]."

External links
FAQ on Function Pointers (http://www.parashift.com/c++faqlite/pointerstomembers.html#faq
33.12), things to avoid with function pointers, some information on using function objects
Function Pointer Tutorials (http://www.newty.de/fpt/), a guide to C/C++ function pointers, callbacks,
and function objects (functors)
Member Function Pointers and the Fastest Possible C++ Delegates
(http://www.codeproject.com/KB/cpp/FastDelegate.aspx), CodeProject article by Don Clugston
Pointer Tutorials (http://www.cplusplus.com/doc/tutorial/pointers.html), C++ documentation and
tutorials
Secure Function Pointer and Callbacks in Windows Programming
(http://www.codeproject.com/KB/security/Securefunctionpointer.aspx), CodeProject article by R.
Selvam
The C Book (http://publications.gbdirect.co.uk/c_book/chapter5/function_pointers.html), Function
Pointers in C by "The C Book"
Function Pointers in dBASE dBL
(http://www.dbase.com/help/2_80/Language_Definition/IDH_LDEF_FUNCPOINTERS.htm),
Function Pointer in dBASE dBL
Retrieved from "https://en.wikipedia.org/w/index.php?title=Function_pointer&oldid=702237802"
Categories: Data types Subroutines
This page was last modified on 29 January 2016, at 09:19.
Text is available under the Creative Commons AttributionShareAlike License; additional terms may
apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a
registered trademark of the Wikimedia Foundation, Inc., a nonprofit organization.

�ݺ�ߣ

Function pointer - Wikipedia, the free encyclopedia

More Related Content

Function pointer - Wikipedia, the free encyclopedia