在构造过程中是否有一种简洁的方法来导出成员的类型？

Question

我有：

• 模板例程unarchive 接受一个字典和一个键并基于传递的模板类型 (T) 可以专门生成一个T
• struct 的构造函数，利用 unarchive 构造其成员

一个例子可能如下：

template <typename T>
T unarchive(const dictionary_t&, key_type key);

struct foo
{
    foo(const dictionary& archive) :
        value_m(unarchive<decltype(value_m)>(archive, value_key))
    { }

    some_value_type value_m;
};

在这里使用unarchive<decltype(value_m)> 的好处是我可以更改value_m 的类型而无需更新这行代码——类型始终遵循成员变量的类型。

我遇到的问题更美观：它非常冗长。目前我有一个宏：

#define UNARCHIVE_FOR(var) unarchive<decltype(var)>

而foo的构造函数变化如下：

foo(const dictionary& archive) :
    value_m(UNARCHIVE_FOR(value_m)(archive, value_key))
{ }

现在我得到了一个更简洁但更丑陋的结果。没有宏能达到同样的效果吗？我想要的是类似于：

foo(const dictionary& archive) :
    value_m(unarchive<value_m>(archive, value_key))
{ }

如何做到这一点？

Answer 1

在这里使用 unarchive 的好处是我可以更改 value_m 的类型，而无需更新这行代码——类型始终遵循成员变量的类型。

另一种方法是为value_m 类型创建一个别名，并从构造函数初始化列表中删除decltype(value_m)：

struct foo
{
    using value_type = int;

    foo(const dictionary_t& archive, const key_type value_key) :
        value_m(unarchive<value_type>(archive, value_key))
    { }

    value_type value_m;
};

unarchive<value_type> 仍然遵循value_m 的类型。如果担心通过不更改 value_type 来更改 value_m 的类型，则可以添加 static_assert 以确保 value_m 的类型与 value_type 相同：

static_assert(std::is_same<decltype(value_m), value_type>::value,
              "'value_m' type differs from 'value_type'");

或者根据value_m的类型设置别名：

int value_m;
using value_type = decltype(value_m);

如果您仍然认为构造函数初始化列表很冗长，请提供一个调用unarchive() 函数的static 包装函数：

struct foo
{
    using value_type = int;

    foo(const dictionary_t& archive, const key_type value_key) :
        value_m(unarchive_(archive, value_key))
    { }

    static value_type unarchive_(const dictionary_t& d, key_type k)
    {
        return unarchive<value_type>(d, k);
    }

    value_type value_m;
};

说了这么多：

value_m(unarchive<decltype(value_m)>(archive, value_key))

不是那么冗长，而是准确地说明了意图。

Answer 2

这有点老套，但是如何使用模板化转换运算符为存档引入包装类：

class wrapper {
  const dictionary_t& dict_m;
  const key_type key_m;
public:
  wrapper(const dictionary_t& d, key_type k) :
    dict_m(d), key_m(k) {}
  template <class T> operator T () const {
    return unarchive<T>(dict_m, key_m);
  }
};

所以你可以初始化：

foo(const dictionary_t& archive, const key_type value_key) :
    value_m(wrapper(archive, value_key))
{}