entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://en.wikipedia.org/wiki/Copy_elision|blocks|key|bj827|text|这是一个非常笨拙且不可扩展的解决方案，但它非常简短，而且它支持RVO，这对于一些返回类型可能很重要：|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|atosk|template+<typename+F>
auto+wrapAndRun(F+fn)+->+decltype(F())+{
++++//+foo();
++++char+c;
++++auto+runner+=+std::unique_ptr<char,+decltype(bar)>(+&c,+bar+);
++++try+{
++++++++return+fn();
++++}
++++catch(+...+)+{
++++++++runner.release();
++++++++throw;
++++}
}|code-block|syntax|javascript|eqfs5^0|V|3|0|0|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|Q|G|@]|H|@$I|R|J|S|A|T]]|6|$]]|$A|K|C|L|2|M|F|U|G|@]|H|@]|6|$N|O]]|$A|P|C|-4|2|E|F|V|G|@]|H|@]|6|$]]]]

This is pretty awkward and not extendable solution but very short and simple and it supports <a href="https://en.wikipedia.org/wiki/Copy_elision" rel="nofollow noreferrer">RVO</a> which could be significant for some return types:

<pre><code>template &lt;typename F&gt;
auto wrapAndRun(F fn) -&gt; decltype(F()) {
 // foo();
 char c;
 auto runner = std::unique_ptr&lt;char, decltype(bar)&gt;( &amp;c, bar );
 try {
 return fn();
 }
 catch( ... ) {
 runner.release();
 throw;
 }
}
</code></pre>

entityMap|blocks|key|1ps61|text|您可以编写一个简单的包装类来处理其中的这一部分：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|6thjt|template+<class+T>
struct+CallAndStore+{
++++template+<class+F>
++++CallAndStore(F+f)+:+t(f())+{}
++++T+t;
++++T+get()+{+return+std::forward<T>(t);+}
};|code-block|syntax|javascript|2l5p4|和专门化：|e0t3e|template+<>
struct+CallAndStore<void>+{
++++template+<class+F>
++++CallAndStore(F+f)+{+f();+}
++++void+get()+{}
};|8f9br|你可以通过一个小的工厂函数来提高可用性：|29u9c|template+<typename+F>
auto+makeCallAndStore(F&&+f)+->+CallAndStore<decltype(std::declval<F>()())>+{
++++return+{std::forward<F>(f)};
}|d3mn2|那就用它吧。|dvpsu|template+<typename+F>
auto+wrapAndRun(F+fn)+{
++++//+foo();
++++auto&&+result+=+makeCallAndStore(std::move(fn));
++++//+bar();
++++return+result.get();
}|1t4e5|编辑:使用get中的std::forward强制转换，这似乎也可以正确地处理从函数返回引用。|offset|length|style|CODE|9pbbh^0|0|0|0|0|0|0|0|0|5|3|A|C|0^^$0|$]|1|@$2|3|4|5|6|7|8|10|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|11|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|12|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|13|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|14|9|@]|A|@]|B|$]]|$2|N|4|O|6|E|8|15|9|@]|A|@]|B|$F|G]]|$2|P|4|Q|6|7|8|16|9|@]|A|@]|B|$]]|$2|R|4|S|6|E|8|17|9|@]|A|@]|B|$F|G]]|$2|T|4|U|6|7|8|18|9|@$V|19|W|1A|X|Y]|$V|1B|W|1C|X|Y]]|A|@]|B|$]]|$2|Z|4|-4|6|7|8|1D|9|@]|A|@]|B|$]]]]

You can write a simple wrapper class that handles this part of it:

<pre><code>template &lt;class T&gt;
struct CallAndStore {
 template &lt;class F&gt;
 CallAndStore(F f) : t(f()) {}
 T t;
 T get() { return std::forward&lt;T&gt;(t); }
};
</code></pre>

And specialize:

<pre><code>template &lt;&gt;
struct CallAndStore&lt;void&gt; {
 template &lt;class F&gt;
 CallAndStore(F f) { f(); }
 void get() {}
};
</code></pre>

You can improve usability with a small factory function:

<pre><code>template &lt;typename F&gt;
auto makeCallAndStore(F&amp;&amp; f) -&gt; CallAndStore&lt;decltype(std::declval&lt;F&gt;()())&gt; {
 return {std::forward&lt;F&gt;(f)};
}
</code></pre>

Then use it.

<pre><code>template &lt;typename F&gt;
auto wrapAndRun(F fn) {
 // foo();
 auto&amp;&amp; result = makeCallAndStore(std::move(fn));
 // bar();
 return result.get();
}
</code></pre>

Edit: with the <code>std::forward</code> cast inside <code>get</code>, this also seems to handle returning a reference from a function correctly.

entityMap|0|type|LINK|mutability|MUTABLE|data|url|http://coliru.stacked-crooked.com/a/e84ff8f74b3b6051|blocks|key|enf4s|text|使用SFINAE的解决方案，其想法是使内部的void函数实际上返回int+-希望编译器会优化这一点。在外部，wrapAndRun将返回与包装函数相同的类型。|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|baupm|b9a72|#include+<iostream>

template+<typename+F>
auto+wrapAndRun1(F+fn)+->+std::enable_if_t<!std::is_same_v<std::result_of_t<F()>,+void>,+std::result_of_t<F()>>+{
++++return+fn();
}


template+<typename+F>
auto+wrapAndRun1(F+fn)+->+std::enable_if_t<std::is_same_v<std::result_of_t<F()>,+void>,+int>+{
++++fn();
++++return+0;
}

template+<typename+F>
auto+wrapAndRun(F+fn)+->+std::result_of_t<F()>+{
++++//+foo();
++++[[maybe_unused]]+auto+result+=+wrapAndRun1(fn);++++
++++//+bar();++++++++
++++if+constexpr+(std::is_void_v<std::result_of_t<F()>>)
++++++++return;
++++else
++++++++return+result;
}

int+main()
{
++++wrapAndRun([]+{+std::cout+<<+"with+return+\n";+return+0;+});
++++wrapAndRun([]+{+std::cout+<<+"no+return+\n";+});
}|code-block|syntax|javascript|337cc^0|1I|A|0|0|1G|0|0|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|T|G|@$H|U|I|V|J|K]]|L|@]|6|$]]|$A|M|C|8|2|E|F|W|G|@]|L|@$H|X|I|Y|A|Z]]|6|$]]|$A|N|C|O|2|P|F|10|G|@]|L|@]|6|$Q|R]]|$A|S|C|-4|2|E|F|11|G|@]|L|@]|6|$]]]]

Solution with SFINAE, the idea is to make internally a void function actually return int - hopefully the compiler will optimize this away. On outside <code>wrapAndRun</code> will return the same type as a wrapped function.

<a href="http://coliru.stacked-crooked.com/a/e84ff8f74b3b6051" rel="nofollow noreferrer">http://coliru.stacked-crooked.com/a/e84ff8f74b3b6051</a>

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

template &lt;typename F&gt;
auto wrapAndRun1(F fn) -&gt; std::enable_if_t&lt;!std::is_same_v&lt;std::result_of_t&lt;F()&gt;, void&gt;, std::result_of_t&lt;F()&gt;&gt; {
 return fn();
}


template &lt;typename F&gt;
auto wrapAndRun1(F fn) -&gt; std::enable_if_t&lt;std::is_same_v&lt;std::result_of_t&lt;F()&gt;, void&gt;, int&gt; {
 fn();
 return 0;
}

template &lt;typename F&gt;
auto wrapAndRun(F fn) -&gt; std::result_of_t&lt;F()&gt; {
 // foo();
 [[maybe_unused]] auto result = wrapAndRun1(fn); 
 // bar(); 
 if constexpr (std::is_void_v&lt;std::result_of_t&lt;F()&gt;&gt;)
 return;
 else
 return result;
}

int main()
{
 wrapAndRun([] { std::cout &lt;&lt; "with return \n"; return 0; });
 wrapAndRun([] { std::cout &lt;&lt; "no return \n"; });
}
</code></pre>

entityMap|blocks|key|cjn8n|text|在这里，新的C%2B%2B17+if+constexpr添加可能会有所帮助。您可以选择是否在编译时返回fn()的结果：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|9it1o|#include+<type_traits>

template+<typename+F>
auto+wrapAndRun(F+fn)+->+decltype(fn())
{
++++if+constexpr+(std::is_same_v<decltype(fn()),+void>)
++++{
++++++++foo();
++++++++fn();
++++++++bar();
++++}
++++else
++++{
++++++++foo();
++++++++auto+result+=+fn();
++++++++bar();
++++++++return+result;
++++}
}|code-block|syntax|javascript|47ajt|正如您所说的，C%2B%2B2a也是一个选项，您还可以利用概念，对函数施加约束：|et8db|template+<typename+F>
++requires+requires+(F+fn)+{+{+fn()+}+->+void+}
void+wrapAndRun(F+fn)
{
++++foo();
++++fn();
++++bar();
}

template+<typename+F>
decltype(auto)+wrapAndRun(F+fn)
{
++++foo();
++++auto+result+=+fn();
++++bar();
++++return+result;
}|4p2r^0|C|C|1B|4|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|Q|9|@$A|R|B|S|C|D]|$A|T|B|U|C|D]]|E|@]|F|$]]|$2|G|4|H|6|I|8|V|9|@]|E|@]|F|$J|K]]|$2|L|4|M|6|7|8|W|9|@]|E|@]|F|$]]|$2|N|4|O|6|I|8|X|9|@]|E|@]|F|$J|K]]|$2|P|4|-4|6|7|8|Y|9|@]|E|@]|F|$]]]]

The new C++17 <code>if constexpr</code> addition may be helpful here. You can choose whether to return <code>fn()</code>'s result at compile-time:

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

template &lt;typename F&gt;
auto wrapAndRun(F fn) -&gt; decltype(fn())
{
 if constexpr (std::is_same_v&lt;decltype(fn()), void&gt;)
 {
 foo();
 fn();
 bar();
 }
 else
 {
 foo();
 auto result = fn();
 bar();
 return result;
 }
}
</code></pre>

As you said C++2a is an option as well, you could also make use of concepts, putting a constraint on the function:

<pre><code>template &lt;typename F&gt;
 requires requires (F fn) { { fn() } -&gt; void }
void wrapAndRun(F fn)
{
 foo();
 fn();
 bar();
}

template &lt;typename F&gt;
decltype(auto) wrapAndRun(F fn)
{
 foo();
 auto result = fn();
 bar();
 return result;
}
</code></pre>

entityMap|blocks|key|emr67|text|另一个技巧可能是利用逗号运算符，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4oo4b|struct+or_void+{};

template<typename+T>
T&&+operator,(+T&&+x,+or_void+){+return+std::forward<T>(x);+}

template+<typename+F>
auto+wrapAndRun(F+fn)+->+decltype(fn())+{
++++//+foo();
++++auto+result+=+(+fn(),+or_void()+);
++++//+bar();
++++return+decltype(fn())(result);
}|code-block|syntax|javascript|dnnnq^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|I|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|J|9|@]|A|@]|B|$F|G]]|$2|H|4|-4|6|7|8|K|9|@]|A|@]|B|$]]]]

Another trick might be to exploit the comma operator, something like:

<pre><code>struct or_void {};

template&lt;typename T&gt;
T&amp;&amp; operator,( T&amp;&amp; x, or_void ){ return std::forward&lt;T&gt;(x); }

template &lt;typename F&gt;
auto wrapAndRun(F fn) -&gt; decltype(fn()) {
 // foo();
 auto result = ( fn(), or_void() );
 // bar();
 return decltype(fn())(result);
}
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://github.com/facebook/folly/blob/master/folly/ScopeGuard.h|blocks|key|17eqf|text|你可以看看Alexandrescu的ScopeGuard：ScopeGuard.h它只在没有异常的时候执行代码。|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|b6qdh|template<class+Fn>
decltype(auto)+wrapAndRun(Fn&&+f)+{
++foo();
++SCOPE_SUCCESS{+bar();+};+//Only+executed+at+scope+exit+when+there+are+no+exceptions.
++return+std::forward<Fn>(f)();
}|code-block|syntax|javascript|7iu58|所以在没有错误的情况下，执行顺序是:1.foo()，2.f()，3.bar()。在出现异常的情况下，顺序是:1.foo()，2.f()|6mb22^0|T|C|0|0|0|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|S|G|@]|H|@$I|T|J|U|A|V]]|6|$]]|$A|K|C|L|2|M|F|W|G|@]|H|@]|6|$N|O]]|$A|P|C|Q|2|E|F|X|G|@]|H|@]|6|$]]|$A|R|C|-4|2|E|F|Y|G|@]|H|@]|6|$]]]]

You can have a look at the ScopeGuard by Alexandrescu: <a href="https://github.com/facebook/folly/blob/master/folly/ScopeGuard.h" rel="noreferrer">ScopeGuard.h</a> It executes code only when there was no exception.

<pre><code>template&lt;class Fn&gt;
decltype(auto) wrapAndRun(Fn&amp;&amp; f) {
 foo();
 SCOPE_SUCCESS{ bar(); }; //Only executed at scope exit when there are no exceptions.
 return std::forward&lt;Fn&gt;(f)();
}
</code></pre>

So in case of no errors, the execution order is: 1. foo(), 2. f(), 3. bar(). And in case of an exception the order is: 1. foo(), 2. f()

I have C++ code that wraps an arbitrary lambda and returns the result of the lambda.
<pre><code>template &lt;typename F&gt;
auto wrapAndRun(F fn) -&gt; decltype(F()) {
 // foo();
 auto result = fn();
 // bar();
 return result;
}
</code></pre>
This works unless <code>F</code> returns <code>void</code> (<code>error: variable has incomplete type 'void'</code>). I thought of using a <code>ScopeGuard</code> to run <code>bar</code>, but I don't want <code>bar</code> to run if <code>fn</code> throws. Any ideas?
P.S. I found out later there's <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0146r1.html" rel="nofollow noreferrer">a proposal to fix this inconsistency</a>.

Handling void assignment in C++ generic programming

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有包装任意lambda并返回lambda结果的C++代码。 template <typename F>auto wrapAndRun(F fn) -> decltype(F()) { // foo(); auto result = fn(); // bar(); return result;...

问在C++泛型编程中处理无效赋值
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++泛型编程中处理无效赋值EN