Question

最初，我认为移动左值参考参数是一种不好的做法。这确实是C ++开发人员社区普遍同意的吗？

当我调用具有R值引用参数的函数时，很明显，我必须期望传递的对象可以移动。对于具有L值引用参数的函数来说，这不是很明显（在C ++ 11中引入移动语义之前，根本不可能）。

但是，我最近与其他一些开发人员交谈，他们不同意应避免移动左值引用。是否有强烈的反对意见？还是我的观点不对？

由于要求我提供一个代码示例，所以这里是一个示例（请参见下文）。这是一个人为的例子，仅用于说明问题。显然，在调用modifyCounter2（）之后，对getValue（）的调用将导致分段错误。但是，如果我不了解getValue（）的内部实现，便会感到非常惊讶。另一方面，如果该参数是R值引用，那么我将完全清楚地知道，在调用modifyCounter2（）之后，我将不再使用该对象。

class Counter
{
public:
    Counter() : value(new int32_t(0))
    {
        std::cout << "Counter()" << std::endl;
    }

    Counter(const Counter & other) : value(new int32_t(0))
    {
        std::cout << "Counter(const A &)" << std::endl;

        *value = *other.value;
    }

    Counter(Counter && other)
    {
        std::cout << "Counter(Counter &&)" << std::endl;

        value = other.value;
        other.value = nullptr;
    }

    ~Counter()
    {
        std::cout << "~Counter()" << std::endl;

        if (value)
        {
            delete value;
        }
    }

    Counter & operator=(Counter const & other)
    {
        std::cout << "operator=(const Counter &)" << std::endl;

        *value = *other.value;

        return *this;
    }

    Counter & operator=(Counter && other)
    {
        std::cout << "operator=(Counter &&)" << std::endl;

        value = other.value;
        other.value = nullptr;

        return *this;
    }

    int32_t getValue()
    {
        return *value;
    }

    void setValue(int32_t newValue)
    {
        *value = newValue;
    }

    void increment()
    {
        (*value)++;
    }

    void decrement()
    {
        (*value)--;
    }

private:
    int32_t* value;      // of course this could be implemented without a pointer, just for demonstration purposes!
};

void modifyCounter1(Counter & counter)
{
    counter.increment();
    counter.increment();
    counter.increment();
    counter.decrement();
}

void modifyCounter2(Counter & counter)
{
    Counter newCounter = std::move(counter);
}

int main(int argc, char ** argv)
{
    auto counter = Counter();

    std::cout << "value: " << counter.getValue() << std::endl;

    modifyCounter1(counter);  // no surprises

    std::cout << "value: " << counter.getValue() << std::endl;

    modifyCounter2(counter);  // surprise, surprise!

    std::cout << "value: " << counter.getValue() << std::endl;

    return 0;
}

Answer 1

是的，这令人惊讶且非常规。

如果您想允许移动，则惯例是按值传递。您可以在函数内部std::move进行适当操作，而调用方如果决定放弃所有权，可以将std::move插入自变量。

此约定是这样命名std::move的概念的来源：促进明确放弃所有权，表示意图。这就是为什么我们忍受这个名称，即使它具有误导性（std::move并没有真正移动任何东西）。

但是您的方法是盗窃。 ;）

移动左值参考参数是不好的做法吗？

1 个答案: