Function pointer
- 20 min read
- 5 chapters
Related on Lably
Through Function (computer programming), Programming language generations and COBOL
Function pointers allow different code to be executed at runtime. They can also be passed to a function to enable callbacks.
Function pointers are supported by third-generation programming languages (such as PL/I, COBOL, Fortran, dBASE dBL, and C) and object-oriented programming languages (such as C++, C#, and D).
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 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.
Example in C
The following C program illustrates the use of two function pointers:
- func1 takes one double-precision (double) parameter and returns another double, and is assigned to a function which converts centimeters 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 C string handling function which returns a pointer to the first occurrence of a given character in a character array.
<span id="mwOw"></span><span class="cp" id="mwPA">#include</span><span class="w" id="mwPQ"> </span><span class="cpf" id="mwPg"><stdio.h></span><span class="c1" id="mwPw"> /* for printf */</span> <span class="cp" id="mwQA">#include</span><span class="w" id="mwQQ"> </span><span class="cpf" id="mwQg"><string.h></span><span class="c1" id="mwQw"> /* for strchr */</span> <span class="kt" id="mwRA">double</span><span class="w" id="mwRQ"> </span><span class="nf" id="mwRg">cm_to_inches</span><span class="p" id="mwRw">(</span><span class="kt" id="mwSA">double</span><span class="w" id="mwSQ"> </span><span class="n" id="mwSg">cm</span><span class="p" id="mwSw">)</span><span class="w" id="mwTA"> </span><span class="p" id="mwTQ">{</span> <span class="w" id="mwTg"> </span><span class="k" id="mwTw">return</span><span class="w" id="mwUA"> </span><span class="n" id="mwUQ">cm</span><span class="w" id="mwUg"> </span><span class="o" id="mwUw">/</span><span class="w" id="mwVA"> </span><span class="mf" id="mwVQ">2.54</span><span class="p" id="mwVg">;</span> <span class="p" id="mwVw">}</span> <span class="c1" id="mwWA">// "strchr" is part of the C string handling (i.e., no need for declaration)</span> <span class="c1" id="mwWQ">// See https://en.wikipedia.org/wiki/C_string_handling#Functions</span> <span class="kt" id="mwWg">int</span><span class="w" id="mwWw"> </span><span class="nf" id="mwXA">main</span><span class="p" id="mwXQ">(</span><span class="kt" id="mwXg">void</span><span class="p" id="mwXw">)</span><span class="w" id="mwYA"> </span><span class="p" id="mwYQ">{</span> <span class="w" id="mwYg"> </span><span class="kt" id="mwYw">double</span><span class="w" id="mwZA"> </span><span class="p" id="mwZQ">(</span><span class="o" id="mwZg">*</span><span class="n" id="mwZw">func1</span><span class="p" id="mwaA">)(</span><span class="kt" id="mwaQ">double</span><span class="p" id="mwag">)</span><span class="w" id="mwaw"> </span><span class="o" id="mwbA">=</span><span class="w" id="mwbQ"> </span><span class="n" id="mwbg">cm_to_inches</span><span class="p" id="mwbw">;</span> <span class="w" id="mwcA"> </span><span class="kt" id="mwcQ">char</span><span class="w" id="mwcg"> </span><span class="o" id="mwcw">*</span><span class="w" id="mwdA"> </span><span class="p" id="mwdQ">(</span><span class="o" id="mwdg">*</span><span class="n" id="mwdw">func2</span><span class="p" id="mweA">)(</span><span class="k" id="mweQ">const</span><span class="w" id="mweg"> </span><span class="kt" id="mwew">char</span><span class="w" id="mwfA"> </span><span class="o" id="mwfQ">*</span><span class="p" id="mwfg">,</span><span class="w" id="mwfw"> </span><span class="kt" id="mwgA">int</span><span class="p" id="mwgQ">)</span><span class="w" id="mwgg"> </span><span class="o" id="mwgw">=</span><span class="w" id="mwhA"> </span><span class="n" id="mwhQ">strchr</span><span class="p" id="mwhg">;</span> <span class="w" id="mwhw"> </span><span class="n" id="mwiA">printf</span><span class="p" id="mwiQ">(</span><span class="s" id="mwig">"%f %s"</span><span class="p" id="mwiw">,</span><span class="w" id="mwjA"> </span><span class="n" id="mwjQ">func1</span><span class="p" id="mwjg">(</span><span class="mf" id="mwjw">15.0</span><span class="p" id="mwkA">),</span><span class="w" id="mwkQ"> </span><span class="n" id="mwkg">func2</span><span class="p" id="mwkw">(</span><span class="s" id="mwlA">"Wikipedia"</span><span class="p" id="mwlQ">,</span><span class="w" id="mwlg"> </span><span class="sc" id="mwlw">'p'</span><span class="p" id="mwmA">));</span> <span class="w" id="mwmQ"> </span><span class="cm" id="mwmg">/* prints "5.905512 pedia" */</span> <span class="w" id="mwmw"> </span><span class="k" id="mwnA">return</span><span class="w" id="mwnQ"> </span><span class="mi" id="mwng">0</span><span class="p" id="mwnw">;</span> <span class="p" id="mwoA">}</span>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.
<span id="mwrw"></span><span class="linenos" data-line="1" id="mwsA"></span><span class="cp" id="mwsQ">#include</span><span class="w" id="mwsg"> </span><span class="cpf" id="mwsw"><math.h></span> <span class="linenos" data-line="2" id="mwtA"></span><span class="cp" id="mwtQ">#include</span><span class="w" id="mwtg"> </span><span class="cpf" id="mwtw"><stdio.h></span> <span class="linenos" data-line="3" id="mwuA"></span> <span class="linenos" data-line="4" id="mwuQ"></span><span class="c1" id="mwug">// Function taking a function pointer as an argument</span> <span class="linenos" data-line="5" id="mwuw"></span><span class="kt" id="mwvA">double</span><span class="w" id="mwvQ"> </span><span class="nf" id="mwvg">compute_sum</span><span class="p" id="mwvw">(</span><span class="kt" id="mwwA">double</span><span class="w" id="mwwQ"> </span><span class="p" id="mwwg">(</span><span class="o" id="mwww">*</span><span class="n" id="mwxA">funcp</span><span class="p" id="mwxQ">)(</span><span class="kt" id="mwxg">double</span><span class="p" id="mwxw">),</span><span class="w" id="mwyA"> </span><span class="kt" id="mwyQ">double</span><span class="w" id="mwyg"> </span><span class="n" id="mwyw">lo</span><span class="p" id="mwzA">,</span><span class="w" id="mwzQ"> </span><span class="kt" id="mwzg">double</span><span class="w" id="mwzw"> </span><span class="n" id="mw0A">hi</span><span class="p" id="mw0Q">)</span><span class="w" id="mw0g"> </span><span class="p" id="mw0w">{</span> <span class="linenos" data-line="6" id="mw1A"></span><span class="w" id="mw1Q"> </span><span class="kt" id="mw1g">double</span><span class="w" id="mw1w"> </span><span class="n" id="mw2A">sum</span><span class="w" id="mw2Q"> </span><span class="o" id="mw2g">=</span><span class="w" id="mw2w"> </span><span class="mf" id="mw3A">0.0</span><span class="p" id="mw3Q">;</span> <span class="linenos" data-line="7" id="mw3g"></span> <span class="linenos" data-line="8" id="mw3w"></span><span class="w" id="mw4A"> </span><span class="c1" id="mw4Q">// Add values returned by the pointed-to function '*funcp'</span> <span class="linenos" data-line="9" id="mw4g"></span><span class="w" id="mw4w"> </span><span class="kt" id="mw5A">int</span><span class="w" id="mw5Q"> </span><span class="n" id="mw5g">i</span><span class="p" id="mw5w">;</span> <span class="linenos" data-line="10" id="mw6A"></span><span class="w" id="mw6Q"> </span><span class="k" id="mw6g">for</span><span class="w" id="mw6w"> </span><span class="p" id="mw7A">(</span><span class="n" id="mw7Q">i</span><span class="w" id="mw7g"> </span><span class="o" id="mw7w">=</span><span class="w" id="mw8A"> </span><span class="mi" id="mw8Q">0</span><span class="p" id="mw8g">;</span><span class="w" id="mw8w"> </span><span class="n" id="mw9A">i</span><span class="w" id="mw9Q"> </span><span class="o" id="mw9g"><=</span><span class="w" id="mw9w"> </span><span class="mi" id="mw-A">100</span><span class="p" id="mw-Q">;</span><span class="w" id="mw-g"> </span><span class="n" id="mw-w">i</span><span class="o" id="mw_A">++</span><span class="p" id="mw_Q">)</span><span class="w" id="mw_g"> </span><span class="p" id="mw_w">{</span> <span class="linenos" data-line="11" id="mwAQA"></span><span class="w" id="mwAQE"> </span><span class="c1" id="mwAQI">// Use the function pointer 'funcp' to invoke the function</span> <span class="linenos" data-line="12" id="mwAQM"></span><span class="w" id="mwAQQ"> </span><span class="kt" id="mwAQU">double</span><span class="w" id="mwAQY"> </span><span class="n" id="mwAQc">x</span><span class="w" id="mwAQg"> </span><span class="o" id="mwAQk">=</span><span class="w" id="mwAQo"> </span><span class="n" id="mwAQs">i</span><span class="w" id="mwAQw"> </span><span class="o" id="mwAQ0">/</span><span class="w" id="mwAQ4"> </span><span class="mf" id="mwAQ8">100.0</span><span class="w" id="mwARA"> </span><span class="o" id="mwARE">*</span><span class="w" id="mwARI"> </span><span class="p" id="mwARM">(</span><span class="n" id="mwARQ">hi</span><span class="w" id="mwARU"> </span><span class="o" id="mwARY">-</span><span class="w" id="mwARc"> </span><span class="n" id="mwARg">lo</span><span class="p" id="mwARk">)</span><span class="w" id="mwARo"> </span><span class="o" id="mwARs">+</span><span class="w" id="mwARw"> </span><span class="n" id="mwAR0">lo</span><span class="p" id="mwAR4">;</span> <span class="linenos" data-line="13" id="mwAR8"></span><span class="w" id="mwASA"> </span><span class="kt" id="mwASE">double</span><span class="w" id="mwASI"> </span><span class="n" id="mwASM">y</span><span class="w" id="mwASQ"> </span><span class="o" id="mwASU">=</span><span class="w" id="mwASY"> </span><span class="n" id="mwASc">funcp</span><span class="p" id="mwASg">(</span><span class="n" id="mwASk">x</span><span class="p" id="mwASo">);</span> <span class="linenos" data-line="14" id="mwASs"></span><span class="w" id="mwASw"> </span><span class="n" id="mwAS0">sum</span><span class="w" id="mwAS4"> </span><span class="o" id="mwAS8">+=</span><span class="w" id="mwATA"> </span><span class="n" id="mwATE">y</span><span class="p" id="mwATI">;</span> <span class="linenos" data-line="15" id="mwATM"></span><span class="w" id="mwATQ"> </span><span class="p" id="mwATU">}</span> <span class="linenos" data-line="16" id="mwATY"></span><span class="w" id="mwATc"> </span><span class="k" id="mwATg">return</span><span class="w" id="mwATk"> </span><span class="n" id="mwATo">sum</span><span class="w" id="mwATs"> </span><span class="o" id="mwATw">/</span><span class="w" id="mwAT0"> </span><span class="mf" id="mwAT4">101.0</span><span class="w" id="mwAT8"> </span><span class="o" id="mwAUA">*</span><span class="w" id="mwAUE"> </span><span class="p" id="mwAUI">(</span><span class="n" id="mwAUM">hi</span><span class="w" id="mwAUQ"> </span><span class="o" id="mwAUU">-</span><span class="w" id="mwAUY"> </span><span class="n" id="mwAUc">lo</span><span class="p" id="mwAUg">);</span> <span class="linenos" data-line="17" id="mwAUk"></span><span class="p" id="mwAUo">}</span> <span class="linenos" data-line="18" id="mwAUs"></span> <span class="linenos" data-line="19" id="mwAUw"></span><span class="kt" id="mwAU0">double</span><span class="w" id="mwAU4"> </span><span class="nf" id="mwAU8">square</span><span class="p" id="mwAVA">(</span><span class="kt" id="mwAVE">double</span><span class="w" id="mwAVI"> </span><span class="n" id="mwAVM">x</span><span class="p" id="mwAVQ">)</span><span class="w" id="mwAVU"> </span><span class="p" id="mwAVY">{</span> <span class="linenos" data-line="20" id="mwAVc"></span><span class="w" id="mwAVg"> </span><span class="k" id="mwAVk">return</span><span class="w" id="mwAVo"> </span><span class="n" id="mwAVs">x</span><span class="w" id="mwAVw"> </span><span class="o" id="mwAV0">*</span><span class="w" id="mwAV4"> </span><span class="n" id="mwAV8">x</span><span class="p" id="mwAWA">;</span> <span class="linenos" data-line="21" id="mwAWE"></span><span class="p" id="mwAWI">}</span> <span class="linenos" data-line="22" id="mwAWM"></span> <span class="linenos" data-line="23" id="mwAWQ"></span><span class="kt" id="mwAWU">int</span><span class="w" id="mwAWY"> </span><span class="nf" id="mwAWc">main</span><span class="p" id="mwAWg">(</span><span class="kt" id="mwAWk">void</span><span class="p" id="mwAWo">)</span><span class="w" id="mwAWs"> </span><span class="p" id="mwAWw">{</span> <span class="linenos" data-line="24" id="mwAW0"></span><span class="w" id="mwAW4"> </span><span class="kt" id="mwAW8">double</span><span class="w" id="mwAXA"> </span><span class="n" id="mwAXE">sum</span><span class="p" id="mwAXI">;</span> <span class="linenos" data-line="25" id="mwAXM"></span> <span class="linenos" data-line="26" id="mwAXQ"></span><span class="w" id="mwAXU"> </span><span class="c1" id="mwAXY">// Use standard library function 'sin()' as the pointed-to function</span> <span class="linenos" data-line="27" id="mwAXc"></span><span class="w" id="mwAXg"> </span><span class="n" id="mwAXk">sum</span><span class="w" id="mwAXo"> </span><span class="o" id="mwAXs">=</span><span class="w" id="mwAXw"> </span><span class="n" id="mwAX0">compute_sum</span><span class="p" id="mwAX4">(</span><span class="n" id="mwAX8">sin</span><span class="p" id="mwAYA">,</span><span class="w" id="mwAYE"> </span><span class="mf" id="mwAYI">0.0</span><span class="p" id="mwAYM">,</span><span class="w" id="mwAYQ"> </span><span class="mf" id="mwAYU">1.0</span><span class="p" id="mwAYY">);</span> <span class="linenos" data-line="28" id="mwAYc"></span><span class="w" id="mwAYg"> </span><span class="n" id="mwAYk">printf</span><span class="p" id="mwAYo">(</span><span class="s" id="mwAYs">"sum(sin): %g</span><span class="se" id="mwAYw">\n</span><span class="s" id="mwAY0">"</span><span class="p" id="mwAY4">,</span><span class="w" id="mwAY8"> </span><span class="n" id="mwAZA">sum</span><span class="p" id="mwAZE">);</span> <span class="linenos" data-line="29" id="mwAZI"></span> <span class="linenos" data-line="30" id="mwAZM"></span><span class="w" id="mwAZQ"> </span><span class="c1" id="mwAZU">// Use standard library function 'cos()' as the pointed-to function</span> <span class="linenos" data-line="31" id="mwAZY"></span><span class="w" id="mwAZc"> </span><span class="n" id="mwAZg">sum</span><span class="w" id="mwAZk"> </span><span class="o" id="mwAZo">=</span><span class="w" id="mwAZs"> </span><span class="n" id="mwAZw">compute_sum</span><span class="p" id="mwAZ0">(</span><span class="n" id="mwAZ4">cos</span><span class="p" id="mwAZ8">,</span><span class="w" id="mwAaA"> </span><span class="mf" id="mwAaE">0.0</span><span class="p" id="mwAaI">,</span><span class="w" id="mwAaM"> </span><span class="mf" id="mwAaQ">1.0</span><span class="p" id="mwAaU">);</span> <span class="linenos" data-line="32" id="mwAaY"></span><span class="w" id="mwAac"> </span><span class="n" id="mwAag">printf</span><span class="p" id="mwAak">(</span><span class="s" id="mwAao">"sum(cos): %g</span><span class="se" id="mwAas">\n</span><span class="s" id="mwAaw">"</span><span class="p" id="mwAa0">,</span><span class="w" id="mwAa4"> </span><span class="n" id="mwAa8">sum</span><span class="p" id="mwAbA">);</span> <span class="linenos" data-line="33" id="mwAbE"></span> <span class="linenos" data-line="34" id="mwAbI"></span><span class="w" id="mwAbM"> </span><span class="c1" id="mwAbQ">// Use user-defined function 'square()' as the pointed-to function</span> <span class="linenos" data-line="35" id="mwAbU"></span><span class="w" id="mwAbY"> </span><span class="n" id="mwAbc">sum</span><span class="w" id="mwAbg"> </span><span class="o" id="mwAbk">=</span><span class="w" id="mwAbo"> </span><span class="n" id="mwAbs">compute_sum</span><span class="p" id="mwAbw">(</span><span class="n" id="mwAb0">square</span><span class="p" id="mwAb4">,</span><span class="w" id="mwAb8"> </span><span class="mf" id="mwAcA">0.0</span><span class="p" id="mwAcE">,</span><span class="w" id="mwAcI"> </span><span class="mf" id="mwAcM">1.0</span><span class="p" id="mwAcQ">);</span> <span class="linenos" data-line="36" id="mwAcU"></span><span class="w" id="mwAcY"> </span><span class="n" id="mwAcc">printf</span><span class="p" id="mwAcg">(</span><span class="s" id="mwAck">"sum(square): %g</span><span class="se" id="mwAco">\n</span><span class="s" id="mwAcs">"</span><span class="p" id="mwAcw">,</span><span class="w" id="mwAc0"> </span><span class="n" id="mwAc4">sum</span><span class="p" id="mwAc8">);</span> <span class="linenos" data-line="37" id="mwAdA"></span> <span class="linenos" data-line="38" id="mwAdE"></span><span class="w" id="mwAdI"> </span><span class="k" id="mwAdM">return</span><span class="w" id="mwAdQ"> </span><span class="mi" id="mwAdU">0</span><span class="p" id="mwAdY">;</span> <span class="linenos" data-line="39" id="mwAdc"></span><span class="p" id="mwAdg">}</span>Sign in to keep reading
4 more chapters are free with a Lably account.
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 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.
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 a 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 pointers
C++ 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: .* 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 sometimes implemented as "fat pointers", typically two or three times the size of a simple function pointer, in order to deal with virtual methods and virtual inheritance.
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:
<span id="mwAgU"></span><span class="cp" id="mwAgY">#include</span><span class="w" id="mwAgc"> </span><span class="cpf" id="mwAgg"><iostream></span> <span class="cp" id="mwAgk">#include</span><span class="w" id="mwAgo"> </span><span class="cpf" id="mwAgs"><functional></span> <span class="k" id="mwAgw">using</span><span class="w" id="mwAg0"> </span><span class="k" id="mwAg4">namespace</span><span class="w" id="mwAg8"> </span><span class="nn" id="mwAhA">std</span><span class="p" id="mwAhE">;</span> <span class="k" id="mwAhI">static</span><span class="w" id="mwAhM"> </span><span class="kt" id="mwAhQ">double</span><span class="w" id="mwAhU"> </span><span class="nf" id="mwAhY">derivative</span><span class="p" id="mwAhc">(</span><span class="k" id="mwAhg">const</span><span class="w" id="mwAhk"> </span><span class="n" id="mwAho">function</span><span class="o" id="mwAhs"><</span><span class="kt" id="mwAhw">double</span><span class="p" id="mwAh0">(</span><span class="kt" id="mwAh4">double</span><span class="p" id="mwAh8">)</span><span class="o" id="mwAiA">></span><span class="w" id="mwAiE"> </span><span class="o" id="mwAiI">&</span><span class="n" id="mwAiM">f</span><span class="p" id="mwAiQ">,</span><span class="w" id="mwAiU"> </span><span class="kt" id="mwAiY">double</span><span class="w" id="mwAic"> </span><span class="n" id="mwAig">x0</span><span class="p" id="mwAik">,</span><span class="w" id="mwAio"> </span><span class="kt" id="mwAis">double</span><span class="w" id="mwAiw"> </span><span class="n" id="mwAi0">eps</span><span class="p" id="mwAi4">)</span><span class="w" id="mwAi8"> </span><span class="p" id="mwAjA">{</span> <span class="w" id="mwAjE"> </span><span class="kt" id="mwAjI">double</span><span class="w" id="mwAjM"> </span><span class="n" id="mwAjQ">eps2</span><span class="w" id="mwAjU"> </span><span class="o" id="mwAjY">=</span><span class="w" id="mwAjc"> </span><span class="n" id="mwAjg">eps</span><span class="w" id="mwAjk"> </span><span class="o" id="mwAjo">/</span><span class="w" id="mwAjs"> </span><span class="mi" id="mwAjw">2</span><span class="p" id="mwAj0">;</span> <span class="w" id="mwAj4"> </span><span class="kt" id="mwAj8">double</span><span class="w" id="mwAkA"> </span><span class="n" id="mwAkE">lo</span><span class="w" id="mwAkI"> </span><span class="o" id="mwAkM">=</span><span class="w" id="mwAkQ"> </span><span class="n" id="mwAkU">x0</span><span class="w" id="mwAkY"> </span><span class="o" id="mwAkc">-</span><span class="w" id="mwAkg"> </span><span class="n" id="mwAkk">eps2</span><span class="p" id="mwAko">;</span> <span class="w" id="mwAks"> </span><span class="kt" id="mwAkw">double</span><span class="w" id="mwAk0"> </span><span class="n" id="mwAk4">hi</span><span class="w" id="mwAk8"> </span><span class="o" id="mwAlA">=</span><span class="w" id="mwAlE"> </span><span class="n" id="mwAlI">x0</span><span class="w" id="mwAlM"> </span><span class="o" id="mwAlQ">+</span><span class="w" id="mwAlU"> </span><span class="n" id="mwAlY">eps2</span><span class="p" id="mwAlc">;</span> <span class="w" id="mwAlg"> </span><span class="k" id="mwAlk">return</span><span class="w" id="mwAlo"> </span><span class="p" id="mwAls">(</span><span class="n" id="mwAlw">f</span><span class="p" id="mwAl0">(</span><span class="n" id="mwAl4">hi</span><span class="p" id="mwAl8">)</span><span class="w" id="mwAmA"> </span><span class="o" id="mwAmE">-</span><span class="w" id="mwAmI"> </span><span class="n" id="mwAmM">f</span><span class="p" id="mwAmQ">(</span><span class="n" id="mwAmU">lo</span><span class="p" id="mwAmY">))</span><span class="w" id="mwAmc"> </span><span class="o" id="mwAmg">/</span><span class="w" id="mwAmk"> </span><span class="n" id="mwAmo">eps</span><span class="p" id="mwAms">;</span> <span class="p" id="mwAmw">}</span> <span class="k" id="mwAm0">static</span><span class="w" id="mwAm4"> </span><span class="kt" id="mwAm8">double</span><span class="w" id="mwAnA"> </span><span class="nf" id="mwAnE">f</span><span class="p" id="mwAnI">(</span><span class="kt" id="mwAnM">double</span><span class="w" id="mwAnQ"> </span><span class="n" id="mwAnU">x</span><span class="p" id="mwAnY">)</span><span class="w" id="mwAnc"> </span><span class="p" id="mwAng">{</span> <span class="w" id="mwAnk"> </span><span class="k" id="mwAno">return</span><span class="w" id="mwAns"> </span><span class="n" id="mwAnw">x</span><span class="w" id="mwAn0"> </span><span class="o" id="mwAn4">*</span><span class="w" id="mwAn8"> </span><span class="n" id="mwAoA">x</span><span class="p" id="mwAoE">;</span> <span class="p" id="mwAoI">}</span> <span class="kt" id="mwAoM">int</span><span class="w" id="mwAoQ"> </span><span class="nf" id="mwAoU">main</span><span class="p" id="mwAoY">()</span><span class="w" id="mwAoc"> </span><span class="p" id="mwAog">{</span> <span class="w" id="mwAok"> </span><span class="kt" id="mwAoo">double</span><span class="w" id="mwAos"> </span><span class="n" id="mwAow">x</span><span class="w" id="mwAo0"> </span><span class="o" id="mwAo4">=</span><span class="w" id="mwAo8"> </span><span class="mi" id="mwApA">1</span><span class="p" id="mwApE">;</span> <span class="w" id="mwApI"> </span><span class="n" id="mwApM">cout</span><span class="w" id="mwApQ"> </span><span class="o" id="mwApU"><<</span><span class="w" id="mwApY"> </span><span class="s" id="mwApc">"d/dx(x ^ 2) [@ x = "</span><span class="w" id="mwApg"> </span><span class="o" id="mwApk"><<</span><span class="w" id="mwApo"> </span><span class="n" id="mwAps">x</span><span class="w" id="mwApw"> </span><span class="o" id="mwAp0"><<</span><span class="w" id="mwAp4"> </span><span class="s" id="mwAp8">"] = "</span><span class="w" id="mwAqA"> </span><span class="o" id="mwAqE"><<</span><span class="w" id="mwAqI"> </span><span class="n" id="mwAqM">derivative</span><span class="p" id="mwAqQ">(</span><span class="n" id="mwAqU">f</span><span class="p" id="mwAqY">,</span><span class="w" id="mwAqc"> </span><span class="n" id="mwAqg">x</span><span class="p" id="mwAqk">,</span><span class="w" id="mwAqo"> </span><span class="mf" id="mwAqs">1e-5</span><span class="p" id="mwAqw">)</span><span class="w" id="mwAq0"> </span><span class="o" id="mwAq4"><<</span><span class="w" id="mwAq8"> </span><span class="n" id="mwArA">endl</span><span class="p" id="mwArE">;</span> <span class="w" id="mwArI"> </span><span class="k" id="mwArM">return</span><span class="w" id="mwArQ"> </span><span class="mi" id="mwArU">0</span><span class="p" id="mwArY">;</span> <span class="p" id="mwArc">}</span>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.
<span id="mwAr4"></span><span class="cp" id="mwAr8">#include</span><span class="w" id="mwAsA"> </span><span class="cpf" id="mwAsE"><iostream></span> <span class="k" id="mwAsI">using</span><span class="w" id="mwAsM"> </span><span class="k" id="mwAsQ">namespace</span><span class="w" id="mwAsU"> </span><span class="nn" id="mwAsY">std</span><span class="p" id="mwAsc">;</span> <span class="k" id="mwAsg">class</span><span class="w" id="mwAsk"> </span><span class="nc" id="mwAso">Foo</span><span class="w" id="mwAss"> </span><span class="p" id="mwAsw">{</span> <span class="k" id="mwAs0">public</span><span class="o" id="mwAs4">:</span> <span class="w" id="mwAs8"> </span><span class="kt" id="mwAtA">int</span><span class="w" id="mwAtE"> </span><span class="n" id="mwAtI">add</span><span class="p" id="mwAtM">(</span><span class="kt" id="mwAtQ">int</span><span class="w" id="mwAtU"> </span><span class="n" id="mwAtY">i</span><span class="p" id="mwAtc">,</span><span class="w" id="mwAtg"> </span><span class="kt" id="mwAtk">int</span><span class="w" id="mwAto"> </span><span class="n" id="mwAts">j</span><span class="p" id="mwAtw">)</span><span class="w" id="mwAt0"> </span><span class="p" id="mwAt4">{</span> <span class="w" id="mwAt8"> </span><span class="k" id="mwAuA">return</span><span class="w" id="mwAuE"> </span><span class="n" id="mwAuI">i</span><span class="o" id="mwAuM">+</span><span class="n" id="mwAuQ">j</span><span class="p" id="mwAuU">;</span> <span class="w" id="mwAuY"> </span><span class="p" id="mwAuc">}</span> <span class="w" id="mwAug"> </span><span class="kt" id="mwAuk">int</span><span class="w" id="mwAuo"> </span><span class="n" id="mwAus">mult</span><span class="p" id="mwAuw">(</span><span class="kt" id="mwAu0">int</span><span class="w" id="mwAu4"> </span><span class="n" id="mwAu8">i</span><span class="p" id="mwAvA">,</span><span class="w" id="mwAvE"> </span><span class="kt" id="mwAvI">int</span><span class="w" id="mwAvM"> </span><span class="n" id="mwAvQ">j</span><span class="p" id="mwAvU">)</span><span class="w" id="mwAvY"> </span><span class="p" id="mwAvc">{</span> <span class="w" id="mwAvg"> </span><span class="k" id="mwAvk">return</span><span class="w" id="mwAvo"> </span><span class="n" id="mwAvs">i</span><span class="o" id="mwAvw">*</span><span class="n" id="mwAv0">j</span><span class="p" id="mwAv4">;</span> <span class="w" id="mwAv8"> </span><span class="p" id="mwAwA">}</span> <span class="w" id="mwAwE"> </span><span class="k" id="mwAwI">static</span><span class="w" id="mwAwM"> </span><span class="kt" id="mwAwQ">int</span><span class="w" id="mwAwU"> </span><span class="n" id="mwAwY">negate</span><span class="p" id="mwAwc">(</span><span class="kt" id="mwAwg">int</span><span class="w" id="mwAwk"> </span><span class="n" id="mwAwo">i</span><span class="p" id="mwAws">)</span><span class="w" id="mwAww"> </span><span class="p" id="mwAw0">{</span> <span class="w" id="mwAw4"> </span><span class="k" id="mwAw8">return</span><span class="w" id="mwAxA"> </span><span class="o" id="mwAxE">-</span><span class="n" id="mwAxI">i</span><span class="p" id="mwAxM">;</span> <span class="w" id="mwAxQ"> </span><span class="p" id="mwAxU">}</span> <span class="p" id="mwAxY">};</span> <span class="kt" id="mwAxc">int</span><span class="w" id="mwAxg"> </span><span class="nf" id="mwAxk">bar1</span><span class="p" id="mwAxo">(</span><span class="kt" id="mwAxs">int</span><span class="w" id="mwAxw"> </span><span class="n" id="mwAx0">i</span><span class="p" id="mwAx4">,</span><span class="w" id="mwAx8"> </span><span class="kt" id="mwAyA">int</span><span class="w" id="mwAyE"> </span><span class="n" id="mwAyI">j</span><span class="p" id="mwAyM">,</span><span class="w" id="mwAyQ"> </span><span class="n" id="mwAyU">Foo</span><span class="o" id="mwAyY">*</span><span class="w" id="mwAyc"> </span><span class="n" id="mwAyg">pFoo</span><span class="p" id="mwAyk">,</span><span class="w" id="mwAyo"> </span><span class="kt" id="mwAys">int</span><span class="p" id="mwAyw">(</span><span class="n" id="mwAy0">Foo</span><span class="o" id="mwAy4">::*</span><span class="n" id="mwAy8">pfn</span><span class="p" id="mwAzA">)(</span><span class="kt" id="mwAzE">int</span><span class="p" id="mwAzI">,</span><span class="kt" id="mwAzM">int</span><span class="p" id="mwAzQ">))</span><span class="w" id="mwAzU"> </span><span class="p" id="mwAzY">{</span> <span class="w" id="mwAzc"> </span><span class="k" id="mwAzg">return</span><span class="w" id="mwAzk"> </span><span class="p" id="mwAzo">(</span><span class="n" id="mwAzs">pFoo</span><span class="o" id="mwAzw">->*</span><span class="n" id="mwAz0">pfn</span><span class="p" id="mwAz4">)(</span><span class="n" id="mwAz8">i</span><span class="p" id="mwA0A">,</span><span class="n" id="mwA0E">j</span><span class="p" id="mwA0I">);</span> <span class="p" id="mwA0M">}</span> <span class="k" id="mwA0Q">typedef</span><span class="w" id="mwA0U"> </span><span class="kt" id="mwA0Y">int</span><span class="p" id="mwA0c">(</span><span class="n" id="mwA0g">Foo</span><span class="o" id="mwA0k">::*</span><span class="n" id="mwA0o">Foo_pfn</span><span class="p" id="mwA0s">)(</span><span class="kt" id="mwA0w">int</span><span class="p" id="mwA00">,</span><span class="kt" id="mwA04">int</span><span class="p" id="mwA08">);</span> <span class="kt" id="mwA1A">int</span><span class="w" id="mwA1E"> </span><span class="nf" id="mwA1I">bar2</span><span class="p" id="mwA1M">(</span><span class="kt" id="mwA1Q">int</span><span class="w" id="mwA1U"> </span><span class="n" id="mwA1Y">i</span><span class="p" id="mwA1c">,</span><span class="w" id="mwA1g"> </span><span class="kt" id="mwA1k">int</span><span class="w" id="mwA1o"> </span><span class="n" id="mwA1s">j</span><span class="p" id="mwA1w">,</span><span class="w" id="mwA10"> </span><span class="n" id="mwA14">Foo</span><span class="o" id="mwA18">*</span><span class="w" id="mwA2A"> </span><span class="n" id="mwA2E">pFoo</span><span class="p" id="mwA2I">,</span><span class="w" id="mwA2M"> </span><span class="n" id="mwA2Q">Foo_pfn</span><span class="w" id="mwA2U"> </span><span class="n" id="mwA2Y">pfn</span><span class="p" id="mwA2c">)</span><span class="w" id="mwA2g"> </span><span class="p" id="mwA2k">{</span> <span class="w" id="mwA2o"> </span><span class="k" id="mwA2s">return</span><span class="w" id="mwA2w"> </span><span class="p" id="mwA20">(</span><span class="n" id="mwA24">pFoo</span><span class="o" id="mwA28">->*</span><span class="n" id="mwA3A">pfn</span><span class="p" id="mwA3E">)(</span><span class="n" id="mwA3I">i</span><span class="p" id="mwA3M">,</span><span class="n" id="mwA3Q">j</span><span class="p" id="mwA3U">);</span> <span class="p" id="mwA3Y">}</span> <span class="k" id="mwA3c">typedef</span><span class="w" id="mwA3g"> </span><span class="k" id="mwA3k">auto</span><span class="p" id="mwA3o">(</span><span class="o" id="mwA3s">*</span><span class="n" id="mwA3w">PFN</span><span class="p" id="mwA30">)(</span><span class="kt" id="mwA34">int</span><span class="p" id="mwA38">)</span><span class="w" id="mwA4A"> </span><span class="o" id="mwA4E">-></span><span class="w" id="mwA4I"> </span><span class="kt" id="mwA4M">int</span><span class="p" id="mwA4Q">;</span> <span class="c1" id="mwA4U">// C++ only, same as: typedef int(*PFN)(int);</span> <span class="kt" id="mwA4Y">int</span><span class="w" id="mwA4c"> </span><span class="nf" id="mwA4g">bar3</span><span class="p" id="mwA4k">(</span><span class="kt" id="mwA4o">int</span><span class="w" id="mwA4s"> </span><span class="n" id="mwA4w">i</span><span class="p" id="mwA40">,</span><span class="w" id="mwA44"> </span><span class="n" id="mwA48">PFN</span><span class="w" id="mwA5A"> </span><span class="n" id="mwA5E">pfn</span><span class="p" id="mwA5I">)</span><span class="w" id="mwA5M"> </span><span class="p" id="mwA5Q">{</span> <span class="w" id="mwA5U"> </span><span class="k" id="mwA5Y">return</span><span class="w" id="mwA5c"> </span><span class="n" id="mwA5g">pfn</span><span class="p" id="mwA5k">(</span><span class="n" id="mwA5o">i</span><span class="p" id="mwA5s">);</span> <span class="p" id="mwA5w">}</span> <span class="kt" id="mwA50">int</span><span class="w" id="mwA54"> </span><span class="nf" id="mwA58">main</span><span class="p" id="mwA6A">()</span><span class="w" id="mwA6E"> </span><span class="p" id="mwA6I">{</span> <span class="w" id="mwA6M"> </span><span class="n" id="mwA6Q">Foo</span><span class="w" id="mwA6U"> </span><span class="n" id="mwA6Y">foo</span><span class="p" id="mwA6c">;</span> <span class="w" id="mwA6g"> </span><span class="n" id="mwA6k">cout</span><span class="w" id="mwA6o"> </span><span class="o" id="mwA6s"><<</span><span class="w" id="mwA6w"> </span><span class="s" id="mwA60">"Foo::add(2,4) = "</span><span class="w" id="mwA64"> </span><span class="o" id="mwA68"><<</span><span class="w" id="mwA7A"> </span><span class="n" id="mwA7E">bar1</span><span class="p" id="mwA7I">(</span><span class="mi" id="mwA7M">2</span><span class="p" id="mwA7Q">,</span><span class="mi" id="mwA7U">4</span><span class="p" id="mwA7Y">,</span><span class="w" id="mwA7c"> </span><span class="o" id="mwA7g">&</span><span class="n" id="mwA7k">foo</span><span class="p" id="mwA7o">,</span><span class="w" id="mwA7s"> </span><span class="o" id="mwA7w">&</span><span class="n" id="mwA70">Foo</span><span class="o" id="mwA74">::</span><span class="n" id="mwA78">add</span><span class="p" id="mwA8A">)</span><span class="w" id="mwA8E"> </span><span class="o" id="mwA8I"><<</span><span class="w" id="mwA8M"> </span><span class="n" id="mwA8Q">endl</span><span class="p" id="mwA8U">;</span> <span class="w" id="mwA8Y"> </span><span class="n" id="mwA8c">cout</span><span class="w" id="mwA8g"> </span><span class="o" id="mwA8k"><<</span><span class="w" id="mwA8o"> </span><span class="s" id="mwA8s">"Foo::mult(3,5) = "</span><span class="w" id="mwA8w"> </span><span class="o" id="mwA80"><<</span><span class="w" id="mwA84"> </span><span class="n" id="mwA88">bar2</span><span class="p" id="mwA9A">(</span><span class="mi" id="mwA9E">3</span><span class="p" id="mwA9I">,</span><span class="mi" id="mwA9M">5</span><span class="p" id="mwA9Q">,</span><span class="w" id="mwA9U"> </span><span class="o" id="mwA9Y">&</span><span class="n" id="mwA9c">foo</span><span class="p" id="mwA9g">,</span><span class="w" id="mwA9k"> </span><span class="o" id="mwA9o">&</span><span class="n" id="mwA9s">Foo</span><span class="o" id="mwA9w">::</span><span class="n" id="mwA90">mult</span><span class="p" id="mwA94">)</span><span class="w" id="mwA98"> </span><span class="o" id="mwA-A"><<</span><span class="w" id="mwA-E"> </span><span class="n" id="mwA-I">endl</span><span class="p" id="mwA-M">;</span> <span class="w" id="mwA-Q"> </span><span class="n" id="mwA-U">cout</span><span class="w" id="mwA-Y"> </span><span class="o" id="mwA-c"><<</span><span class="w" id="mwA-g"> </span><span class="s" id="mwA-k">"Foo::negate(6) = "</span><span class="w" id="mwA-o"> </span><span class="o" id="mwA-s"><<</span><span class="w" id="mwA-w"> </span><span class="n" id="mwA-0">bar3</span><span class="p" id="mwA-4">(</span><span class="mi" id="mwA-8">6</span><span class="p" id="mwA_A">,</span><span class="w" id="mwA_E"> </span><span class="o" id="mwA_I">&</span><span class="n" id="mwA_M">Foo</span><span class="o" id="mwA_Q">::</span><span class="n" id="mwA_U">negate</span><span class="p" id="mwA_Y">)</span><span class="w" id="mwA_c"> </span><span class="o" id="mwA_g"><<</span><span class="w" id="mwA_k"> </span><span class="n" id="mwA_o">endl</span><span class="p" id="mwA_s">;</span> <span class="w" id="mwA_w"> </span><span class="k" id="mwA_0">return</span><span class="w" id="mwA_4"> </span><span class="mi" id="mwA_8">0</span><span class="p" id="mwBAA">;</span> <span class="p" id="mwBAE">}</span>Alternate C and C++ syntax
The C and C++ syntax given above is the canonical one used in all the textbooks - but it's difficult to read and explain. Even the above typedef examples use this syntax. However, every C and C++ compiler supports a more clear and concise mechanism to declare function pointers: use typedef, but don't store the pointer as part of the definition. Note that the only way this kind of typedef can actually be used is with a pointer - but that highlights the pointer-ness of it.
C and C++
<span id="mwBAs"></span><span class="c1" id="mwBAw">// This declares 'F', a function that accepts a 'char' and returns an 'int'. Definition is elsewhere.</span> <span class="kt" id="mwBA0">int</span><span class="w" id="mwBA4"> </span><span class="nf" id="mwBA8">F</span><span class="p" id="mwBBA">(</span><span class="kt" id="mwBBE">char</span><span class="w" id="mwBBI"> </span><span class="n" id="mwBBM">c</span><span class="p" id="mwBBQ">);</span> <span class="c1" id="mwBBU">// This defines 'Fn', a type of function that accepts a 'char' and returns an 'int'.</span> <span class="k" id="mwBBY">typedef</span><span class="w" id="mwBBc"> </span><span class="kt" id="mwBBg">int</span><span class="w" id="mwBBk"> </span><span class="nf" id="mwBBo">Fn</span><span class="p" id="mwBBs">(</span><span class="kt" id="mwBBw">char</span><span class="w" id="mwBB0"> </span><span class="n" id="mwBB4">c</span><span class="p" id="mwBB8">);</span> <span class="c1" id="mwBCA">// This defines 'fn', a variable of type pointer-to-'Fn', and assigns the address of 'F' to it.</span> <span class="n" id="mwBCE">Fn</span><span class="w" id="mwBCI"> </span><span class="o" id="mwBCM">*</span><span class="n" id="mwBCQ">fn</span><span class="w" id="mwBCU"> </span><span class="o" id="mwBCY">=</span><span class="w" id="mwBCc"> </span><span class="o" id="mwBCg">&</span><span class="n" id="mwBCk">F</span><span class="p" id="mwBCo">;</span><span class="w" id="mwBCs"> </span><span class="c1" id="mwBCw">// Note '&' not required - but it highlights what is being done.</span> <span class="c1" id="mwBC0">// This calls 'F' using 'fn', assigning the result to the variable 'a'</span> <span class="kt" id="mwBC4">int</span><span class="w" id="mwBC8"> </span><span class="n" id="mwBDA">a</span><span class="w" id="mwBDE"> </span><span class="o" id="mwBDI">=</span><span class="w" id="mwBDM"> </span><span class="n" id="mwBDQ">fn</span><span class="p" id="mwBDU">(</span><span class="sc" id="mwBDY">'A'</span><span class="p" id="mwBDc">);</span> <span class="c1" id="mwBDg">// This defines 'Call', a function that accepts a pointer-to-'Fn', calls it, and returns the result</span> <span class="kt" id="mwBDk">int</span><span class="w" id="mwBDo"> </span><span class="nf" id="mwBDs">Call</span><span class="p" id="mwBDw">(</span><span class="n" id="mwBD0">Fn</span><span class="w" id="mwBD4"> </span><span class="o" id="mwBD8">*</span><span class="n" id="mwBEA">fn</span><span class="p" id="mwBEE">,</span><span class="w" id="mwBEI"> </span><span class="kt" id="mwBEM">char</span><span class="w" id="mwBEQ"> </span><span class="n" id="mwBEU">c</span><span class="p" id="mwBEY">)</span><span class="w" id="mwBEc"> </span><span class="p" id="mwBEg">{</span> <span class="w" id="mwBEk"> </span><span class="k" id="mwBEo">return</span><span class="w" id="mwBEs"> </span><span class="n" id="mwBEw">fn</span><span class="p" id="mwBE0">(</span><span class="n" id="mwBE4">c</span><span class="p" id="mwBE8">);</span> <span class="p" id="mwBFA">}</span><span class="w" id="mwBFE"> </span><span class="c1" id="mwBFI">// Call(fn, c)</span> <span class="c1" id="mwBFM">// This calls function 'Call', passing in 'F' and assigning the result to 'call'</span> <span class="kt" id="mwBFQ">int</span><span class="w" id="mwBFU"> </span><span class="n" id="mwBFY">call</span><span class="w" id="mwBFc"> </span><span class="o" id="mwBFg">=</span><span class="w" id="mwBFk"> </span><span class="n" id="mwBFo">Call</span><span class="p" id="mwBFs">(</span><span class="o" id="mwBFw">&</span><span class="n" id="mwBF0">F</span><span class="p" id="mwBF4">,</span><span class="w" id="mwBF8"> </span><span class="sc" id="mwBGA">'A'</span><span class="p" id="mwBGE">);</span><span class="w" id="mwBGI"> </span><span class="c1" id="mwBGM">// Again, '&' is not required</span> <span class="c1" id="mwBGQ">// LEGACY: Note that to maintain existing code bases, the above definition style can still be used first;</span> <span class="c1" id="mwBGU">// then the original type can be defined in terms of it using the new style.</span> <span class="c1" id="mwBGY">// This defines 'PFn', a type of pointer-to-type-Fn.</span> <span class="k" id="mwBGc">typedef</span><span class="w" id="mwBGg"> </span><span class="n" id="mwBGk">Fn</span><span class="w" id="mwBGo"> </span><span class="o" id="mwBGs">*</span><span class="n" id="mwBGw">PFn</span><span class="p" id="mwBG0">;</span> <span class="c1" id="mwBG4">// 'PFn' can be used wherever 'Fn *' can</span> <span class="n" id="mwBG8">PFn</span><span class="w" id="mwBHA"> </span><span class="n" id="mwBHE">pfn</span><span class="w" id="mwBHI"> </span><span class="o" id="mwBHM">=</span><span class="w" id="mwBHQ"> </span><span class="n" id="mwBHU">F</span><span class="p" id="mwBHY">;</span> <span class="kt" id="mwBHc">int</span><span class="w" id="mwBHg"> </span><span class="nf" id="mwBHk">CallP</span><span class="p" id="mwBHo">(</span><span class="n" id="mwBHs">PFn</span><span class="w" id="mwBHw"> </span><span class="n" id="mwBH0">fn</span><span class="p" id="mwBH4">,</span><span class="w" id="mwBH8"> </span><span class="kt" id="mwBIA">char</span><span class="w" id="mwBIE"> </span><span class="n" id="mwBII">c</span><span class="p" id="mwBIM">);</span>C++
These examples use the above definitions. In particular, note that the above definition for Fn can be used in pointer-to-member-function definitions:
<span id="mwBIk"></span><span class="c1" id="mwBIo">// This defines 'C', a class with similar static and member functions,</span> <span class="c1" id="mwBIs">// and then creates an instance called 'c'</span> <span class="k" id="mwBIw">class</span><span class="w" id="mwBI0"> </span><span class="nc" id="mwBI4">C</span><span class="w" id="mwBI8"> </span><span class="p" id="mwBJA">{</span> <span class="k" id="mwBJE">public</span><span class="o" id="mwBJI">:</span> <span class="k" id="mwBJM">static</span><span class="w" id="mwBJQ"> </span><span class="kt" id="mwBJU">int</span><span class="w" id="mwBJY"> </span><span class="n" id="mwBJc">Static</span><span class="p" id="mwBJg">(</span><span class="kt" id="mwBJk">char</span><span class="w" id="mwBJo"> </span><span class="n" id="mwBJs">c</span><span class="p" id="mwBJw">);</span> <span class="kt" id="mwBJ0">int</span><span class="w" id="mwBJ4"> </span><span class="nf" id="mwBJ8">Member</span><span class="p" id="mwBKA">(</span><span class="kt" id="mwBKE">char</span><span class="w" id="mwBKI"> </span><span class="n" id="mwBKM">c</span><span class="p" id="mwBKQ">);</span> <span class="p" id="mwBKU">}</span><span class="w" id="mwBKY"> </span><span class="n" id="mwBKc">c</span><span class="p" id="mwBKg">;</span><span class="w" id="mwBKk"> </span><span class="c1" id="mwBKo">// C</span> <span class="c1" id="mwBKs">// This defines 'p', a pointer to 'C' and assigns the address of 'c' to it</span> <span class="n" id="mwBKw">C</span><span class="w" id="mwBK0"> </span><span class="o" id="mwBK4">*</span><span class="n" id="mwBK8">p</span><span class="w" id="mwBLA"> </span><span class="o" id="mwBLE">=</span><span class="w" id="mwBLI"> </span><span class="o" id="mwBLM">&</span><span class="n" id="mwBLQ">c</span><span class="p" id="mwBLU">;</span> <span class="c1" id="mwBLY">// This assigns a pointer-to-'Static' to 'fn'.</span> <span class="c1" id="mwBLc">// Since there is no 'this', 'Fn' is the correct type; and 'fn' can be used as above.</span> <span class="n" id="mwBLg">fn</span><span class="w" id="mwBLk"> </span><span class="o" id="mwBLo">=</span><span class="w" id="mwBLs"> </span><span class="o" id="mwBLw">&</span><span class="n" id="mwBL0">C</span><span class="o" id="mwBL4">::</span><span class="n" id="mwBL8">Static</span><span class="p" id="mwBMA">;</span> <span class="c1" id="mwBME">// This defines 'm', a pointer-to-member-of-'C' with type 'Fn',</span> <span class="c1" id="mwBMI">// and assigns the address of 'C::Member' to it.</span> <span class="c1" id="mwBMM">// You can read it right-to-left like all pointers:</span> <span class="c1" id="mwBMQ">// "'m' is a pointer to member of class 'C' of type 'Fn'"</span> <span class="n" id="mwBMU">Fn</span><span class="w" id="mwBMY"> </span><span class="n" id="mwBMc">C</span><span class="o" id="mwBMg">::*</span><span class="n" id="mwBMk">m</span><span class="w" id="mwBMo"> </span><span class="o" id="mwBMs">=</span><span class="w" id="mwBMw"> </span><span class="o" id="mwBM0">&</span><span class="n" id="mwBM4">C</span><span class="o" id="mwBM8">::</span><span class="n" id="mwBNA">Member</span><span class="p" id="mwBNE">;</span> <span class="c1" id="mwBNI">// This uses 'm' to call 'Member' in 'c', assigning the result to 'cA'</span> <span class="kt" id="mwBNM">int</span><span class="w" id="mwBNQ"> </span><span class="n" id="mwBNU">cA</span><span class="w" id="mwBNY"> </span><span class="o" id="mwBNc">=</span><span class="w" id="mwBNg"> </span><span class="p" id="mwBNk">(</span><span class="n" id="mwBNo">c</span><span class="p" id="mwBNs">.</span><span class="o" id="mwBNw">*</span><span class="n" id="mwBN0">m</span><span class="p" id="mwBN4">)(</span><span class="sc" id="mwBN8">'A'</span><span class="p" id="mwBOA">);</span> <span class="c1" id="mwBOE">// This uses 'm' to call 'Member' in 'p', assigning the result to 'pA'</span> <span class="kt" id="mwBOI">int</span><span class="w" id="mwBOM"> </span><span class="n" id="mwBOQ">pA</span><span class="w" id="mwBOU"> </span><span class="o" id="mwBOY">=</span><span class="w" id="mwBOc"> </span><span class="p" id="mwBOg">(</span><span class="n" id="mwBOk">p</span><span class="o" id="mwBOo">->*</span><span class="n" id="mwBOs">m</span><span class="p" id="mwBOw">)(</span><span class="sc" id="mwBO0">'A'</span><span class="p" id="mwBO4">);</span> <span class="c1" id="mwBO8">// This defines 'Ref', a function that accepts a reference-to-'C',</span> <span class="c1" id="mwBPA">// a pointer-to-member-of-'C' of type 'Fn', and a 'char',</span> <span class="c1" id="mwBPE">// calls the function and returns the result</span> <span class="kt" id="mwBPI">int</span><span class="w" id="mwBPM"> </span><span class="nf" id="mwBPQ">Ref</span><span class="p" id="mwBPU">(</span><span class="n" id="mwBPY">C</span><span class="w" id="mwBPc"> </span><span class="o" id="mwBPg">&</span><span class="n" id="mwBPk">r</span><span class="p" id="mwBPo">,</span><span class="w" id="mwBPs"> </span><span class="n" id="mwBPw">Fn</span><span class="w" id="mwBP0"> </span><span class="n" id="mwBP4">C</span><span class="o" id="mwBP8">::*</span><span class="n" id="mwBQA">m</span><span class="p" id="mwBQE">,</span><span class="w" id="mwBQI"> </span><span class="kt" id="mwBQM">char</span><span class="w" id="mwBQQ"> </span><span class="n" id="mwBQU">c</span><span class="p" id="mwBQY">)</span><span class="w" id="mwBQc"> </span><span class="p" id="mwBQg">{</span> <span class="w" id="mwBQk"> </span><span class="k" id="mwBQo">return</span><span class="w" id="mwBQs"> </span><span class="p" id="mwBQw">(</span><span class="n" id="mwBQ0">r</span><span class="p" id="mwBQ4">.</span><span class="o" id="mwBQ8">*</span><span class="n" id="mwBRA">m</span><span class="p" id="mwBRE">)(</span><span class="n" id="mwBRI">c</span><span class="p" id="mwBRM">);</span> <span class="p" id="mwBRQ">}</span><span class="w" id="mwBRU"> </span><span class="c1" id="mwBRY">// Ref(r, m, c)</span> <span class="c1" id="mwBRc">// This defines 'Ptr', a function that accepts a pointer-to-'C',</span> <span class="c1" id="mwBRg">// a pointer-to-member-of-'C' of type 'Fn', and a 'char',</span> <span class="c1" id="mwBRk">// calls the function and returns the result</span> <span class="kt" id="mwBRo">int</span><span class="w" id="mwBRs"> </span><span class="nf" id="mwBRw">Ptr</span><span class="p" id="mwBR0">(</span><span class="n" id="mwBR4">C</span><span class="w" id="mwBR8"> </span><span class="o" id="mwBSA">*</span><span class="n" id="mwBSE">p</span><span class="p" id="mwBSI">,</span><span class="w" id="mwBSM"> </span><span class="n" id="mwBSQ">Fn</span><span class="w" id="mwBSU"> </span><span class="n" id="mwBSY">C</span><span class="o" id="mwBSc">::*</span><span class="n" id="mwBSg">m</span><span class="p" id="mwBSk">,</span><span class="w" id="mwBSo"> </span><span class="kt" id="mwBSs">char</span><span class="w" id="mwBSw"> </span><span class="n" id="mwBS0">c</span><span class="p" id="mwBS4">)</span><span class="w" id="mwBS8"> </span><span class="p" id="mwBTA">{</span> <span class="w" id="mwBTE"> </span><span class="k" id="mwBTI">return</span><span class="w" id="mwBTM"> </span><span class="p" id="mwBTQ">(</span><span class="n" id="mwBTU">p</span><span class="o" id="mwBTY">->*</span><span class="n" id="mwBTc">m</span><span class="p" id="mwBTg">)(</span><span class="n" id="mwBTk">c</span><span class="p" id="mwBTo">);</span> <span class="p" id="mwBTs">}</span><span class="w" id="mwBTw"> </span><span class="c1" id="mwBT0">// Ptr(p, m, c)</span> <span class="c1" id="mwBT4">// LEGACY: Note that to maintain existing code bases, the above definition style can still be used first;</span> <span class="c1" id="mwBT8">// then the original type can be defined in terms of it using the new style.</span> <span class="c1" id="mwBUA">// This defines 'FnC', a type of pointer-to-member-of-class-'C' of type 'Fn'</span> <span class="k" id="mwBUE">typedef</span><span class="w" id="mwBUI"> </span><span class="n" id="mwBUM">Fn</span><span class="w" id="mwBUQ"> </span><span class="n" id="mwBUU">C</span><span class="o" id="mwBUY">::*</span><span class="n" id="mwBUc">FnC</span><span class="p" id="mwBUg">;</span> <span class="c1" id="mwBUk">// 'FnC' can be used wherever 'Fn C::*' can</span> <span class="n" id="mwBUo">FnC</span><span class="w" id="mwBUs"> </span><span class="n" id="mwBUw">fnC</span><span class="w" id="mwBU0"> </span><span class="o" id="mwBU4">=</span><span class="w" id="mwBU8"> </span><span class="o" id="mwBVA">&</span><span class="n" id="mwBVE">C</span><span class="o" id="mwBVI">::</span><span class="n" id="mwBVM">Member</span><span class="p" id="mwBVQ">;</span> <span class="kt" id="mwBVU">int</span><span class="w" id="mwBVY"> </span><span class="nf" id="mwBVc">RefP</span><span class="p" id="mwBVg">(</span><span class="n" id="mwBVk">C</span><span class="w" id="mwBVo"> </span><span class="o" id="mwBVs">&</span><span class="n" id="mwBVw">p</span><span class="p" id="mwBV0">,</span><span class="w" id="mwBV4"> </span><span class="n" id="mwBV8">FnC</span><span class="w" id="mwBWA"> </span><span class="n" id="mwBWE">m</span><span class="p" id="mwBWI">,</span><span class="w" id="mwBWM"> </span><span class="kt" id="mwBWQ">char</span><span class="w" id="mwBWU"> </span><span class="n" id="mwBWY">c</span><span class="p" id="mwBWc">);</span>