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个构造函数。

顺便说一句，请查看Andrei Alexandrescu的书＆＃34; Modern C ++ Design＆＃34;中的 type list 实现。如果您无法访问该书，您可以（可能）在Loki库实现中找到它。这本书可以作为Loki基本方面的介绍阅读。

您还可以查看 Boost tuple library 。也许Boost支持你的pre-C ++ 11编译器。那么Boost元组很可能是一个优秀的解决方案，无论如何，工作量更少！ ; - ）

C ++ cons实现 - 是否有任何方法可以使构造函数更具可读性？

1 个答案: