blocks|key|579636|text|这个例子有帮助吗？我努力寻找一个有用的std::forward的非通用示例，但偶然发现了一个银行帐户的示例，我们将现金作为参数传递给该帐户。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|579637|因此，如果我们有一个常量版本的帐户，当我们将它传递给我们的存款template<>时，我们应该预料到常量函数会被调用；然后这会抛出一个异常(想法是这是一个锁定的帐户！)|579638|如果我们有一个非常数帐户，那么我们应该能够修改帐户。|579639|#include+<iostream>
#include+<string>
#include+<sstream>+//+std::stringstream
#include+<algorithm>+//+std::move
#include+<utility>
#include+<iostream>
#include+<functional>

template<class+T>+class+BankAccount+{
private:
++++const+T+no_cash+{};
++++T+cash+{};
public:
++++BankAccount<T>+()+{
++++++++std::cout+<<+"default+constructor+"+<<+to_string()+<<+std::endl;
++++}
++++BankAccount<T>+(T+cash)+:+cash+(cash)+{
++++++++std::cout+<<+"new+cash+"+<<+to_string()+<<+std::endl;
++++}
++++BankAccount<T>+(const+BankAccount&+o)+{
++++++++std::cout+<<+"copy+cash+constructor+called+for+"+<<+o.to_string()+<<+std::endl;
++++++++cash+=+o.cash;
++++++++std::cout+<<+"copy+cash+constructor+result+is++"+<<+to_string()+<<+std::endl;
++++}
++++//+Transfer+of+funds?
++++BankAccount<T>+(BankAccount<T>&&+o)+{
++++++++std::cout+<<+"move+cash+called+for+"+<<+o.to_string()+<<+std::endl;
++++++++cash+=+o.cash;
++++++++o.cash+=+no_cash;
++++++++std::cout+<<+"move+cash+result+is++"+<<+to_string()+<<+std::endl;
++++}
++++~BankAccount<T>+()+{
++++++++std::cout+<<+"delete+account+"+<<+to_string()+<<+std::endl;
++++}
++++void+deposit+(const+T&+deposit)+{
++++++++cash+%2B=+deposit;
++++++++std::cout+<<+"deposit+cash+called+"+<<+to_string()+<<+std::endl;
++++}
++++friend+int+deposit+(int+cash,+const+BankAccount<int>+&&account)+{
++++++++throw+std::string("tried+to+write+to+a+locked+(const)+account");
++++}
++++friend+int+deposit+(int+cash,+const+BankAccount<int>+&account)+{
++++++++throw+std::string("tried+to+write+to+a+locked+(const)+account");
++++}
++++friend+int+deposit+(int+cash,+BankAccount<int>+&account)+{
++++++++account.deposit(cash);
++++++++return+account.cash;
++++}
++++friend+std::ostream&+operator<<(std::ostream+&os,+const+BankAccount<T>&+o)+{
++++++++os+<<+"$"+<<+std::to_string(o.cash);
++++++++return+os;
++++}
++++std::string+to_string+(void)+const+{
++++++++auto+address+=+static_cast<const+void*>(this);
++++++++std::stringstream+ss;
++++++++ss+<<+address;
++++++++return+"BankAccount("+%2B+ss.str()+%2B+",+cash+$"+%2B+std::to_string(cash)+%2B+")";
++++}
};

template<typename+T,+typename+Account>
int+process_deposit(T+cash,+Account&&+b)+{
++++return+deposit(cash,+std::forward<Account>(b));
}

int+main(int,+char**)
{
++++try+{
++++++++//+create+account1+and+try+to+deposit+into+it
++++++++auto+account1+=+BankAccount<int>(0);
++++++++process_deposit<int>(100,+account1);
++++++++std::cout+<<+account1.to_string()+<<+std::endl;
++++++++std::cout+<<+"SUCCESS:+account1+deposit+succeeded!"+<<+std::endl;
++++}+catch+(const+std::string+&e)+{
++++++++std::cerr+<<+"FAILED:+account1+deposit+failed!:+"+<<+e+<<+std::endl;
++++}

++++try+{
++++++++//+create+locked+account2+and+try+to+deposit+into+it;+this+should+fail
++++++++const+auto+account2+=+BankAccount<int>(0);
++++++++process_deposit<int>(100,+account2);
++++++++std::cout+<<+account2.to_string()+<<+std::endl;
++++++++std::cout+<<+"SUCCESS:+account2+deposit+succeeded!"+<<+std::endl;
++++}+catch+(const+std::string+&e)+{
++++++++std::cerr+<<+"FAILED:+account2+deposit+failed!:+"+<<+e+<<+std::endl;
++++}

++++try+{
++++++++//+create+locked+account3+and+try+to+deposit+into+it;+this+should+fail
++++++++auto+account3+=+BankAccount<int>(0);
++++++++process_deposit<int>(100,+std::move(account3));
++++++++std::cout+<<+account3.to_string()+<<+std::endl;
++++++++std::cout+<<+"SUCCESS:+account3+deposit+succeeded!"+<<+std::endl;
++++}+catch+(const+std::string+&e)+{
++++++++std::cerr+<<+"FAILED:+account3+deposit+failed!:+"+<<+e+<<+std::endl;
++++}
}|code-block|syntax|javascript|579640|要构建：|579641|cd+std_forward
rm+-f+*.o+example
c%2B%2B+-std=c%2B%2B2a+-Werror+-g+-ggdb3+-Wall+-c+-o+main.o+main.cpp
c%2B%2B+main.o++-o+example
./example|579642|预期输出：|579643|#+create+account1+and+try+to+deposit+into+it
new+cash+BankAccount(0x7ffee68d96b0,+cash+$0)
deposit+cash+called+BankAccount(0x7ffee68d96b0,+cash+$100)
BankAccount(0x7ffee68d96b0,+cash+$100)
#+SUCCESS:+account1+deposit+succeeded!
delete+account+BankAccount(0x7ffee68d96b0,+cash+$100)

#+create+locked+account2+and+try+to+deposit+into+it;+this+should+fail
new+cash+BankAccount(0x7ffee68d9670,+cash+$0)
delete+account+BankAccount(0x7ffee68d9670,+cash+$0)
#+FAILED:+account2+deposit+failed!:+tried+to+write+to+a+locked+(const)+account

#+create+locked+account3+and+try+to+deposit+into+it;+this+should+fail
new+cash+BankAccount(0x7ffee68d9630,+cash+$0)
delete+account+BankAccount(0x7ffee68d9630,+cash+$0)
#+FAILED:+account3+deposit+failed!:+tried+to+write+to+a+locked+(const)+account|579644|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Does this example help? I struggled to find a useful non generic example of std::forward, but hit upon an example of a bank account that we pass along
the cash to be deposited as an argument.

So if we have a const version of an account we should expect when we pass it to our deposit template&lt;> that the const function is called; and this then throws an exception (the idea being this was a locked account!)

If we have a non const account then we should be able to modify the account.

<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;sstream&gt; // std::stringstream
#include &lt;algorithm&gt; // std::move
#include &lt;utility&gt;
#include &lt;iostream&gt;
#include &lt;functional&gt;

template&lt;class T&gt; class BankAccount {
private:
 const T no_cash {};
 T cash {};
public:
 BankAccount&lt;T&gt; () {
 std::cout &lt;&lt; "default constructor " &lt;&lt; to_string() &lt;&lt; std::endl;
 }
 BankAccount&lt;T&gt; (T cash) : cash (cash) {
 std::cout &lt;&lt; "new cash " &lt;&lt; to_string() &lt;&lt; std::endl;
 }
 BankAccount&lt;T&gt; (const BankAccount&amp; o) {
 std::cout &lt;&lt; "copy cash constructor called for " &lt;&lt; o.to_string() &lt;&lt; std::endl;
 cash = o.cash;
 std::cout &lt;&lt; "copy cash constructor result is " &lt;&lt; to_string() &lt;&lt; std::endl;
 }
 // Transfer of funds?
 BankAccount&lt;T&gt; (BankAccount&lt;T&gt;&amp;&amp; o) {
 std::cout &lt;&lt; "move cash called for " &lt;&lt; o.to_string() &lt;&lt; std::endl;
 cash = o.cash;
 o.cash = no_cash;
 std::cout &lt;&lt; "move cash result is " &lt;&lt; to_string() &lt;&lt; std::endl;
 }
 ~BankAccount&lt;T&gt; () {
 std::cout &lt;&lt; "delete account " &lt;&lt; to_string() &lt;&lt; std::endl;
 }
 void deposit (const T&amp; deposit) {
 cash += deposit;
 std::cout &lt;&lt; "deposit cash called " &lt;&lt; to_string() &lt;&lt; std::endl;
 }
 friend int deposit (int cash, const BankAccount&lt;int&gt; &amp;&amp;account) {
 throw std::string("tried to write to a locked (const) account");
 }
 friend int deposit (int cash, const BankAccount&lt;int&gt; &amp;account) {
 throw std::string("tried to write to a locked (const) account");
 }
 friend int deposit (int cash, BankAccount&lt;int&gt; &amp;account) {
 account.deposit(cash);
 return account.cash;
 }
 friend std::ostream&amp; operator&lt;&lt;(std::ostream &amp;os, const BankAccount&lt;T&gt;&amp; o) {
 os &lt;&lt; "$" &lt;&lt; std::to_string(o.cash);
 return os;
 }
 std::string to_string (void) const {
 auto address = static_cast&lt;const void*&gt;(this);
 std::stringstream ss;
 ss &lt;&lt; address;
 return "BankAccount(" + ss.str() + ", cash $" + std::to_string(cash) + ")";
 }
};

template&lt;typename T, typename Account&gt;
int process_deposit(T cash, Account&amp;&amp; b) {
 return deposit(cash, std::forward&lt;Account&gt;(b));
}

int main(int, char**)
{
 try {
 // create account1 and try to deposit into it
 auto account1 = BankAccount&lt;int&gt;(0);
 process_deposit&lt;int&gt;(100, account1);
 std::cout &lt;&lt; account1.to_string() &lt;&lt; std::endl;
 std::cout &lt;&lt; "SUCCESS: account1 deposit succeeded!" &lt;&lt; std::endl;
 } catch (const std::string &amp;e) {
 std::cerr &lt;&lt; "FAILED: account1 deposit failed!: " &lt;&lt; e &lt;&lt; std::endl;
 }

 try {
 // create locked account2 and try to deposit into it; this should fail
 const auto account2 = BankAccount&lt;int&gt;(0);
 process_deposit&lt;int&gt;(100, account2);
 std::cout &lt;&lt; account2.to_string() &lt;&lt; std::endl;
 std::cout &lt;&lt; "SUCCESS: account2 deposit succeeded!" &lt;&lt; std::endl;
 } catch (const std::string &amp;e) {
 std::cerr &lt;&lt; "FAILED: account2 deposit failed!: " &lt;&lt; e &lt;&lt; std::endl;
 }

 try {
 // create locked account3 and try to deposit into it; this should fail
 auto account3 = BankAccount&lt;int&gt;(0);
 process_deposit&lt;int&gt;(100, std::move(account3));
 std::cout &lt;&lt; account3.to_string() &lt;&lt; std::endl;
 std::cout &lt;&lt; "SUCCESS: account3 deposit succeeded!" &lt;&lt; std::endl;
 } catch (const std::string &amp;e) {
 std::cerr &lt;&lt; "FAILED: account3 deposit failed!: " &lt;&lt; e &lt;&lt; std::endl;
 }
}
</code></pre>

To build:

<pre><code>cd std_forward
rm -f *.o example
c++ -std=c++2a -Werror -g -ggdb3 -Wall -c -o main.o main.cpp
c++ main.o -o example
./example
</code></pre>

Expected output:

<pre><code># create account1 and try to deposit into it
new cash BankAccount(0x7ffee68d96b0, cash $0)
deposit cash called BankAccount(0x7ffee68d96b0, cash $100)
BankAccount(0x7ffee68d96b0, cash $100)
# SUCCESS: account1 deposit succeeded!
delete account BankAccount(0x7ffee68d96b0, cash $100)

# create locked account2 and try to deposit into it; this should fail
new cash BankAccount(0x7ffee68d9670, cash $0)
delete account BankAccount(0x7ffee68d9670, cash $0)
# FAILED: account2 deposit failed!: tried to write to a locked (const) account

# create locked account3 and try to deposit into it; this should fail
new cash BankAccount(0x7ffee68d9630, cash $0)
delete account BankAccount(0x7ffee68d9630, cash $0)
# FAILED: account3 deposit failed!: tried to write to a locked (const) account
</code></pre>

C++0x shows an example of using <code>std::forward</code>:

<pre><code>template&lt;class T&gt;
void foo(T&amp;&amp; arg) 
{
 bar(std::forward&lt;T&gt;(arg));
}
</code></pre>

When is it advantageous to use <code>std::forward</code>, always?

Also, it requires to use <code>&amp;&amp;</code> in the parameters declaration, is it valid in all cases? I thought you had to pass temporaries to a function if the function was declared with <code>&amp;&amp;</code> in it, so can foo be called with any parameter?

Lastly, if I have a function call such as this:

<pre><code>template&lt;int val, typename... Params&gt;
void doSomething(Params... args) {
 doSomethingElse&lt;val, Params...&gt;(args...);
}
</code></pre>

Should I use this instead:

<pre><code>template&lt;int val, typename... Params&gt;
void doSomething(Params&amp;&amp;... args) {
 doSomethingElse&lt;val, Params...&gt;(std::forward&lt;Params&gt;(args)...);
}
</code></pre>

Also, if use the parameters twice in the function, i.e. forwarding to two functions at the same time, is it wise to use <code>std::forward</code>? Won't <code>std::forward</code> convert the same thing to a temporary twice, moving the memory and make it invalid for a second use? Would the following code be ok:

<pre><code>template&lt;int val, typename... Params&gt;
void doSomething(Params&amp;&amp;... args) {
 doSomethingElse&lt;val, Params...&gt;(std::forward&lt;Params&gt;(args)...);
 doSomethingWeird&lt;val, Params...&gt;(std::forward&lt;Params&gt;(args)...);
}
</code></pre>

I'm a bit confused by <code>std::forward</code>, and I'd gladly use some clearing up.

When to use std::forward to forward arguments?

C++0x显示了一个使用std::forward的示例template<class T>void foo(T&& arg) { bar(std::forward<T>(arg));}什么时候总是使用std::forward是有利的？另外，它需要在参数声明中使用&&，它在所有情况下都有效吗？我认为如果函数中声明了&&，...

问什么时候使用std::forward来转发参数？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候使用std::forward来转发参数？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候使用std::forward来转发参数？
EN