C++ cons 实现 - 有什么方法可以使构造函数更具可读性吗？

Question

我决定用 C++ 实现一个基本的 cons 实现，主要是为了在没有 C++11 的情况下获得可变参数模板功能，尽管它有很多限制。我的问题是:该类的构造函数非常不可读，而且可能会变得更糟，具体取决于模板中嵌套的 cons 的数量。这是因为构造函数

cons< int, cons< int, cons<std::string> > > x(4, cons< int, cons<std::string> >(5, cons<std::string>("Hello")));

非常冗长，难以阅读，所以我希望它是理想的

cons< int, cons< int, cons<std::string> > > x(4, 5, "Hello");

我可能在其他地方做错了，请随时纠正我。

struct null_t
{
    null_t()
    {
    }

    operator int()
    {
        return NULL;
    }
};

template < typename _Ty1, typename _Ty2 = null_t > struct cons : public null_t
{
public:
    typedef _Ty1 _Ty1;
    typedef _Ty2 _Ty2;
    typedef cons<_Ty1, _Ty2> _Myt;

    cons()
        : var_x(), var_y()
    {
    }

    cons(const _Ty1 &_Var_x, const _Ty2 &_Var_y = null_t())
        : var_x(_Var_x), var_y(_Var_y)
    {
    }

    cons(const _Myt &_Rhs)
        : var_x(_Rhs.__var_x), var_y(_Rhs.var_y)
    {
    }

    template < typename _Ty3, typename _Ty4 > cons(const cons<_Ty3, _Ty4> &_Rhs)
        : var_x(_Rhs.var_x), var_y(_Rhs.var_y)
    {
    }

    _Myt &operator=(const _Myt &_Rhs)
    {
        var_x = _Rhs.var_x;
        var_y = _Rhs.var_y;
        return *this;
    }

    template < typename _Ty3, typename _Ty4 > _Myt &operator=(const cons<_Ty3, _Ty4> &_Rhs)
    {
        var_x = _Rhs.var_x;
        var_y = _Rhs.var_y;
        return *this;
    }

    _Ty1 &x()
    {
        return var_x;
    }

    _Ty2 &y()
    {
        return var_y;
    }

private:
    _Ty1 var_x;
    _Ty2 var_y;
};

int main()
{
    cons< int, cons< int, cons<std::string> > > x(4, cons< int, cons<std::string> >(5, cons<std::string>("Hello")));
    // Ideally cons< int, cons< int, cons<std::string> > > x(4, 5, "Hello");
    std::cout << x.x() << "\n";
    std::cout << x.y().x() << "\n";
    std::cout << x.y().y().x();
}

Answer 1

您处于模板领域，因此您可以定义在使用时甚至不会编译的构造函数。只需确定一个限制，比如 15 种类型(伪元组大小)。然后提供15个构造函数。

---

顺便看看 type list 在 Andrei Alexandrescu 的书“现代 C++ 设计”中实现。如果您无法访问这本书，您(可能)也可以在 Loki 库实现中找到它。这本书可以作为对 Loki 基本方面的介绍来阅读。

您还可以查看 Boost tuple library 。也许 Boost 支持您的 C++11 之前的编译器。那么 Boost 元组很可能是一个更好的解决方案，而且无论如何，工作量更少! ;-)