0

这是我最近在思考的问题。假设我们的接口是一个成员函数，它返回复制成本高且移动成本低的对象（std::string、std::vector 等）。一些实现可能会计算结果并返回一个临时对象，而其他实现可能只是返回一个成员对象。

示例代码来说明：

// assume the interface is: Vec foo() const
// Vec is cheap to move but expensive to copy

struct RetMember {
    Vec foo() const { return m_data; }
    Vec m_data;
    // some other code
}

struct RetLocal {
    Vec foo() const {
        Vec local = /*some computation*/;
        return local;
    }
};

还有各种“客户”。有些只读取数据，有些需要所有权。

void only_reads(const Vec&) { /* some code */ }
void requires_ownership(Vec) { /* some code */ }

上面的代码编写得很好，但没有达到应有的效率。以下是所有组合：

RetMember retmem;
RetLocal retloc;

only_reads(retmem.foo()); // unnecessary copy, bad
only_reads(retloc.foo()); // no copy, good

requires_ownership(retmem.foo()); // copy, good
requires_ownership(retloc.foo()); // no copy, good

解决这种情况的好方法是什么？

我想出了两种方法，但我确信有更好的解决方案。

在我的第一次尝试中，我编写了一个包含 T 值或指向 const T 的指针的 DelayedCopy 包装器。它非常丑陋，需要额外的努力，引入了多余的移动，妨碍了复制省略，并且可能还有许多其他问题。

我的第二个想法是continuation-passing style，它工作得很好，但将成员函数转换为成员函数模板。我知道，有 std::function，但它有它的开销，所以在性能方面它可能是不可接受的。

示例代码：

#include <boost/variant/variant.hpp>
#include <cstdio>
#include <iostream>
#include <type_traits>

struct Noisy {

  Noisy() = default;
  Noisy(const Noisy &) { std::puts("Noisy: copy ctor"); }
  Noisy(Noisy &&) { std::puts("Noisy: move ctor"); }

  Noisy &operator=(const Noisy &) {
    std::puts("Noisy: copy assign");
    return *this;
  }
  Noisy &operator=(Noisy &&) {
    std::puts("Noisy: move assign");
    return *this;
  }
};

template <typename T> struct Borrowed {
  explicit Borrowed(const T *ptr) : data_(ptr) {}
  const T *get() const { return data_; }

private:
  const T *data_;
};

template <typename T> struct DelayedCopy {
private:
  using Ptr = Borrowed<T>;
  boost::variant<Ptr, T> data_;

  static_assert(std::is_move_constructible<T>::value, "");
  static_assert(std::is_copy_constructible<T>::value, "");

public:
  DelayedCopy() = delete;

  DelayedCopy(const DelayedCopy &) = delete;
  DelayedCopy &operator=(const DelayedCopy &) = delete;

  DelayedCopy(DelayedCopy &&) = default;
  DelayedCopy &operator=(DelayedCopy &&) = default;

  DelayedCopy(T &&value) : data_(std::move(value)) {}
  DelayedCopy(const T &cref) : data_(Borrowed<T>(&cref)) {}

  const T &ref() const { return boost::apply_visitor(RefVisitor(), data_); }

  friend T take_ownership(DelayedCopy &&cow) {
    return boost::apply_visitor(TakeOwnershipVisitor(), cow.data_);
  }

private:
  struct RefVisitor : public boost::static_visitor<const T &> {
    const T &operator()(Borrowed<T> ptr) const { return *ptr.get(); }
    const T &operator()(const T &ref) const { return ref; }
  };

  struct TakeOwnershipVisitor : public boost::static_visitor<T> {
    T operator()(Borrowed<T> ptr) const { return T(*ptr.get()); }
    T operator()(T &ref) const { return T(std::move(ref)); }
  };
};

struct Bar {
  Noisy data_;

  auto fl() -> DelayedCopy<Noisy> { return Noisy(); }
  auto fm() -> DelayedCopy<Noisy> { return data_; }

  template <typename Fn> void cpsl(Fn fn) { fn(Noisy()); }
  template <typename Fn> void cpsm(Fn fn) { fn(data_); }
};

static void client_observes(const Noisy &) { std::puts(__func__); }
static void client_requires_ownership(Noisy) { std::puts(__func__); }

int main() {
  Bar a;

  std::puts("DelayedCopy:");
  auto afl = a.fl();
  auto afm = a.fm();

  client_observes(afl.ref());
  client_observes(afm.ref());

  client_requires_ownership(take_ownership(a.fl()));
  client_requires_ownership(take_ownership(a.fm()));

  std::puts("\nCPS:");

  a.cpsl(client_observes);
  a.cpsm(client_observes);

  a.cpsl(client_requires_ownership);
  a.cpsm(client_requires_ownership);
}

输出：

DelayedCopy:
Noisy: move ctor
client_observes
client_observes
Noisy: move ctor
Noisy: move ctor
client_requires_ownership
Noisy: copy ctor
client_requires_ownership

CPS:
client_observes
client_observes
client_requires_ownership
Noisy: copy ctor
client_requires_ownership

是否有更好的技术来传递避免额外副本但仍然通用的值（允许返回临时成员和数据成员）？

附带说明：代码是用 C++11 中的 g++ 5.2 和 clang 3.7 编译的。在 C++14 和 C++1z 中，DelayedCopy 无法编译，我不确定这是否是我的错。

4

1 回答 1

1

可能有成千上万的“正确”方法。我倾向于其中一个：

  1. 传递引用或移动对象的方法已明确说明，因此没有人有任何疑问。
  2. 尽可能少地维护代码。
  3. 所有代码组合都编译并做明智的事情。

像这样（人为）的例子：

#include <iostream>
#include <string>
#include <boost/optional.hpp>

// an object that produces (for example) strings
struct universal_producer
{
    void produce(std::string s)
    {
        _current = std::move(s);
        // perhaps signal clients that there is something to take here?
    }

    // allows a consumer to see the string but does not relinquish ownership
    const std::string& peek() const {
        // will throw an exception if there is nothing to take
        return _current.value();
    }

    // removes the string from the producer and hands it to the consumer
    std::string take() // not const
    {
        std::string result = std::move(_current.value());
        _current = boost::none;
        return result;
    }

    boost::optional<std::string> _current;

};

using namespace std;

// prints a string by reference
void say_reference(const std::string& s)
{
    cout << s << endl;
}

// prints a string after taking ownership or a copy depending on the call context
void say_copy(std::string s)
{
    cout << s << endl;
}

auto main() -> int
{
    universal_producer producer;
    producer.produce("Hello, World!");

    // print by reference
    say_reference(producer.peek());

    // print a copy but don't take ownership
    say_copy(producer.peek());

    // take ownership and print
    say_copy(producer.take());
    // producer now has no string. next peek or take will cause an exception
    try {
        say_reference(producer.peek());
    }
    catch(const std::exception& e)
    {
        cout << "exception: " << e.what() << endl;
    }
    return 0;
}

预期输出：

Hello, World!
Hello, World!
Hello, World!
exception: Attempted to access the value of an uninitialized optional object.
于 2015-10-03T11:48:57.533 回答