Question

对于下面的程序代码，我必须在接收rvalue和lvalue引用的成员函数对中编写相同的代码。

我的目标是只使用一对中的一个（例如;仅使用接受rvalue的那个），以及其他。我阅读了std::forward的参考资料，据我所知，它看起来就像是为了这个目的。但是，当我删除左值引用时，我得到以下编译器错误。

＆＃39; TestClass :: TestClass（const TestClass＆amp;）＆＃39;：无法从＆＃39; std :: wstring＆＃39;转换参数1到＆＃39; std :: wstring＆amp;＆amp;＆＃39;

如何防止此代码重复？

#include <iostream>
#include <string>

class TestClass
{
    public:
        TestClass(const std::wstring    &  Text)
            : Text(Text)
        {
            std::wcout << L"LValue Constructor : " << Text << std::endl;
            /*Some code here...*/
        }
        TestClass(      std::wstring    && Text)
            : Text(std::forward<std::wstring>(Text))
        {
            std::wcout << L"RValue Constructor : " << this->Text << std::endl;
            /*Same code here...*/
        }
        TestClass(const TestClass       &  Another)
            : Text(Another.Text)
        {
            std::wcout << L"Copy   Constructor : " << Text << std::endl;
            /*Some code here...*/
        }
        TestClass(      TestClass       && Another)
            : Text(std::forward<std::wstring>(Another.Text))
        {
            std::wcout << L"Move   Constructor : " << Text << std::endl;
            /*Same code here...*/
        }

    private:
        std::wstring Text;
};

int wmain(int argc, wchar_t *argv[], wchar_t *envp[])
{
    std::wstring Argument(L"Testing Copy");
    TestClass Class1Copy(Argument);
    TestClass Class1Move(L"Testing Move");
    TestClass Class2Copy(Class1Copy);
    TestClass Class2Move(std::move(Class1Move));

    _wsystem(L"pause");
    return 0;
}

输出：

LValue Constructor : Testing Copy  
RValue Constructor : Testing Move  
Copy   Constructor : Testing Copy  
Move   Constructor : Testing Move  
Press any key to continue . . .

Answer 1

您可以按值，然后move。那么您只需要N次重载，而不是2N：

TestClass(std::wstring Text)
    : Text(std::move(Text))
{
}

你可以通过什么都不写来避免复制构造函数和移动构造函数复制;在这种情况下，编译器将默认生成它们。

Answer 2

如果预计移动构造非常便宜，您可以按价值并从价值移动。这比一对复制和移动重载完全相同。

如果你想要最佳效率，和/或如果移动构造更便宜但便宜足以忽略，你可以转发：

template<class T>
std::decay_t<T> copy(T&& t) {
  return std::forward<T>(t);
}
class TestClass {
public:
  TestClass(std::wstring const&  Text)
    TestClass( copy(Text) )
  {}
  TestClass(TestClass const& o)
    : TestClass( o.Text )
  {}
  TestClass(TestClass&& o)
    : TestClass( std::move(o).Text ) // pattern does the right thing more often than `std::move(o.Text)` does.
  {}
  // only "real" ctor:
  TestClass( std::wstring&& Text)
    : Text(std::forward<std::wstring>(Text))
  {
    std::wcout << L"RValue Constructor : " << this->Text << std::endl;
    /*Code here...*/
  }
// ...

现在一切都转发给一个构造函数。

你甚至可以混合使用这两种技术：对std::wstring使用by-value（因为我们知道移动便宜）并为TestClass代码转发内容（或任何不太可能的东西）保持稳定。）

Answer 3

我认为你不能这样做，因为函数的签名决定了它们的使用时间和地点。它就像copy constructor和assignment operator。它们有点类似类似的东西，但编译器在上下文中调用适当的一个基础。

如果您想避免重复使用代码，只需将共性分解为单独的函数。

如何防止rvalue和lvalue成员函数之间的代码重复？

3 个答案: