Question

我正在编写一个模板化的类，它负责将一些数据复制到本地函数中和从本地函数中复制出来。我为此做了两种不同的机制。通过子类或通过引用。这更有意义，是“正确”的方式吗？

namespace subclass {
struct array {
  int a, b, c, d;
};

template <typename T> class inout : public T {
private:
  static_assert(std::is_pod<T>::value);

  T *p;

public:
  inout(T *_p) : p(_p) { memcpy(this, p, sizeof(T)); }
  ~inout(void) { memcpy(p, this, sizeof(T)); }
};

void subr(array *args, int) {
  inout<array> local(args);

  local.a = local.b + local.c + local.d;
}
}

namespace reference {
struct array {
  int a, b, c, d;
};

template <typename T> class inout {
private:
  static_assert(std::is_pod<T>::value);

  T *p;
  T &l;

public:
  inout(T &_l, T *_p) : p(_p), l(_l) { memcpy(&l, p, sizeof(T)); }
  ~inout(void) { memcpy(p, &l, sizeof(T)); }
};

void subr(array *args, int) {
  array local;
  inout<array> raii(local, args);

  local.a = local.b + local.c + local.d;
}
}

Answer 1

在我看来，他们的解决方案是他们试图以一种艰难的方式做一件简单的事情。如果你想复制，为什么不简单地复制？

void subr(array *args, int) {
  array local = *args;

  local.a = local.b + local.c + local.d;

  *args = local;
}

如果您希望在范围的末尾自动复制，请再次使用更简单的方法：

template <typename T>
class AutoCopy {
private:
   T   m_copy;
   T * m_original;

public:
   AutoCopy(T * original) : m_copy(*original), m_original(original) {}
   ~AutoCopy() { *m_original = m_copy; }

   T & get() { return m_copy; }
};

void subr(array *args, int) {
  AutoCopy<array> c(args);
  c.get().a = c.get().b + c.get().c + c.get().d;
}

适合你吗？这样它的工作方式甚至是类型不是POD，如果它是常规默认复制构造函数将与memcpy()相同（正如您在“Trivial复制构造函数”中看到的那样here部分）。

即使您更喜欢保留memcpy()，我认为拥有成员变量并复制到其中将比继承您的类型更清晰。

C ++模板类作为子类还是引用？

1 个答案: