时间戳

首页 > 解决方案 > 移动左值参考参数是不好的做法吗？

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

问题描述

我最初认为移动左值参考参数是不好的做法。这确实是 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;
}

标签： c++move-semantics

解决方案

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

如果您想允许移动，约定是按值传递。您可以根据需要std::move从函数内部，而调用者可以std::move在他们决定放弃所有权时进入参数。

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

但你的方式是盗窃。;)

推荐阅读