接受 const 和 non-const 数据的通用函数和相关函数

Question

要使问题标题更有意义，请考虑以下代码：

template <typename T>
void write(const T& /*data*/)
{
    // use data as const
}

template <typename T>
void read(T& /*data*/)
{
    // modify data
}

struct S { 
    int a;
    int b;
    // a lot of primitive types here
};

void output(const S& s)
{
    write(s.a);
    write(s.b);
    // ...
}

void input(S& s)
{
    read(s.a);
    read(s.b);
    // ...
}

int main()
{
    S s;
    input(s);
    output(s);
}

我有 write 和 read 函数来操作原始数据，例如 int、double 等。我有几个结构类型，例如 S，其中包含很多原始数据成员，我需要输入并通过相应的函数input 和output 输出此类类型（不同类型有许多重载）。如您所见，output 和input 函数的内容基本相同，只是内部函数和类型常量不同。我想做一些通用（模板）函数use 来消除input/output 函数中的代码重复。

我认为模板签名如下（但我可能会遗漏一些东西）：

template <typename F, typename T>
void use(T& t) { ... }

所以我可以像这样从input/output 调用use 函数：

use<write, S>(s); // in output function
use<read, S>(s);  // in input fuction

如何归档这种（或类似的）行为以消除代码重复？我正在使用 C++14。

Answer 1

template <typename S, typename F>
void use(S&& s, F&& f)
{
    f(s.a);
    f(s.b);
    f(s.c);
}

用法：

use(s, [](const auto& x){ write(x); });
use(s, [](auto& x)      { read(x); });

live example on wandbox.org

---

如果您需要多种类型：

template <typename S, typename Target>
using EnableFor = std::enable_if_t<std::is_same_v<std::decay_t<S>, Target>>;

template <typename S, typename F>
auto use(S&& s, F&& f) -> EnableFor<S, S0>
{
    f(s.a);
    f(s.b);
    f(s.c);
}

template <typename S, typename F>
auto use(S&& s, F&& f) -> EnableFor<S, S1>
{
    f(s.d);
    f(s.e);
    f(s.f);
}

用法：

int main()
{
    S0 s0; 
    use(s0, [](const auto& x){ write(x); });
    use(s0, [](auto& x)      { read(x); });

    S1 s1;
    use(s1, [](const auto& x){ write(x); });
    use(s1, [](auto& x)      { read(x); });
}

live example on wandbox.org

Answer 2

您可以定义正在使用的模板的接口：

template<class M, class S>
void use(S &&s) {
    M::method(s.a);
    M::method(s.b);
};

然后实现它：

template <typename T>
void write(const T& /*data*/)
{
    // use data as const
}

struct writer {
    template <typename T>
    static void method(const T& t)
    {
        write(t);
    }
};

现在你可以使用它了：

use<writer>(s);

对于read，也是一样的：

struct reader {
    template <typename T>
    static void method(T& t)
    {
        read(t);
    }
};

use<reader>(s);

Answer 3

我相信我明白你想要什么，但这是不可能的。目前没有办法在 C++ 通用流中为所有类实现。需要访问诸如类具有的字段数量、它们的相对地址以及编译时间类型等信息。

目前他们多年来一直致力于将其添加到 C++ 中，寻求 Reflection TS。据我所知，它还没有为 C++20 做好准备。

但是，您可以组织代码，使每个读/写方法都易于实现。例如：

class A : public B, public C
{
   private:
   vector<int> m_v;
   int m_x;
};

然后为它实现写

template<>
void write(const A& a)
{
     write((const B&)a);
     write((const C&)a);
     write(a.m_v);
     write(a.m_x);
}

而对于像std::vector<T> 这样的常见数据结构，通过write<T> 实现写入。这需要时间，但使其具有技术性并使用重定向可以节省大量代码和时间。

（你需要将write设为好友函数，或成员函数以使其访问私有成员）