blocks|key|3240838|text|它们不是函数指针。这就是std::function存在的目的。它包装了您给它的任何可调用类型。你应该检查一下boost::bind-它通常用于使成员函数指针可调用为(this，args)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3240839|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

They're not function pointers. That's what std::function exists for. It wraps whatever callable types you give it. You should check out boost::bind- it's often used to make member function pointers callable as (this, args).

blocks|key|3026701|text|它是如何做到的(我相信)还没有定义(但我这里没有标准的副本)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3026702|但是考虑到需要涵盖的所有不同的可能性，我有一种感觉，破译它如何工作的确切定义将非常困难:所以我不打算尝试。|3026703|但我想你会想知道函数器是如何工作的，而且它们相对简单。这里有一个简单的例子。|3026704|函数式：|3026705|这些对象的行为类似于函数。|3026706|它们在模板代码中非常有用，因为它们通常允许您互换使用对象或函数。不过，函数器的伟大之处在于，它们可以保持状态(一种穷人的闭包)。|3026707|struct+X
{
+++++int+operator()(int+x)+{+return+doStuff(x%2B1);}
+++++int+doStuff(int+x)++++{+return+x%2B1;}
};

X+++x;++//+You+can+now+use+x+like+a+function
int++a+=+x(5);|code-block|syntax|javascript|3026708|您可以利用functor保持状态的事实来保持参数、对象或指向成员方法的指针(或它们的任意组合)。|3026709|struct+Y+//+Hold+a+member+function+pointer
{
++++int+(X::*member)(int+x);
++++int+operator(X*+obj,+int+param)+{+return+(obj->*member)(param);}
};
X++x;
Y++y;
y.member+=+&X::doStuff;
int+a+=+y(&x,5);|3026710|或者甚至更进一步，绑定参数。所以现在您需要提供的只是其中一个参数。|3026711|struct+Z
{
++++int+(X::*member)(int+x);
++++int++param;
++++Z(int+(X::*m)(int),+int+p)+:+member(m),+param(p)+{}

++++int+operator()(X*+obj)++{+return+(obj->*member)(param);}
++++int+operator()(X&+obj)++{+return+(obj.*member)(param);}
};

Z+z(&X::doStuff,5);

X+x;
int+a+=+z(x);|3026712|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|15|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|16|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|18|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|N|7|1A|8|@]|9|@]|A|$O|P]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

How it does it (I believe) is left undefined (but I don't have a copy of the standard here).
But given all the different possibilities that need to be covered I have the feeling that deciphering the exact definition of how it works would be really hard: So I am not going to try.
But I think you would like to know how functors work and they are relatively simple. So here is a quick example.
<h3>Functors:</h3>
These are objects that act like functions. 
They are very useful in template code as they often allow you to use objects or functions interchangeably. The great thing about functors though is that they can hold state (a sort of poor man's closure).
<pre><code>struct X
{
 int operator()(int x) { return doStuff(x+1);}
 int doStuff(int x) { return x+1;}
};

X x; // You can now use x like a function
int a = x(5);
</code></pre>
You can use the fact that functor hold state to hold things like parameters or the objects or the pointer to member methods (or any combination thereof).
<pre><code>struct Y // Hold a member function pointer
{
 int (X::*member)(int x);
 int operator(X* obj, int param) { return (obj-&gt;*member)(param);}
};
X x;
Y y;
y.member = &amp;X::doStuff;
int a = y(&amp;x,5);
</code></pre>
Or even go further and bind parameters. So now all you need to provide is one of the parameters.
<pre><code>struct Z
{
 int (X::*member)(int x);
 int param;
 Z(int (X::*m)(int), int p) : member(m), param(p) {}

 int operator()(X* obj) { return (obj-&gt;*member)(param);}
 int operator()(X&amp; obj) { return (obj.*member)(param);}
};

Z z(&amp;X::doStuff,5);

X x;
int a = z(x);
</code></pre>

blocks|key|299143|text|g%2B%2B似乎有一个联合，可以保留函数指针、成员指针或空指针，这些指针可能指向一个函数器。添加重载，适当地标记哪个联合成员是有效的，并将大量的强制转换添加到汤中，然后它就可以工作了……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|299144|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

g++ seems to have an union which may keep either function pointer, member pointer or void pointer which probably points to a functor. Add overloads which appropriately flag which union member is valid and heavy casting to a soup and then it works...

blocks|key|299783|text|在获得了其他答案和评论的帮助，并阅读了GCC源代码和C%2B%2B11标准后，我发现可以使用部分模板专门化和函数重载来解析函数类型(它的返回类型和参数类型)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|299784|下面是一个简单的(不完整的)示例，用于实现类似于std::function的东西|CODE|299785|template<class+T>+class+Function+{+};

//+Parse+the+function+type
template<class+Res,+class+Obj,+class...+ArgTypes>
class+Function<Res+(Obj*,+ArgTypes...)>+{
++++union+Pointers+{
++++++++Res+(*func)(Obj*,+ArgTypes...);
++++++++Res+(Obj::*mem_func)(ArgTypes...);
++++};

++++typedef+Res+Callback(Pointers&,+Obj&,+ArgTypes...);

++++Pointers+ptrs;
++++Callback*+callback;

++++static+Res+call_func(Pointers&+ptrs,+Obj&+obj,+ArgTypes...+args)+{
++++++++return+(*ptrs.func)(&obj,+args...);
++++}

++++static+Res+call_mem_func(Pointers&+ptrs,+Obj&+obj,+ArgTypes...+args)+{
++++++++return+(obj.*(ptrs.mem_func))(args...);
++++}

++public:

++++Function()+:+callback(0)+{+}

++++//+Parse+the+function+type
++++Function(Res+(*func)(Obj*,+ArgTypes...))+{
++++++++ptrs.func+=+func;
++++++++callback+=+&call_func;
++++}

++++//+Parse+the+function+type
++++Function(Res+(Obj::*mem_func)(ArgTypes...))+{
++++++++ptrs.mem_func+=+mem_func;
++++++++callback+=+&call_mem_func;
++++}

++++Function(const+Function&+function)+{
++++++++ptrs+=+function.ptrs;
++++++++callback+=+function.callback;
++++}

++++Function&+operator=(const+Function&+function)+{
++++++++ptrs+=+function.ptrs;
++++++++callback+=+function.callback;
++++++++return+*this;
++++}

++++Res+operator()(Obj&+obj,+ArgTypes...+args)+{
++++++++if(callback+==+0)+throw+0;+//+throw+an+exception
++++++++return+(*callback)(ptrs,+obj,+args...);
++++}
};|code-block|syntax|javascript|299786|用法：|299787|#include+<iostream>

struct+Funny+{
++++void+print(int+i)+{
++++++++std::cout+<<+"void+(Funny::*)(int):+"+<<+i+<<+std::endl;
++++}
};

void+print(Funny*+funny,+int+i)+{
++++std::cout+<<+"void+(*)(Funny*,+int):+"+<<+i+<<+std::endl;
}

int+main(int+argc,+char**+argv)+{
++++Funny+funny;
++++Function<void(Funny*,+int)>+wmw;

++++wmw+=+&Funny::print;+//+void+(Funny::*)(int)
++++wmw(funny,+10);+//+void+(Funny::*)(int)

++++wmw+=+&print;+//+void+(*)(Funny*,+int)
++++wmw(funny,+8);+//+void+(*)(Funny*,+int)

++++return+0;
}|299788|entityMap^0|16|7|1E|4|0|O|D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@$9|Z|A|10|B|H]]|D|@]|E|$]]|$1|I|3|J|5|K|7|11|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|6|7|12|8|@]|D|@]|E|$]]|$1|P|3|Q|5|K|7|13|8|@]|D|@]|E|$L|M]]|$1|R|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|S|$]]

After getting help from other answers and comments, and reading GCC source code and C++11 standard, I found that it is possible to parse a function type (its return type and its argument types) by using partial template specialization and 
function overloading.

The following is a simple (and incomplete) example to implement something like <code>std::function</code>:

<pre><code>template&lt;class T&gt; class Function { };

// Parse the function type
template&lt;class Res, class Obj, class... ArgTypes&gt;
class Function&lt;Res (Obj*, ArgTypes...)&gt; {
 union Pointers {
 Res (*func)(Obj*, ArgTypes...);
 Res (Obj::*mem_func)(ArgTypes...);
 };

 typedef Res Callback(Pointers&amp;, Obj&amp;, ArgTypes...);

 Pointers ptrs;
 Callback* callback;

 static Res call_func(Pointers&amp; ptrs, Obj&amp; obj, ArgTypes... args) {
 return (*ptrs.func)(&amp;obj, args...);
 }

 static Res call_mem_func(Pointers&amp; ptrs, Obj&amp; obj, ArgTypes... args) {
 return (obj.*(ptrs.mem_func))(args...);
 }

 public:

 Function() : callback(0) { }

 // Parse the function type
 Function(Res (*func)(Obj*, ArgTypes...)) {
 ptrs.func = func;
 callback = &amp;call_func;
 }

 // Parse the function type
 Function(Res (Obj::*mem_func)(ArgTypes...)) {
 ptrs.mem_func = mem_func;
 callback = &amp;call_mem_func;
 }

 Function(const Function&amp; function) {
 ptrs = function.ptrs;
 callback = function.callback;
 }

 Function&amp; operator=(const Function&amp; function) {
 ptrs = function.ptrs;
 callback = function.callback;
 return *this;
 }

 Res operator()(Obj&amp; obj, ArgTypes... args) {
 if(callback == 0) throw 0; // throw an exception
 return (*callback)(ptrs, obj, args...);
 }
};
</code></pre>

Usage:

<pre><code>#include &lt;iostream&gt;

struct Funny {
 void print(int i) {
 std::cout &lt;&lt; "void (Funny::*)(int): " &lt;&lt; i &lt;&lt; std::endl;
 }
};

void print(Funny* funny, int i) {
 std::cout &lt;&lt; "void (*)(Funny*, int): " &lt;&lt; i &lt;&lt; std::endl;
}

int main(int argc, char** argv) {
 Funny funny;
 Function&lt;void(Funny*, int)&gt; wmw;

 wmw = &amp;Funny::print; // void (Funny::*)(int)
 wmw(funny, 10); // void (Funny::*)(int)

 wmw = &amp;print; // void (*)(Funny*, int)
 wmw(funny, 8); // void (*)(Funny*, int)

 return 0;
}
</code></pre>

blocks|key|3026814|text|回答标题中的问题。std::function使用的参数是一个很好的技巧，可以将多个类型参数作为一个模板参数进行传递。这些参数是函数的参数类型和返回类型。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3026815|事实证明，std::function试图擦除一个通用函数器的类型，但这只是巧合。|3026816|事实上，曾几何时，有些编译器不会接受这样的技巧，而boost::function的前身有一种可移植的语法，所有参数都可以通过它单独传递：|BOLD|3026817|3026818|首选语法|blockquote|3026819|3026820|boost::function+sum_avg；|3026821|可移植的语法|3026822|boost::function4+sum_avg；|3026823|3026824|https://www.boost.org/doc/libs/1_68_0/doc/html/function/tutorial.html#id-1.3.16.5.4|3026825|这就是std::function的模板参数是如何工作的，最后，这只是一个技巧，让很多参数看起来像一个函数调用。指向该类型函数的函数指针不一定包含在类中。|3026826|entityMap|0|LINK|mutability|MUTABLE|url^0|9|D|0|5|D|0|P|F|1A|4|0|0|0|0|0|0|0|0|0|2B|0|0|3|D|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|J]]|D|@]|E|$]]|$1|K|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1J|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1L|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1M|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1N|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1P|8|@]|D|@$9|1Q|A|1R|1|1S]]|E|$]]|$1|Y|3|Z|5|6|7|1T|8|@$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]]|11|$12|$5|13|14|15|E|$16|X]]]]

To answer the question in the title. The parameter that <code>std::function</code> uses is a nice trick to pass many type parameters as a single template parameter. Those arguments being the argument types and the return type of a function. 

It turns out that <code>std::function</code> tries to type-erase a general functor but that is just coincidence.

As a matter of fact, once upon a time there were compilers that wouldn't accept such tricks and the <code>boost::function</code> precursor had a portable syntax by which all the parameters could be passed separately:

<blockquote>
 Preferred syntax

<pre><code>boost::function&lt;void(int*, int, int&amp;, float&amp;)&gt; sum_avg;
</code></pre>
 
 Portable syntax

<pre><code>boost::function4&lt;void, int*, int, int&amp;, float&amp;&gt; sum_avg;
</code></pre>
</blockquote>

<a href="https://www.boost.org/doc/libs/1_68_0/doc/html/function/tutorial.html#id-1.3.16.5.4" rel="nofollow noreferrer">https://www.boost.org/doc/libs/1_68_0/doc/html/function/tutorial.html#id-1.3.16.5.4</a>

So that's how the template parameters of <code>std::function</code> work, at the end it is just a trick to make a lot of parameters look like a function call. Function pointers to that type of function are not necessarily involved in the class.

In Bjarne Stroustrup's home page (<a href="http://www.stroustrup.com/C++11FAQ.html#std-function" rel="noreferrer">C++11 FAQ</a>):

<pre><code>struct X { int foo(int); };

std::function&lt;int(X*, int)&gt; f;
f = &amp;X::foo; //pointer to member

X x;
int v = f(&amp;x, 5); //call X::foo() for x with 5
</code></pre>

How does it work? How does std::function call a foo member function?

The template parameter is <code>int(X*, int)</code>, is <code>&amp;X::foo</code> converted from the member function pointer to a non-member function pointer?!

<pre><code>(int(*)(X*, int))&amp;X::foo //casting (int(X::*)(int) to (int(*)(X*, int))
</code></pre>

<hr>

To clarify: I know that we don't need to cast any pointer to use std::function, but I don't know how the internals of std::function handle this incompatibility between a member function pointer and a non-member function pointer. I don't know how the standard allows us to implement something like std::function!

How does the template parameter of std::function work? (implementation)

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在Bjarne Stroustrup的主页()中：struct X { int foo(int); };std::function<int(X*, int)> f;f = &X::foo; //pointer to memberX x;int v = f(&x, 5); //call X::foo() for x wi...

问std::function的模板参数是如何工作的？(实现)
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问std::function的模板参数是如何工作的？(实现)EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问std::function的模板参数是如何工作的？(实现)
EN