草庐IT

C++0x 右值引用 - 左值-右值绑定(bind)

coder 2023-06-02 原文

这是一个后续问题
C++0x rvalue references and temporaries

在上一个问题中，我问过这段代码应该如何工作:

void f(const std::string &); //less efficient
void f(std::string &&); //more efficient

void g(const char * arg)
{
    f(arg);
}

由于隐式临时性，似乎应该调用移动重载，这发生在 GCC 而不是 MSVC(或 MSVC 的智能感知中使用的 EDG 前端)。

这段代码怎么样？
void f(std::string &&); //NB: No const string & overload supplied

void g1(const char * arg)
{
     f(arg);
}
void g2(const std::string & arg)
{
    f(arg);
}

看来，根据我之前问题的答案，函数 g1是合法的(并且被 GCC 4.3-4.5 接受，但不被 MSVC 接受)。然而，GCC 和 MSVC 都拒绝了 g2因为第 13.3.3.1.4/3 条禁止左值绑定(bind)到右值引用参数。我理解这背后的基本原理 - 在 N2831“使用右值引用修复安全问题”中对此进行了解释。我还认为 GCC 可能正在按照该论文作者的意图实现该条款，因为 GCC 的原始补丁是由其中一位作者(Doug Gregor)编写的。

但是，我不认为这是很直观的。对我来说，(a) const string &在概念上更接近于 string &&比const char * , (b) 编译器可以在 g2 中创建一个临时字符串，好像是这样写的:
void g2(const std::string & arg)
{
    f(std::string(arg));
}

事实上，有时复制构造函数被认为是一个隐式转换操作符。在语法上，这是通过复制构造函数的形式提出的，标准甚至在第 13.3.3.1.2/4 节中特别提到了这一点，其中派生基转换的复制构造函数被赋予比其他用户定义的更高的转换等级转换:

A conversion of an expression of class type to the same class type is given Exact Match rank, and a conversion of an expression of class type to a base class of that type is given Conversion rank, in spite of the fact that a copy/move constructor (i.e., a user-defined conversion function) is called for those cases.



(我假设这在将派生类传递给像 void h(Base) 这样的函数时使用，该函数按值获取基类。)

动机

我提出这个问题的动机类似于 How to reduce redundant code when adding new c++0x rvalue reference operator overloads 中提出的问题。 (“如何在添加新的 c++0x 右值引用运算符重载时减少冗余代码”)。

如果您有一个函数接受许多可能可移动的参数，并且会在可能的情况下移动它们(例如工厂函数/构造函数:Object create_object(string, vector<string>, string) 等)，并且想要适本地移动或复制每个参数，您快速开始编写大量代码。

如果参数类型是可移动的，那么可以只编写一个按值接受参数的版本，如上所述。但是，如果参数是(传统的)不可移动但可交换的类，如 C++03，并且您无法更改它们，那么编写右值引用重载会更有效。

因此，如果左值确实通过隐式拷贝绑定(bind)到右值，那么您可以只编写一个重载，如 create_object(legacy_string &&, legacy_vector<legacy_string> &&, legacy_string &&)它或多或少会像提供右值/左值引用重载的所有组合一样工作——作为左值的实际参数将被复制然后绑定(bind)到参数，作为右值的实际参数将直接绑定(bind)。

澄清/编辑:我意识到这实际上与按值接受可移动类型的参数相同，例如 C++0x std::string 和 std::vector(除了概念上调用移动构造函数的次数)。但是，对于可复制但不可移动的类型，它并不相同，其中包括具有显式定义的复制构造函数的所有 C++03 类。考虑这个例子:
class legacy_string { legacy_string(const legacy_string &); }; //defined in a header somewhere; not modifiable.

void f(legacy_string s1, legacy_string s2); //A *new* (C++0x) function that wants to move from its arguments where possible, and avoid copying
void g() //A C++0x function as well
{
    legacy_string x(/*initialization*/);
    legacy_string y(/*initialization*/);

    f(std::move(x), std::move(y));
}

如 g电话f ，然后 x和 y将被复制 - 我不知道编译器如何移动它们。如 f反而被宣布为服用 legacy_string &&参数，它可以避免调用者显式调用的那些拷贝 std::move在论据上。我不明白这些是如何等效的。

问题

我的问题是:
  • 这是对标准的有效解释吗？无论如何，这似乎不是传统的或预期的。
  • 它具有直观意义吗？
  • 我没有看到这个想法有什么问题吗？似乎您可以在不完全预期的情况下悄悄创建拷贝，但这就是 C++03 中某些地方的现状。此外，它会使一些重载目前不可行，但在实践中我认为这不是问题。
  • 这是一个足够重要的改进，值得做吗？ GCC 的实验性补丁？

    • 最佳答案

    What about this code?


    void f(std::string &&); //NB: No const string & overload supplied

void g2(const std::string & arg)
{
    f(arg);
}

    ...However, GCC and MSVC both reject g2 because of clause 13.3.3.1.4/3, which prohibits lvalues from binding to rvalue ref arguments. I understand the rationale behind this - it is explained in N2831 "Fixing a safety problem with rvalue references". I also think that GCC is probably implementing this clause as intended by the authors of that paper, because the original patch to GCC was written by one of the authors (Doug Gregor)....



    不，这只是两个编译器拒绝您的代码的一半原因。另一个原因是您不能使用引用 const 对象的表达式初始化对非常量的引用。因此，即使在 N2831 之前，这也不起作用。根本不需要转换，因为字符串已经是字符串。看来你想用 string&&喜欢 string .然后，只需编写您的函数 f以便它按值获取字符串。如果你想让编译器创建一个 const 字符串左值的临时拷贝，这样你就可以调用一个带 string&& 的函数。 ，按值或按 rref 获取字符串不会有区别，是吗？

    N2831 与此场景关系不大。

    If you have a function that accepts a number of potentially-moveable arguments, and would move them if it can (e.g. a factory function/constructor: Object create_object(string, vector, string) or the like), and want to move or copy each argument as appropriate, you quickly start writing a lot of code.



    并不真地。为什么要编写大量代码？几乎没有理由用 const& 来弄乱您的所有代码/&&重载。您仍然可以使用一个混合了传值和传引用到常量的单一函数——这取决于您想对参数做什么。至于工厂，想法是使用完美转发:
    template<class T, class... Args>
unique_ptr<T> make_unique(Args&&... args)
{
    T* ptr = new T(std::forward<Args>(args)...);
    return unique_ptr<T>(ptr);
}

    ......一切都很好。一个特殊的模板参数推导规则有助于区分左值和右值参数，并且 std::forward 允许您创建与实际参数具有相同“值”的表达式。所以，如果你写这样的东西:
    string foo();

int main() {
   auto ups = make_unique<string>(foo());
}

    foo 返回的字符串会自动移动到堆中。

    So if lvalues did bind to rvalues via an implicit copy, then you could write just one overload like create_object(legacy_string &&, legacy_vector &&, legacy_string &&) and it would more or less work like providing all the combinations of rvalue/lvalue reference overloads...



    嗯，这几乎等同于按值获取参数的函数。不开玩笑。

    Is this a significant enough improvement that it would be worth making e.g. an experimental patch for GCC?



    没有任何改善。

    关于C++0x 右值引用 - 左值-右值绑定(bind)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/2749263/

    amp43codestringc++c++11rvalue-referencelvalue

    有关C++0x 右值引用 - 左值-右值绑定(bind)的更多相关文章

    1. ruby-on-rails - 如何优雅地重启 thin + nginx？ - 2

      我的瘦服务器配置了nginx，我的ROR应用程序正在它们上运行。在我发布代码更新时运行thinrestart会给我的应用程序带来一些停机时间。我试图弄清楚如何优雅地重启正在运行的Thin实例，但找不到好的解决方案。有没有人能做到这一点？ 最佳答案 #Restartjustthethinserverdescribedbythatconfigsudothin-C/etc/thin/mysite.ymlrestartNginx将继续运行并代理请求。如果您将Nginx设置为使用多个上游服务器，例如server{listen80;server

    2. ruby - ruby 中的 TOPLEVEL_BINDING 是什么？ - 2

      它不等于主线程的binding，这个toplevel作用域是什么？此作用域与主线程中的binding有何不同？>ruby-e'putsTOPLEVEL_BINDING===binding'false 最佳答案 事实是，TOPLEVEL_BINDING始终引用Binding的预定义全局实例，而Kernel#binding创建的新实例>Binding每次封装当前执行上下文。在顶层，它们都包含相同的绑定(bind)，但它们不是同一个对象，您无法使用==或===测试它们的绑定(bind)相等性。putsTOPLEVEL_BINDINGput

    3. ruby - 一个 YAML 对象可以引用另一个吗？ - 2

      我想让一个yaml对象引用另一个，如下所示:intro:"Hello,dearuser."registration:$introThanksforregistering!new_message:$introYouhaveanewmessage!上面的语法只是它如何工作的一个例子(这也是它在thiscpanmodule中的工作方式。)我正在使用标准的ruby​​yaml解析器。这可能吗？ 最佳答案 一些yaml对象确实引用了其他对象:irb>require'yaml'#=>trueirb>str="hello"#=>"hello"ir

    4. 电脑0x0000001A蓝屏错误怎么U盘重装系统教学 - 2

      　　电脑0x0000001A蓝屏错误怎么U盘重装系统教学分享。有用户电脑开机之后遇到了系统蓝屏的情况。系统蓝屏问题很多时候都是系统bug，只有通过重装系统来进行解决。那么蓝屏问题如何通过U盘重装新系统来解决呢？来看看以下的详细操作方法教学吧。　　准备工作：　　1、U盘一个（尽量使用8G以上的U盘）。　　2、一台正常联网可使用的电脑。　　3、ghost或ISO系统镜像文件（Win10系统下载_Win10专业版_windows10正式版下载-系统之家）。　　4、在本页面下载U盘启动盘制作工具：系统之家U盘启动工具。　　U盘启动盘制作步骤：　　注意：制作期间，U盘会被格式化，因此U盘中的重要文件请注

    5. ruby - 使用 `+=` 和 `send` 方法 - 2

      如何将send与+=一起使用？a=20;a.send"+=",10undefinedmethod`+='for20:Fixnuma=20;a+=10=>30 最佳答案 恐怕你不能。+=不是方法，而是语法糖。参见http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_expressions.html它说Incommonwithmanyotherlanguages,Rubyhasasyntacticshortcut:a=a+2maybewrittenasa+=2.你能做的最好的事情是:

    6. ruby-on-rails - 创建 ruby​​ 数据库时惰性符号绑定(bind)失败 - 2

      我正在尝试在Rails上安装ruby​​，到目前为止一切都已安装，但是当我尝试使用rakedb:create创建数据库时，我收到一个奇怪的错误:dyld:lazysymbolbindingfailed:Symbolnotfound:_mysql_get_client_infoReferencedfrom:/Library/Ruby/Gems/1.8/gems/mysql2-0.3.11/lib/mysql2/mysql2.bundleExpectedin:flatnamespacedyld:Symbolnotfound:_mysql_get_client_infoReferencedf

    7. ruby - 如何计算 Liquid 中的变量 +1 - 2

      我对如何计算通过{%assignvar=0%}赋值的变量加一完全感到困惑。这应该是最简单的任务。到目前为止，这是我尝试过的:{%assignamount=0%}{%forvariantinproduct.variants%}{%assignamount=amount+1%}{%endfor%}Amount:{{amount}}结果总是0。也许我忽略了一些明显的东西。也许有更好的方法。我想要存档的只是获取运行的迭代次数。 最佳答案 因为{{incrementamount}}将输出您的变量值并且不会影响{%assign%}定义的变量，我

    8. ruby - Chef LW 资源属性默认值如何引用另一个属性？ - 2

      我正在尝试将一个资源属性的默认值设置为另一个属性的值。我正在为我正在构建的tomcat说明书定义一个资源，其中包含以下定义。我想要可以独立设置的“名称”和“服务名称”属性。当未设置服务名称时，我希望它默认为为“名称”提供的任何内容。以下不符合我的预期:attribute:name,:kind_of=>String,:required=>true,:name_attribute=>trueattribute:service_name,:kind_of=>String,:default=>:name注意第二行末尾的“:default=>:name”。当我在Recipe的新block中引用我

    9. arrays - Ruby 数组 += vs 推送 - 2

      我有一个数组数组，想将元素附加到子数组。+=做我想做的，但我想了解为什么push不做。我期望的行为(并与+=一起工作):b=Array.new(3,[])b[0]+=["apple"]b[1]+=["orange"]b[2]+=["frog"]b=>[["苹果"],["橙子"],["Frog"]]通过推送，我将推送的元素附加到每个子数组(为什么？):a=Array.new(3,[])a[0].push("apple")a[1].push("orange")a[2].push("frog")a=>[[“苹果”、“橙子”、“Frog”]、[“苹果”、“橙子”、“Frog”]、[“苹果”、“

    10. ruby - 在 Ruby 中，为什么 Array.new(size, object) 创建一个由对同一对象的多个引用组成的数组？ - 2

      如thisanswer中所述,Array.new(size,object)创建一个数组，其中size引用相同的object。hash=Hash.newa=Array.new(2,hash)a[0]['cat']='feline'a#=>[{"cat"=>"feline"},{"cat"=>"feline"}]a[1]['cat']='Felix'a#=>[{"cat"=>"Felix"},{"cat"=>"Felix"}]为什么Ruby会这样做，而不是对object进行dup或clone？ 最佳答案 因为那是thedocumenta

    随机推荐