blocks|key|3950791|text|如果您可以将“一些泛型内容”放在bar类的析构函数中(在安全的try/catch块中，如果您不确定这不会抛出异常，正如Drax所指出的那样)，那么您可以简单地编写|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3950792|template+<typename+F>
auto+foo+(F+&&f)
+{
+++bar+b;

+++return+std::forward<F>(f)(/*some+args*/);
+}|code-block|syntax|javascript|3950793|因此，编译器计算f(/*some+args*/)，执行b的析构函数，并返回计算值(或不返回任何值)。|3950794|注意到return+func();是完全合法的，其中func()是返回void的函数。|3950795|entityMap^0|G|3|0|0|8|G|R|1|0|3|E|Q|6|Z|4|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|P|$]]

if you can place the "some generic stuff" in the destructor of a <code>bar</code> class (inside a security try/catch block, if you're not sure that doesn't throw exceptions, as pointed by Drax), you can simply write

<pre><code>template &lt;typename F&gt;
auto foo (F &amp;&amp;f)
 {
 bar b;

 return std::forward&lt;F&gt;(f)(/*some args*/);
 }
</code></pre>

So the compiler compute <code>f(/*some args*/)</code>, exec the destructor of <code>b</code> and return the computed value (or nothing).

Observe that <code>return func();</code>, where <code>func()</code> is a function returning <code>void</code>, is perfectly legal.

blocks|key|3946874|text|在某些地方，一些专业化是必要的。但这里的目标是避免专门化函数本身。但是，您可以专门化帮助器类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3946875|使用带有-std=c%2B%2B17的gcc+9.1进行了测试。|offset|length|style|CODE|3946876|#include+<type_traits>
#include+<iostream>

template<typename+T>
struct+return_value+{


++++T+val;

++++template<typename+F,+typename+...Args>
++++return_value(F+&&f,+Args+&&+...args)
++++++++:+val{f(std::forward<Args>(args)...)}
++++{
++++}

++++T+value()+const
++++{
++++++++return+val;
++++}
};

template<>
struct+return_value<void>+{

++++template<typename+F,+typename+...Args>
++++return_value(F+&&f,+Args+&&+...args)
++++{
++++++++f(std::forward<Args>(args)...);
++++}

++++void+value()+const
++++{
++++}
};

template<class+F>
auto+foo(F+&&f)
{
++++return_value<decltype(std::declval<F+&&>()(2,+4))>+r{f,+2,+4};

++++//+Something

++++return+r.value();
}

int+main()
{
++++foo(+[](int+a,+int+b)+{+return;+});

++++std::cout+<<+foo(+[](int+a,+int+b)+{+return+a%2Bb;+})+<<+std::endl;
}|code-block|syntax|javascript|3946877|entityMap^0|0|4|A|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|$]]

Some specialization, somewhere, is necessary. But the goal here is to avoid specializing the function itself. However, you can specialize a helper class.

Tested with gcc 9.1 with <code>-std=c++17</code>.

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

template&lt;typename T&gt;
struct return_value {


 T val;

 template&lt;typename F, typename ...Args&gt;
 return_value(F &amp;&amp;f, Args &amp;&amp; ...args)
 : val{f(std::forward&lt;Args&gt;(args)...)}
 {
 }

 T value() const
 {
 return val;
 }
};

template&lt;&gt;
struct return_value&lt;void&gt; {

 template&lt;typename F, typename ...Args&gt;
 return_value(F &amp;&amp;f, Args &amp;&amp; ...args)
 {
 f(std::forward&lt;Args&gt;(args)...);
 }

 void value() const
 {
 }
};

template&lt;class F&gt;
auto foo(F &amp;&amp;f)
{
 return_value&lt;decltype(std::declval&lt;F &amp;&amp;&gt;()(2, 4))&gt; r{f, 2, 4};

 // Something

 return r.value();
}

int main()
{
 foo( [](int a, int b) { return; });

 std::cout &lt;&lt; foo( [](int a, int b) { return a+b; }) &lt;&lt; std::endl;
}
</code></pre>

blocks|key|3946917|text|在我看来，要做到这一点，最好的方法是实际改变调用可能返回void的函数的方式。基本上，我们将返回void的类改为返回某种类类型Void，也就是说，无论出于何种目的，都是一样的，没有用户会真正关心。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3946918|struct+Void+{+};|code-block|syntax|javascript|3946919|我们所需要做的就是包装调用。下面的代码使用了C%2B%2B17名称(std::invoke和std::invoke_result_t)，但它们都可以在C%2B%2B14中实现，不用太费事：|3946920|//+normal+case:+R+isn't+void
template+<typename+F,+typename...+Args,+
++++typename+R+=+std::invoke_result_t<F,+Args...>,
++++std::enable_if_t<!std::is_void<R>::value,+int>+=+0>
R+invoke_void(F&&+f,+Args&&...+args)+{
++++return+std::invoke(std::forward<F>(f),+std::forward<Args>(args)...);
}

//+special+case:+R+is+void
template+<typename+F,+typename...+Args,+
++++typename+R+=+std::invoke_result_t<F,+Args...>,
++++std::enable_if_t<std::is_void<R>::value,+int>+=+0>
Void+invoke_void(F&&+f,+Args&&...+args)+{
++++//+just+call+it,+since+it+doesn't+return+anything
++++std::invoke(std::forward<F>(f),+std::forward<Args>(args)...);

++++//+and+return+Void
++++return+Void{};
}|3946921|这样做的好处是，你可以直接编写你想要写的代码，以你想要的方式开始：|3946922|template<class+F>
auto+foo(F+&&f)+{
++++auto+result+=+invoke_void(std::forward<F>(f),+/*some+args*/);
++++//do+some+generic+stuff
++++return+result;
}|3946923|而且，您不必将所有逻辑都放在析构函数中，也不必通过专门化来复制所有逻辑。代价是foo([]{})返回Void而不是void，这并不是很大的开销。|3946924|然后，如果Regular+Void被采用，您所要做的就是用std::invoke替换invoke_void。|3946925|entityMap|0|LINK|mutability|MUTABLE|url|https://wg21.link/p0146^0|1C|4|1R|4|0|0|U|B|16|K|0|0|0|0|13|9|1E|4|1L|4|0|T|B|16|B|5|C|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1G|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1P|8|@$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]]|D|@$9|1U|A|1V|1|1W]]|E|$]]|$1|W|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

The best way to do this, in my opinion, is to actually change the way you call your possibly-void-returning functions. Basically, we change the ones that return <code>void</code> to instead return some class type <code>Void</code> that is, for all intents and purposes, the same thing and no users really are going to care.

<pre><code>struct Void { };
</code></pre>

All we need to do is to wrap the invocation. The following uses C++17 names (<code>std::invoke</code> and <code>std::invoke_result_t</code>) but they're all implementable in C++14 without too much fuss:

<pre><code>// normal case: R isn't void
template &lt;typename F, typename... Args, 
 typename R = std::invoke_result_t&lt;F, Args...&gt;,
 std::enable_if_t&lt;!std::is_void&lt;R&gt;::value, int&gt; = 0&gt;
R invoke_void(F&amp;&amp; f, Args&amp;&amp;... args) {
 return std::invoke(std::forward&lt;F&gt;(f), std::forward&lt;Args&gt;(args)...);
}

// special case: R is void
template &lt;typename F, typename... Args, 
 typename R = std::invoke_result_t&lt;F, Args...&gt;,
 std::enable_if_t&lt;std::is_void&lt;R&gt;::value, int&gt; = 0&gt;
Void invoke_void(F&amp;&amp; f, Args&amp;&amp;... args) {
 // just call it, since it doesn't return anything
 std::invoke(std::forward&lt;F&gt;(f), std::forward&lt;Args&gt;(args)...);

 // and return Void
 return Void{};
}
</code></pre>

The advantage of doing it this way is that you can just directly write the code you wanted to write to begin with, in the way you wanted to write it:

<pre><code>template&lt;class F&gt;
auto foo(F &amp;&amp;f) {
 auto result = invoke_void(std::forward&lt;F&gt;(f), /*some args*/);
 //do some generic stuff
 return result;
}
</code></pre>

And you don't have to either shove all your logic in a destructor or duplicate all of your logic by doing specialization. At the cost of <code>foo([]{})</code> returning <code>Void</code> instead of <code>void</code>, which isn't much of a cost.

And then if <a href="https://wg21.link/p0146" rel="noreferrer">Regular Void</a> is ever adopted, all you have to do is swap out <code>invoke_void</code> for <code>std::invoke</code>.

I am in the middle of writing some generic code for a future library. I came across the following problem inside a template function. Consider the code below:

<pre><code>template&lt;class F&gt;
auto foo(F &amp;&amp;f) {
 auto result = std::forward&lt;F&gt;(f)(/*some args*/);
 //do some generic stuff
 return result;
}
</code></pre>

It will work fine, unless I pass to it a function that returns <code>void</code> like:

<pre><code>foo([](){});
</code></pre>

Now, of course, I could use some <code>std::enable_if</code> magic to check the return type and perform specialization for a function returning <code>void</code> that looks like this:

<pre><code>template&lt;class F, class = /*enable if stuff*/&gt;
void foo(F &amp;&amp;f) {
 std::forward&lt;F&gt;(f)(/*some args*/);
 //do some generic stuff
}
</code></pre>

But that would awfully duplicate code for actually logically equivalent functions. Can this be done easily in a generic way for both <code>void</code>-returning and non-<code>void</code>-returning functions in a elegant way?

EDIT:
there is data dependency between function <code>f()</code> and generic stuff I want to do, so I do not take code like this into account: 

<pre><code>template&lt;class F&gt;
auto foo(F &amp;&amp;f) {
 //do some generic stuff
 return std::forward&lt;F&gt;(f)(/*some args*/);
}
</code></pre>

Function argument returning void or non-void type

编译器

我正在为未来的库编写一些泛型代码。我在一个模板函数中遇到了以下问题。考虑下面的代码：template<class F>auto foo(F &&f) { auto result = std::forward<F>(f)(/*some args*/); //do some generic stuff r...

问返回void或非void类型的函数参数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问返回void或非void类型的函数参数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问返回void或非void类型的函数参数
EN