blocks|key|1030279|text|您可以创建一个卫士类，在销毁时自动为您调用pop_back：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1030280|template+<typename+T>
class+push_pop_guard
{
private:
++++std::vector<T>&+_v;

public:
++++template+<typename+Item>
++++push_pop_guard(std::vector<T>&+v,+Item&&+x)+:+_v{v}+
++++{+
++++++++_v.push_back(std::forward<Item>(x));
++++}

++++~push_pop_guard()
++++{
++++++++_v.pop_back();
++++}
};|code-block|syntax|javascript|1030281|用法示例：|1030282|void+function(std::vector+<int>+vec)
{
++++{
++++++++push_pop_guard+ppg{vec,+0};
++++++++function(vec);
++++}

++++//+...
}|1030283|entityMap^0|L|8|0|0|0|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|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

You could create a guard class that calls <code>pop_back</code> automatically for you on destruction:

<pre><code>template &lt;typename T&gt;
class push_pop_guard
{
private:
 std::vector&lt;T&gt;&amp; _v;

public:
 template &lt;typename Item&gt;
 push_pop_guard(std::vector&lt;T&gt;&amp; v, Item&amp;&amp; x) : _v{v} 
 { 
 _v.push_back(std::forward&lt;Item&gt;(x));
 }

 ~push_pop_guard()
 {
 _v.pop_back();
 }
};
</code></pre>

Usage example:

<pre><code>void function(std::vector &lt;int&gt; vec)
{
 {
 push_pop_guard ppg{vec, 0};
 function(vec);
 }

 // ...
}
</code></pre>

blocks|key|520171|text|我发现你所拥有的已经相当可读的了。只有两点我会改进。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|520172|首先，通过引用传递向量，避免重复拷贝。|520173|其次，为了保持回溯不变，您仍然需要维护pop_back。但你可以把它移到一个不那么尴尬的地方：|offset|length|style|CODE|520174|void+function(std::vector<int>+&vec){
++++vec.push_back(0);+//+Initial+modification
++++function(vec);
++++vec.back()+=+1;+++//+Second+modification
++++function(vec);
++++vec.pop_back();+++//+Return+to+previous+state
++++return;
}|code-block|syntax|javascript|520175|因为函数会弹出它推送的整数，所以我们可以肯定，vec.back()是调用之间的整数。所以你可以做简单的任务，而不是另一对弹出和推。|520176|entityMap^0|0|0|J|8|0|0|N|A|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@$F|V|G|W|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|X|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|Y|8|@$F|Z|G|10|H|I]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

I find that what you have is already fairly readable. There's only two points I would improve on.

First and foremost, pass the vector by reference, avoid the redundant copies.

Secondly, and to maintain the backtracking invariant, you'll still need to maintain the <code>pop_back</code>. But you can move it to a less awkward place:

<pre><code>void function(std::vector&lt;int&gt; &amp;vec){
 vec.push_back(0); // Initial modification
 function(vec);
 vec.back() = 1; // Second modification
 function(vec);
 vec.pop_back(); // Return to previous state
 return;
}
</code></pre>

Because the function pops out the very integer it pushed, we may be certain that <code>vec.back()</code> is that integer between calls. So you can do simple assignment instead of another pair of pop and push.

blocks|key|520184|text|您可以将值传递给该方法，并在以后将其推送到向量：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|520185|void+function(std::vector+<int>+vec,+int+element){
++++vec.push_back(element);
++++//Do+stuff
++++function(vec,0);
++++function(vec,1);

++++return;
}|code-block|syntax|javascript|520186|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|$]]

You can pass the value to the method and push it to vector later:

<pre><code>void function(std::vector &lt;int&gt; vec, int element){
 vec.push_back(element);
 //Do stuff
 function(vec,0);
 function(vec,1);

 return;
}
</code></pre>

blocks|key|1030335|text|template<class+F>
struct+scope_guard_t+{
++std::optional<F>+f;
++scope_guard_t(+F+in+):f(std::move(f))+{}
++scope_guard_t(+scope_guard_t&&+o+):
++++f(std::move(o.f))
++{
++++o.clear();
++}
++void+abandon()+{+clear();+}
++void+commit_early()+{+commit();+clear();+}
++~scope_guard_t()+{+commit();+}
private:
++void+commit()+{+if(f)+(*f)();+}
++void+clear()+{+f+=+std::nullopt;+}
};
template<class+F>
scope_guard_t<F>+scope_guard(+F+in+)+{+return+{std::move(in)};+}

template<class+C,+class+T>
auto+temp_push(+C&+c,+T&&+t+)+{
++c.push_back(+std::forward<T>(t)+);+//+do
++return+scope_guard(
++++[&]{+c.pop_back();+}+//+undo
++);
}
void+function(std::vector+<int>+vec){
++{
++++auto+scope+=+temp_push(+vec,+0+);
++++function(vec);
++}

++{
++++auto+scope+=+temp_push(+vec,+1+);
++++function(vec);
++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1030336|std::optional可以在c%2B%2B14和以前用boost::optional代替。|unstyled|offset|length|style|CODE|1030337|scope_guard通常是有用的。|1030338|我还将通过传递引用来替换按值传递的vector；这可能会更有效，因为它避免了为每个递归重新分配它。|1030339|entityMap|0|LINK|mutability|MUTABLE|url|/questions/tagged/c%252b%252b14^0|0|0|D|P|F|G|5|0|0|0|B|0|H|6|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|X|8|@$G|Y|H|Z|I|J]|$G|10|H|11|I|J]]|9|@$G|12|H|13|1|14]]|A|$]]|$1|K|3|L|5|F|7|15|8|@$G|16|H|17|I|J]]|9|@]|A|$]]|$1|M|3|N|5|F|7|18|8|@$G|19|H|1A|I|J]]|9|@]|A|$]]|$1|O|3|-4|5|F|7|1B|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

<pre><code>template&lt;class F&gt;
struct scope_guard_t {
 std::optional&lt;F&gt; f;
 scope_guard_t( F in ):f(std::move(f)) {}
 scope_guard_t( scope_guard_t&amp;&amp; o ):
 f(std::move(o.f))
 {
 o.clear();
 }
 void abandon() { clear(); }
 void commit_early() { commit(); clear(); }
 ~scope_guard_t() { commit(); }
private:
 void commit() { if(f) (*f)(); }
 void clear() { f = std::nullopt; }
};
template&lt;class F&gt;
scope_guard_t&lt;F&gt; scope_guard( F in ) { return {std::move(in)}; }

template&lt;class C, class T&gt;
auto temp_push( C&amp; c, T&amp;&amp; t ) {
 c.push_back( std::forward&lt;T&gt;(t) ); // do
 return scope_guard(
 [&amp;]{ c.pop_back(); } // undo
 );
}
void function(std::vector &lt;int&gt; vec){
 {
 auto scope = temp_push( vec, 0 );
 function(vec);
 }

 {
 auto scope = temp_push( vec, 1 );
 function(vec);
 }
}
</code></pre>

<code>std::optional</code> can be replaced with <code>boost::optional</code> in <a href="/questions/tagged/c%2b%2b14" class="post-tag" title="show questions tagged &#39;c++14&#39;" rel="tag">c++14</a> and before.

<code>scope_guard</code> is generally useful.

I'd also replace the <code>vector</code> being passed by value by passing by reference; that can be much more efficient, as it avoids reallocating it for each recursion.

In a backtracking problem, I am required to pass a vector to a function in such a way that the vector is modified at each level:

<pre><code>void function(std::vector &lt;int&gt; vec){
 vec.push_back(0); // Initial modification
 function(vec);

 vec.pop_back(); // Return to previous state

 vec.push_back(1); // Second modification
 function(vec);

 return;
}
</code></pre>

I've omitted extraneous code. 

Is there any way to simplify the vector modification so that I don't have to pop_back afterwards?

Pass a temporarily modified vector to a function

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在回溯问题中，我必须将向量传递给函数，以便在每个级别上修改该向量：void function(std::vector <int> vec){ vec.push_back(0); // Initial modification function(vec); vec.pop_back(); // Retu...

问将临时修改的向量传递给函数
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将临时修改的向量传递给函数EN