Databases
StackOverflow2013
Postsdbo
PO
 

Note that there are some explanatory texts on larger screens.

plurals
  1. PO
    primarykey
    data
    text
    <p>I also think there is no direct way to define the template parameters and function arguments of a single, primary template definition such that <code>T</code> can be deduced in all the different situations (function pointer, lambda expression, <code>std::function</code> argument etc.).</p> <p>I would therefore recommend that you follow the approach suggested at the end of your question. Indeed neither <code>std::function</code> nor the tools offered by Boost (as far as I know) will easily enable this, though.</p> <p>What I use (and I learnt that from other SO posts in the past), is a rather complicated template <code>function_traits</code> with specializations for all the different cases. My definition is this:</p> <pre><code>template &lt;typename T&gt; struct function_traits : public function_traits&lt;decltype(&amp;T::operator())&gt; { }; template &lt;typename Return, typename... Args&gt; struct function_traits&lt;Return(Args...)&gt; { typedef std::size_t size_type; typedef Return result_type; typedef result_type function_type(Args...); static constexpr size_type arity = sizeof...(Args); template &lt;size_type index&gt; struct arg { typedef typename std::tuple_element&lt;index,std::tuple&lt;Args...&gt;&gt;::type type; }; static constexpr bool value = true; }; template &lt;typename Return, typename... Args&gt; struct function_traits&lt;Return(*)(Args...)&gt; : function_traits&lt;Return(Args...)&gt; { }; template &lt;typename Return, typename... Args&gt; struct function_traits&lt;Return(&amp;)(Args...)&gt; : function_traits&lt;Return(Args...)&gt; { }; template &lt;typename Class, typename Return, typename... Args&gt; struct function_traits&lt;Return(Class::*)(Args...)&gt; : function_traits&lt;Return(Args...)&gt; { }; template &lt;typename Class, typename Return, typename... Args&gt; struct function_traits&lt;Return(Class::*)(Args...) volatile&gt; : function_traits&lt;Return(Args...)&gt; { }; template &lt;typename Class, typename Return, typename... Args&gt; struct function_traits&lt;Return(Class::*)(Args...) const&gt; : function_traits&lt;Return(Args...)&gt; { }; template &lt;typename Class, typename Return, typename... Args&gt; struct function_traits&lt;Return(Class::*)(Args...) const volatile&gt; : function_traits&lt;Return(Args...)&gt; { }; </code></pre> <p>To make using this even more convenient, you may want to define <code>using</code>-aliases:</p> <pre><code>template &lt;typename Fun&gt; using result_of = typename function_traits&lt;Fun&gt;::result_type; template &lt;typename Fun, std::size_t index&gt; using arg = typename function_traits&lt;Fun&gt;::template arg&lt;index&gt;::type; </code></pre> <p>With all these definitions (which in the below, I assume you put into a separate header <code>more_type_traits.hpp</code>), you can then easily define your wrapper function as follows:</p> <pre><code>#include &lt;iostream&gt; #include &lt;functional&gt; #include &lt;type_traits&gt; #include "more_type_traits.hpp" template &lt;typename Fun&gt; using noref = typename std::remove_reference&lt;Fun&gt;::type; template &lt;typename Fun&gt; result_of&lt;noref&lt;Fun&gt;&gt; fun(Fun &amp;&amp;argfun) { // Default-initialize the first argument arg&lt;noref&lt;Fun&gt;,0&gt; arg {}; // Call the function return argfun(arg); } </code></pre> <p>The below (which is basically copied from your code) then compiles and works for me:</p> <pre><code>void f1(int i) { std::cout &lt;&lt; "f1(" &lt;&lt; i &lt;&lt; ')' &lt;&lt; std::endl; } struct f2_t { void operator()(int i) { std::cout &lt;&lt; "f2(" &lt;&lt; i &lt;&lt; ')' &lt;&lt; std::endl; } }; int main() { fun(f1); f2_t f2; fun(f2); std::function&lt;void(int)&gt; funobj = [](int i) { std::cout &lt;&lt; "funobj(" &lt;&lt; i &lt;&lt; ')' &lt;&lt; std::endl; }; fun(funobj); fun( [](int i) { std::cout &lt;&lt; "lambda(" &lt;&lt; i &lt;&lt; ')' &lt;&lt; std::endl; } ); return 0; } </code></pre> <p>Clearly, the definition of <code>function_traits</code> is complicated, because many different specializations are required. But it's worth the effort if you want to make function wrapping convenient.</p>
    singulars
    1. This table or related slice is empty.
    1. POFunctions and functors as arguments to template functions
      singulars
      1. PTQuestion
    1. PTAnswer
    1. This table or related slice is empty.
    1. USjogojapan
    plurals
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    2. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTDownMod
    3. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    1. COThis `function_traits` is not complicated enough. It is less general than `std::result_of`
      singulars
      1. PO
      1. USR. Martinho Fernandes
    2. CO@R.MartinhoFernandes I didn't say it's perfect. What parts are missing anyway?
      singulars
      1. PO
      1. USjogojapan
    3. COMy point is not about it being perfect but about it not being more generally applicable than `std::result_of` which leads me to "why would I ever use this instead of std::result_of?" To see what it misses see k-ballo's answer or any polymorphic function object like `std::greater <>`. I don't see a point in making life way harder for users of those just to gain... I'm not sure what.
      singulars
      1. PO
      1. USR. Martinho Fernandes
 

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.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload