<dt><spanclass="section"><ahref="mem_fn.html#mem_fn.faq.can_mem_fn_be_used_instead_of_th">Can <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> be used instead of the standard <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">mem_fun</span><spanclass="special">[</span><spanclass="identifier">_ref</span><spanclass="special">]</span></code>
adaptors?</a></span></dt>
<dt><spanclass="section"><ahref="mem_fn.html#mem_fn.faq.should_i_replace_every_occurence">Should I
replace every occurence of <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">mem_fun</span><spanclass="special">[</span><spanclass="identifier">_ref</span><spanclass="special">]</span></code>
with <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> in my existing
code?</a></span></dt>
<dt><spanclass="section"><ahref="mem_fn.html#mem_fn.faq.does_mem_fn_work_with_com_method">Does <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> work with COM methods?</a></span></dt>
<codeclass="computeroutput"><spanclass="identifier">__cdecl</span></code>, and <codeclass="computeroutput"><spanclass="identifier">__fastcall</span></code> Support</a></span></dt>
<codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">mem_fn</span></code> is a generalization of the standard
functions <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">mem_fun</span></code> and <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">mem_fun_ref</span></code>.
It supports member function pointers with more than one argument, and the returned
function object can take a pointer, a reference, or a smart pointer to an object
instance as its first argument. <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code>
also supports pointers to data members by treating them as functions taking
no arguments and returning a (const) reference to the member.
</p>
<p>
The purpose of <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> is twofold.
First, it allows users to invoke a member function on a container with the
<spanclass="emphasis"><em>Effects:</em></span> Equivalent to <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">for_each</span><spanclass="special">(</span><spanclass="identifier">first</span><spanclass="special">,</span><spanclass="identifier">last</span><spanclass="special">,</span><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">mem_fn</span><spanclass="special">(</span><spanclass="identifier">pmf</span><spanclass="special">))</span></code>.
</li></ul></div>
<p>
where <codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">mem_fn</span></code> can be a link to this page. See the
<ahref="../../../../libs/bind/bind.html"target="_top">documentation of <codeclass="computeroutput"><spanclass="identifier">bind</span></code></a>
for an example.
</p>
<p>
<codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> takes one argument,
a pointer to a member, and returns a function object suitable for use with
The returned function object takes the same arguments as the input member function
plus a "flexible" first argument that represents the object instance.
</p>
<p>
When the function object is invoked with a first argument <codeclass="computeroutput"><spanclass="identifier">x</span></code>
that is neither a pointer nor a reference to the appropriate class (<codeclass="computeroutput"><spanclass="identifier">X</span></code> in the example above), it uses <codeclass="computeroutput"><spanclass="identifier">get_pointer</span><spanclass="special">(</span><spanclass="identifier">x</span><spanclass="special">)</span></code> to obtain
a pointer from <codeclass="computeroutput"><spanclass="identifier">x</span></code>. Library authors
can "register" their smart pointer classes by supplying an appropriate
is not restricted to return a pointer. Any object that can be used in a member
function call expression <codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">x</span><spanclass="special">->*</span><spanclass="identifier">pmf</span><spanclass="special">)(...)</span></code> will work.<spanclass="emphasis"><em>]</em></span>
</p>
<p>
<spanclass="emphasis"><em>[Note:</em></span> the library uses an unqualified call to <codeclass="computeroutput"><spanclass="identifier">get_pointer</span></code>. Therefore, it will find, through
overloads that are defined in the same namespace as the corresponding smart
pointer class, in addition to any <codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">get_pointer</span></code>
overloads.<spanclass="emphasis"><em>]</em></span>
</p>
<p>
All function objects returned by <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code>
expose a <codeclass="computeroutput"><spanclass="identifier">result_type</span></code> typedef
that represents the return type of the member function. For data members,
<codeclass="computeroutput"><spanclass="identifier">result_type</span></code> is defined as the
<aname="mem_fn.faq.can_mem_fn_be_used_instead_of_th"></a><aclass="link"href="mem_fn.html#mem_fn.faq.can_mem_fn_be_used_instead_of_th"title="Can mem_fn be used instead of the standard std::mem_fun[_ref] adaptors?">Can <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> be used instead of the standard <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">mem_fun</span><spanclass="special">[</span><spanclass="identifier">_ref</span><spanclass="special">]</span></code>
adaptors?</a>
</h3></div></div></div>
<p>
Yes. For simple uses, <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code>
provides additional functionality that the standard adaptors do not. Complicated
expressions that use <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">bind1st</span></code>,
<codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">bind2nd</span></code> or <ahref="http://www.boost.org/doc/libs/1_31_0/libs/compose/index.htm"target="_top">Boost.Compose</a>
along with the standard adaptors can be rewritten using <codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">bind</span></code>
that automatically takes advantage of <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code>.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="mem_fn.faq.should_i_replace_every_occurence"></a><aclass="link"href="mem_fn.html#mem_fn.faq.should_i_replace_every_occurence"title="Should I replace every occurence of std::mem_fun[_ref] with mem_fn in my existing code?">Should I
replace every occurence of <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">mem_fun</span><spanclass="special">[</span><spanclass="identifier">_ref</span><spanclass="special">]</span></code>
with <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> in my existing
code?</a>
</h3></div></div></div>
<p>
No, unless you have good reasons to do so. <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code>
is not 100% compatible with the standard adaptors, although it comes pretty
close. In particular, <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code>
does not return objects of type <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::[</span><spanclass="identifier">const_</span><spanclass="special">]</span><spanclass="identifier">mem_fun</span><spanclass="special">[</span><spanclass="number">1</span><spanclass="special">][</span><spanclass="identifier">_ref</span><spanclass="special">]</span><spanclass="identifier">_t</span></code>,
as the standard adaptors do, and it is not possible to fully describe the
type of the first argument using the standard <codeclass="computeroutput"><spanclass="identifier">argument_type</span></code>
and <codeclass="computeroutput"><spanclass="identifier">first_argument_type</span></code> nested
typedefs. Libraries that need adaptable function objects in order to function
might not like <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code>.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="mem_fn.faq.does_mem_fn_work_with_com_method"></a><aclass="link"href="mem_fn.html#mem_fn.faq.does_mem_fn_work_with_com_method"title="Does mem_fn work with COM methods?">Does <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> work with COM methods?</a>
</h3></div></div></div>
<p>
Yes, if you <aclass="link"href="mem_fn.html#mem_fn.implementation.stdcall"title="__stdcall, __cdecl, and __fastcall Support">`#define BOOST_MEM_FN_ENABLE_STDCALL</a>.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="mem_fn.faq.why_isn_t_boost_mem_fn_enable_st"></a><aclass="link"href="mem_fn.html#mem_fn.faq.why_isn_t_boost_mem_fn_enable_st"title="Why isn't BOOST_MEM_FN_ENABLE_STDCALL defined automatically?">Why isn't
All <spanclass="emphasis"><em>unspecified-N</em></span> types mentioned in the Synopsis are
<spanclass="emphasis"><em>CopyConstructible</em></span> and <spanclass="emphasis"><em>Assignable</em></span>.
Their copy constructors and assignment operators do not throw exceptions.
<spanclass="emphasis"><em>unspecified-N</em></span><codeclass="computeroutput"><spanclass="special">::</span><spanclass="identifier">result_type</span></code> is defined as the return type
of the member function pointer passed as an argument to <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code>
(<codeclass="computeroutput"><spanclass="identifier">R</span></code> in the Synopsis.) <spanclass="emphasis"><em>unspecified-2-1</em></span><codeclass="computeroutput"><spanclass="special">::</span><spanclass="identifier">result_type</span></code>
is defined as <codeclass="computeroutput"><spanclass="identifier">R</span></code>.
<spanclass="emphasis"><em>Returns:</em></span> a function object ϝ such that the
expression ϝ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">)</span></code> is equivalent to <codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">.*</span><spanclass="identifier">pmf</span><spanclass="special">)()</span></code>
when <codeclass="computeroutput"><spanclass="identifier">t</span></code> is an l-value
of type <codeclass="computeroutput"><spanclass="identifier">T</span></code> or derived,
<spanclass="emphasis"><em>Returns:</em></span> a function object ϝ such that the
expression ϝ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">)</span></code> is equivalent to <codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">.*</span><spanclass="identifier">pmf</span><spanclass="special">)()</span></code>
when <codeclass="computeroutput"><spanclass="identifier">t</span></code> is of type <codeclass="computeroutput"><spanclass="identifier">T</span></code><spanclass="emphasis"><em>[</em></span><codeclass="computeroutput"><spanclass="keyword">const</span></code><spanclass="emphasis"><em>]</em></span> or derived,
<spanclass="emphasis"><em>Returns:</em></span> a function object ϝ such that the
expression ϝ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">)</span></code> is equivalent to <codeclass="computeroutput"><spanclass="identifier">t</span><spanclass="special">.*</span><spanclass="identifier">pm</span></code>
when <codeclass="computeroutput"><spanclass="identifier">t</span></code> is of type <codeclass="computeroutput"><spanclass="identifier">T</span></code><spanclass="emphasis"><em>[</em></span><codeclass="computeroutput"><spanclass="keyword">const</span></code><spanclass="emphasis"><em>]</em></span> or derived,
<spanclass="emphasis"><em>Returns:</em></span> a function object ϝ such that the
expression ϝ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">,</span><spanclass="identifier">a1</span><spanclass="special">)</span></code> is equivalent to <codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">.*</span><spanclass="identifier">pmf</span><spanclass="special">)(</span><spanclass="identifier">a1</span><spanclass="special">)</span></code>
when <codeclass="computeroutput"><spanclass="identifier">t</span></code> is an l-value
of type <codeclass="computeroutput"><spanclass="identifier">T</span></code> or derived,
<spanclass="emphasis"><em>Returns:</em></span> a function object ϝ such that the
expression ϝ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">,</span><spanclass="identifier">a1</span><spanclass="special">)</span></code> is equivalent to <codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">.*</span><spanclass="identifier">pmf</span><spanclass="special">)(</span><spanclass="identifier">a1</span><spanclass="special">)</span></code>
when <codeclass="computeroutput"><spanclass="identifier">t</span></code> is of type <codeclass="computeroutput"><spanclass="identifier">T</span></code><spanclass="emphasis"><em>[</em></span><codeclass="computeroutput"><spanclass="keyword">const</span></code><spanclass="emphasis"><em>]</em></span> or derived,
<spanclass="emphasis"><em>Returns:</em></span> a function object ϝ such that the
expression ϝ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">,</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">)</span></code> is equivalent to <codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">.*</span><spanclass="identifier">pmf</span><spanclass="special">)(</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">)</span></code>
when <codeclass="computeroutput"><spanclass="identifier">t</span></code> is an l-value
of type <codeclass="computeroutput"><spanclass="identifier">T</span></code> or derived,
<spanclass="emphasis"><em>Returns:</em></span> a function object ϝ such that the
expression ϝ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">,</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">)</span></code> is equivalent to <codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">t</span><spanclass="special">.*</span><spanclass="identifier">pmf</span><spanclass="special">)(</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">)</span></code>
when <codeclass="computeroutput"><spanclass="identifier">t</span></code> is of type <codeclass="computeroutput"><spanclass="identifier">T</span></code><spanclass="emphasis"><em>[</em></span><codeclass="computeroutput"><spanclass="keyword">const</span></code><spanclass="emphasis"><em>]</em></span> or derived,
(used by <codeclass="computeroutput"><spanclass="identifier">mem_fn</span><spanclass="special">.</span><spanclass="identifier">hpp</span></code>, do not include directly)
(used by <codeclass="computeroutput"><spanclass="identifier">mem_fn</span><spanclass="special">.</span><spanclass="identifier">hpp</span></code>, do not include directly)
(used by <codeclass="computeroutput"><spanclass="identifier">mem_fn</span><spanclass="special">.</span><spanclass="identifier">hpp</span></code>, do not include directly)
<aname="mem_fn.implementation.number_of_arguments"></a><aclass="link"href="mem_fn.html#mem_fn.implementation.number_of_arguments"title="Number of Arguments">Number of
Arguments</a>
</h3></div></div></div>
<p>
This implementation supports member functions with up to eight arguments.
This is not an inherent limitation of the design, but an implementation detail.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="mem_fn.implementation.stdcall"></a><aclass="link"href="mem_fn.html#mem_fn.implementation.stdcall"title="__stdcall, __cdecl, and __fastcall Support"><codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code>,
<codeclass="computeroutput"><spanclass="identifier">__cdecl</span></code>, and <codeclass="computeroutput"><spanclass="identifier">__fastcall</span></code> Support</a>
</h3></div></div></div>
<p>
Some platforms allow several types of member functions that differ by their
calling convention (the rules by which the function is invoked: how are arguments
passed, how is the return value handled, and who cleans up the stack - if
any.)
</p>
<p>
For example, Windows API functions and COM interface member functions use
a calling convention known as <codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code>.
Borland VCL components use <codeclass="computeroutput"><spanclass="identifier">__fastcall</span></code>.
UDK, the component model of OpenOffice.org, uses <codeclass="computeroutput"><spanclass="identifier">__cdecl</span></code>.
</p>
<p>
To use <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> with <codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code> member functions, <codeclass="computeroutput"><spanclass="preprocessor">#define</span></code> the macro <codeclass="computeroutput"><spanclass="identifier">BOOST_MEM_FN_ENABLE_STDCALL</span></code>
before including <codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">mem_fn</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code>.
</p>
<p>
To use <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> with <codeclass="computeroutput"><spanclass="identifier">__fastcall</span></code> member functions, <codeclass="computeroutput"><spanclass="preprocessor">#define</span></code> the macro <codeclass="computeroutput"><spanclass="identifier">BOOST_MEM_FN_ENABLE_FASTCALL</span></code>
before including <codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">mem_fn</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code>.
</p>
<p>
To use <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> with <codeclass="computeroutput"><spanclass="identifier">__cdecl</span></code> member functions, <codeclass="computeroutput"><spanclass="preprocessor">#define</span></code> the macro <codeclass="computeroutput"><spanclass="identifier">BOOST_MEM_FN_ENABLE_CDECL</span></code>
before including <codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">mem_fn</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code>.
</p>
<p>
<spanclass="bold"><strong>It is best to define these macros in the project options,
via <codeclass="computeroutput"><spanclass="special">-</span><spanclass="identifier">D</span></code>
on the command line, or as the first line in the translation unit (.cpp file)
where <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> is used.</strong></span>
Not following this rule can lead to obscure errors when a header includes
<codeclass="computeroutput"><spanclass="identifier">mem_fn</span><spanclass="special">.</span><spanclass="identifier">hpp</span></code> before the macro has been defined.
</p>
<p>
<spanclass="emphasis"><em>[Note:</em></span> this is a non-portable extension. It is not part
of the interface.<spanclass="emphasis"><em>]</em></span>
</p>
<p>
<spanclass="emphasis"><em>[Note:</em></span> Some compilers provide only minimal support for
the <codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code> keyword.<spanclass="emphasis"><em>]</em></span>
Rene Jager's initial suggestion of using traits classes to make <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> adapt to user-defined smart pointers
inspired the <codeclass="computeroutput"><spanclass="identifier">get_pointer</span></code>-based
design.
</li>
<liclass="listitem">
Numerous improvements were suggested during the formal review period by
Richard Crossley, Jens Maurer, Ed Brey, and others. Review manager was
Darin Adler.
</li>
<liclass="listitem">
Steve Anichini pointed out that COM interfaces use <codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code>.
</li>
<liclass="listitem">
Dave Abrahams modified <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
and <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> to support
<codeclass="computeroutput"><spanclass="keyword">void</span></code> returns on deficient
compilers.
</li>
<liclass="listitem">
Daniel Boelzle pointed out that UDK uses <codeclass="computeroutput"><spanclass="identifier">__cdecl</span></code>.
</li>
</ul></div>
<p>
This documentation was ported to Quickbook by Agustín Bergé.
