2

我有一些轻物体可以推动和操纵，然后我想将它们包含在一个更复杂的物体中。有一个查找表应该保持不变。这个想法看起来很简单，但是这样做的一行b += c(a);- 会产生一个昂贵的临时性。

#include <vector>
static int count;

struct costly {
    /* std::map<std::string, int> and whatnot */
    int b;

    ~costly() { count++; }
     costly(int b): b(b) { }
     costly &operator+= (costly &rhs) { b += rhs.b; return *this; }
};

/* Note the assumption above constructor exists for rhs */
costly operator* (const costly &lhs, costly rhs) {
    rhs.b *= lhs.b; return rhs;
}

struct cheap {
    /* Consider these private or generally unaccessible to 'costly' */
    int index, mul;

    cheap(int index, int mul): index(index), mul(mul) { }
    costly operator() (const std::vector<costly> &rhs) {
        /* Can we do without this? */
        costly tmp = rhs[index] * mul; return tmp;
    }
};

int main(int argc, char* argv[]) {
    std::vector<costly> a = {1, 2}; costly b(1); cheap c = {1, 2};
    /* Above init also calls the destructor, don't care for now */
    count = 0;
    b += c(a);
    return count;
}

我一直在阅读 RVO 和 C++11 的右值，但还不能完全理解它们以完全消除引入的中间值。上面只创建了一个，因为 rhs 的构造函数可用。最初我有这个；

costly operator* (costly lhs, int rhs) {
    lhs.b *= rhs; return lhs;
}

/* ... */

costly operator() (const std::vector<costly> &rhs) {
    return rhs[index] * mul;
}

但是，与我的直觉相反，结果count甚至是 2。为什么编译器没有得到我的意图？

4

3 回答 3

1

这是一种完全不同的方法，与您是否通过 RVO 进行优化是正交的，但这里是：

既然使复制变得昂贵的内部数据成员或多或少是 const，为什么不直接避免复制该特定成员呢？

如果你costly这样改变：

struct costly {
    shared_ptr<const map<string, int>> lookup_table;
    int m;
    ...
};

复制变得便宜得多。请注意，指向表的指针是非常量的，即使它指向的映射是 const。

肖恩·帕特（Sean Parent）对此进行了很好的讨论，关于他们如何在 Photoshop 中实现历史和图层。由于带宽有限，我现在无法查找 URL。

于 2014-11-16T14:26:08.153 回答
1

RVO 不适用于函数参数，因此您的*运营商正在禁止它。为了启用 RVO，您需要参数的本地副本。然后，您可以通过提供采用右值引用的重载进行优化（前提costly是具有有效的移动复制构造函数）。例如，

costly operator*(const costly& c, int i)
{
  costly ret = c;
  ret += 1;
  return ret;
}

costly operator*(costly&& c, int i)
{
  costly ret = std::move(c);
  ret += 1;
  return ret;
}
于 2014-11-16T12:27:06.930 回答
0

我认为部分问题在于算术运算符最适合复制相对便宜的值类型。如果您想完全避免复制costly，我认为最好避免重载这些运算符。

它可能会添加太多逻辑，costly但您可以添加一个函数来执行您想要的操作，而无需制作任何副本：

void addWithMultiple(const costly& rhs, int mul) {
    b += rhs.b * mul;
}

然后可以这样调用cheap：

void operator() (costly &b, const std::vector<costly> &a) {
    b.addWithMultiple(a[index], mul);
}

但这是一个相当大的重构，因此可能无法满足您的所有需求。

于 2014-11-16T14:04:27.827 回答