blocks|key|3271331|text|要使第二个选项起作用，请声明foo，以便编译器知道它是一个类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3271332|还要注意，您的函数指针语法是不正确的。*恰好出现在变量名称之前：|offset|length|style|CODE|3271333|class+foo;

class+bar
{
public:
++++void+(foo::*funcP)();
};|code-block|syntax|javascript|3271334|entityMap^0|0|J|1|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

To make your second option work, declare foo so the compiler knows that it is a class.

Also note that your function pointer syntax is incorrect. The <code>*</code> comes just before the name of the variable:

<pre><code>class foo;

class bar
{
public:
 void (foo::*funcP)();
};
</code></pre>

blocks|key|3058025|text|在bar前面转发foo的声明：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3058026|class+foo;|code-block|syntax|javascript|3058027|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

forward foo's declaration in front of bar:

<pre><code>class foo;
</code></pre>

blocks|key|317522|text|正如错误所说，方法属于类，而不是单个实例。因此，指向自由函数的指针和指向非静态方法的指针是完全不同的。您还需要一个实例来调用该方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|317523|//declaring+and+taking+the+address+of+a+foo's+method+
void+(foo::*method)()+=+&foo::hello;+//as+the+compiler+nicely+suggests

//calling+a+function+through+pointer
free_func();

//calling+a+method+through+pointer
foo+instance;
(instance.*method)();|code-block|syntax|javascript|317524|您可以使用诸如Boost.Bind和Boost.Function+(我认为也在std::tr1中)这样的库来抽象这些差异，还可以将一个实例绑定到该方法：|offset|length|317525|#include+<iostream>
#include+<boost/bind.hpp>
#include+<boost/function.hpp>

using+namespace+std;

class+foo
{
public:
++++void+hello(){cout+<<+"hello"+<<+endl;};
};

void+byebye()
{
++++cout+<<+"bye"+<<+endl;
}


int+main()
{
++++foo+testFoo;

++++boost::function<void()>+helloFunc(boost::bind(&foo::hello,+testFoo));
++++boost::function<void()>+byeFunc(byebye);

++++helloFunc();
++++byeFunc();
++++return+0;
}|317526|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_42_0/libs/bind/bind.html|1|http://www.boost.org/doc/libs/1_42_0/doc/html/function.html^0|0|0|7|A|0|I|E|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@$I|Z|J|10|1|11]|$I|12|J|13|1|14]]|A|$]]|$1|K|3|L|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]]]

As the error says, methods belong to the class, not to individual instances. For this reason pointers to free functions and pointers to non-static methods are completely different things. You'll also need an instance to call the method on.

<pre><code>//declaring and taking the address of a foo's method 
void (foo::*method)() = &amp;foo::hello; //as the compiler nicely suggests

//calling a function through pointer
free_func();

//calling a method through pointer
foo instance;
(instance.*method)();
</code></pre>

You can use libraries like <a href="http://www.boost.org/doc/libs/1_42_0/libs/bind/bind.html" rel="noreferrer">Boost.Bind</a> and <a href="http://www.boost.org/doc/libs/1_42_0/doc/html/function.html" rel="noreferrer">Boost.Function</a> (also in std::tr1 I think) to abstract away the difference and also bind an instance to the method:

<pre><code>#include &lt;iostream&gt;
#include &lt;boost/bind.hpp&gt;
#include &lt;boost/function.hpp&gt;

using namespace std;

class foo
{
public:
 void hello(){cout &lt;&lt; "hello" &lt;&lt; endl;};
};

void byebye()
{
 cout &lt;&lt; "bye" &lt;&lt; endl;
}


int main()
{
 foo testFoo;

 boost::function&lt;void()&gt; helloFunc(boost::bind(&amp;foo::hello, testFoo));
 boost::function&lt;void()&gt; byeFunc(byebye);

 helloFunc();
 byeFunc();
 return 0;
}
</code></pre>

blocks|key|3058129|text|综合每个人的建议，你的最终解决方案将如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3058130|#include+<iostream>+
using+std::cout;
usind+std::endl;

class+foo;+//+tell+the+compiler+there's+a+foo+out+there.

class+bar+
{+
public:+
++++//+If+you+want+to+store+a+pointer+to+each+type+of+function+you'll
++++//+need+two+different+pointers+here:
++++void+(*freeFunctionPointer)();
++++void+(foo::*memberFunctionPointer)();
};+

class+foo+
{+
public:+
++++bar+myBar;+
++++void+hello(){+cout+<<+"hello"+<<+endl;+}
};+

void+byebye()+
{+
++++cout+<<+"bye"+<<+endl;+
}+


int+main()+
{+
++++foo+testFoo;+

++++testFoo.myBar.freeFunctionPointer+=+&byebye;
++++testFoo.myBar.memberFunctionPointer+=+&foo::hello;

++++((testFoo).*(testFoo.myBar.memberFunctionPointer))();+//+calls+foo::hello()
++++testFoo.myBar.freeFunctionPointer();+++//+calls+byebye()
++++return+0;+
}+|code-block|syntax|javascript|3058131|C%2B%2B+FAQ+Lite对如何简化语法提供了一些指导。|offset|length|3058132|将Chris的想法付诸实践，你可以得到这样的东西：|3058133|#include+<iostream>
using+std::cout;+using+std::endl;

class+foo;
typedef+void+(*FreeFn)();
typedef+void+(foo::*MemberFn)();

class+bar
{
public:
++bar()+:+freeFn(NULL),+memberFn(NULL)+{}
++void+operator()(foo*+other)
++{
++++if+(freeFn+!=+NULL)+{+freeFn();+}
++++else+if+(memberFn+!=+NULL)+{+((other)->*(memberFn))();+}
++++else+{+cout+<<+"No+function+attached!"+<<+endl;+}
++}

++void+setFreeFn(FreeFn+value)+{+freeFn+=+value;+memberFn+=+NULL;+}
++void+setMemberFn(MemberFn+value)+{+memberFn+=+value;+freeFn+=+NULL;+}
private:
++FreeFn+freeFn;
++MemberFn+memberFn;
};

class+foo
{
public:
++bar+myBar;
++void+hello()+{+cout+<<+"foo::hello()"+<<+endl;+}
++void+operator()()+{+myBar(this);+}
};

void+bye()+{+cout+<<+"bye()"+<<+endl;+}

int+main()
{
++foo+testFoo;

++testFoo();

++testFoo.myBar.setMemberFn(&foo::hello);
++testFoo();

++testFoo.myBar.setFreeFn(&bye);
++testFoo();

++return+0;
}|3058134|entityMap|0|LINK|mutability|MUTABLE|url|http://www.parashift.com/c%2B%2B-faq-lite/pointers-to-members.html#faq-33.5^0|0|0|0|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@$I|Z|J|10|1|11]]|A|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Taking everyone's suggestions together, your final solution will look like:

<pre><code>#include &lt;iostream&gt; 
using std::cout;
usind std::endl;

class foo; // tell the compiler there's a foo out there.

class bar 
{ 
public: 
 // If you want to store a pointer to each type of function you'll
 // need two different pointers here:
 void (*freeFunctionPointer)();
 void (foo::*memberFunctionPointer)();
}; 

class foo 
{ 
public: 
 bar myBar; 
 void hello(){ cout &lt;&lt; "hello" &lt;&lt; endl; }
}; 

void byebye() 
{ 
 cout &lt;&lt; "bye" &lt;&lt; endl; 
} 


int main() 
{ 
 foo testFoo; 

 testFoo.myBar.freeFunctionPointer = &amp;byebye;
 testFoo.myBar.memberFunctionPointer = &amp;foo::hello;

 ((testFoo).*(testFoo.myBar.memberFunctionPointer))(); // calls foo::hello()
 testFoo.myBar.freeFunctionPointer(); // calls byebye()
 return 0; 
} 
</code></pre>

The <a href="http://www.parashift.com/c++-faq-lite/pointers-to-members.html#faq-33.5" rel="noreferrer">C++ FAQ Lite</a> has some guidance on how to simplify the syntax.

Taking Chris' idea and running with it, you could get yourself something like this:

<pre><code>#include &lt;iostream&gt;
using std::cout; using std::endl;

class foo;
typedef void (*FreeFn)();
typedef void (foo::*MemberFn)();

class bar
{
public:
 bar() : freeFn(NULL), memberFn(NULL) {}
 void operator()(foo* other)
 {
 if (freeFn != NULL) { freeFn(); }
 else if (memberFn != NULL) { ((other)-&gt;*(memberFn))(); }
 else { cout &lt;&lt; "No function attached!" &lt;&lt; endl; }
 }

 void setFreeFn(FreeFn value) { freeFn = value; memberFn = NULL; }
 void setMemberFn(MemberFn value) { memberFn = value; freeFn = NULL; }
private:
 FreeFn freeFn;
 MemberFn memberFn;
};

class foo
{
public:
 bar myBar;
 void hello() { cout &lt;&lt; "foo::hello()" &lt;&lt; endl; }
 void operator()() { myBar(this); }
};

void bye() { cout &lt;&lt; "bye()" &lt;&lt; endl; }

int main()
{
 foo testFoo;

 testFoo();

 testFoo.myBar.setMemberFn(&amp;foo::hello);
 testFoo();

 testFoo.myBar.setFreeFn(&amp;bye);
 testFoo();

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

I have a problem with using a pointer to function in C++. Here is my example:

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

using namespace std;

class bar
{
public:
 void (*funcP)();
};

class foo
{
public:
 bar myBar;
 void hello(){cout &lt;&lt; "hello" &lt;&lt; endl;};
};

void byebye()
{
 cout &lt;&lt; "bye" &lt;&lt; endl;
}


int main()
{
 foo testFoo;

 testFoo.myBar.funcP = &amp;byebye; //OK
 testFoo.myBar.funcP = &amp;testFoo.hello; //ERROR
 return 0;
}
</code></pre>

Compilator returns an error at <code>testFoo.myBar.funcP = &amp;testFoo.hello;</code>:

<blockquote>
 ISO C++ forbids taking the address of a bound member function to form a
 pointer to member function. Say
 '&amp;foo::hello'
 
 cannot convert 'void (foo::)()' to 'void ()()' in assignment
</blockquote>

So i tried it like this:

<pre><code>class bar
{
public:
 void (*foo::funcP)();
};
</code></pre>

But now the compilator adds one more:

<blockquote>
 'foo' has not been declared
</blockquote>

Is there a way make it work?

Thanks in advance for suggestions

Passing member function pointer to member object in c++

编译器

在C++中使用指向函数的指针有问题。下面是我的例子：#include <iostream>using namespace std;class bar{public: void (*funcP)();};class foo{public: bar myBar; void hello(){cout << ...

问将成员函数指针传递到c++中的成员对象
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将成员函数指针传递到c++中的成员对象EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将成员函数指针传递到c++中的成员对象
EN