StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
4868535
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
2
CommunityOwnedDate
CreationDate
2011-02-01T22:09:36.833
FavoriteCount
0
LastActivityDate
2011-02-02T23:24:05
LastEditDate
2011-02-02T23:24:05
LastEditorUserId
196844
OwnerUserId
196844
ParentId
4855219
PostTypeId
2
Score
1
ViewCount
0
LastEditorDisplayName
text
Body
I think that the only technique which will work perfectly is to write a C wrapper function for each member function that you wish to invoke within a C callback; i.e.: <pre><code>extern "C" void Foo_x(Foo *foo) { foo->x(); } extern "C" void Foo_x1(Foo *foo, int i) { foo->x1(i); } </code></pre> You could also use lambda expressions of C++0x, which implicitly convert to a pointer to function having the same parameter and return types as the closure type’s function call operator. But, keep in mind that the language linkage of the function type is "C++", not "C". <pre><code>#include <cstdlib> #include <iostream> using namespace std; struct Foo { void x() { cout << "Foo::x()" << endl; } void x1(int i) { cout << "Foo::x1(" <x(); }; fn(&foo); f1_t fn1 = [] (Foo *foo, int i) { foo->x1(i); }; fn1(&foo, 314); return EXIT_SUCCESS; } </code></pre> Note that Section 5.2.2, Function call, of the C++ Standard states: <blockquote> Calling a function through an expression whose function type has a language linkage that is different from the language linkage of the function type of the called function’s definition is undefined. </blockquote> So the following technically invokes undefined behavior: <pre><code>extern "C" typedef void (*f_t)(Foo*); int main() { Foo foo; f_t fn = [] (Foo *foo) { foo->x(); }; fn(&foo); // `fn` is a pointer to a function that uses "C++" language linkage, // but it is erroneously called through "C" language linkage. //... </code></pre> EDIT: After a bit of experimentation, I came up with the following template functions which return lambdas that call the given member function: <pre><code>template <typename return_t, class base, typename... arg_types> std::function<return_t (base*, arg_types...)> make_lambda_to_call_member_function(return_t (base::*mem_fn)(arg_types...)) { return [mem_fn] (base *o, arg_types... args) -> return_t { (o->*mem_fn)(args...); }; } template <typename return_t, class base, typename... arg_types> std::function<return_t (const base*, arg_types...)> make_lambda_to_call_member_function(return_t (base::*cmem_fn)(arg_types...) const) { return [cmem_fn] (const base *o, arg_types... args) -> return_t { (o->*cmem_fn)(args...); }; } </code></pre> If <code>Foo</code> is defined as: <pre><code>struct Foo { void x() { cout << "Foo::x()" << endl; } void x1(int i) { cout << "Foo::x1(" <</pre> Then you use the template <code>make_lambda_to_call_member_function</code> like: <pre><code>auto fn = make_lambda_to_call_member_function(&Foo::x); fn(&foo); auto fn1 = make_lambda_to_call_member_function(&Foo::x1); fn1(&foo, 314); auto fn2 = make_lambda_to_call_member_function(&Foo::cx1); fn2(&foo, 44.832f); </code></pre> Note, however, that the returned lambda objects will not implicitly convert to a function pointer because the lambda expression uses a lambda-capture. The latest draft of C++0x, n3225, states: <blockquote> The closure type for a lambda-expression with no lambda-capture has a public non-virtual non-explicit const conversion function to pointer to function having the same parameter and return types as the closure type's function call operator. The value returned by this conversion function shall be the address of a function that, when invoked, has the same effect as invoking the closure type's function call operator. </blockquote> The following is illegal: <pre><code>void (*fn5)(Foo*) = make_lambda_to_call_member_function(&Foo::x); </code></pre>
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POBinding class member function to c-function
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USDaniel Trebbien
UserOwnerUserId
1. USDaniel Trebbien
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POBinding class member function to c-function
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTAcceptedByOriginator
CommentsPostId
1. COIt's a good point about linkage type. I see a problem with using lambda - all argument types should be fully listed. With template version all types are calculated with compiler. Is it possible to make a template of lambda function, which will take member function as parameter?
 singulars
 PostPostId
 PO
 UserUserId
 USklimkin
2. CO@klimkin: I updated my answer with a lot more information. To answer your question, yes it's possible to write a template function that returns a lambda object that invokes a given member function, but that lambda object can no longer be converted to a function pointer.
 singulars
 PostPostId
 PO
 UserUserId
 USDaniel Trebbien

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.