C++；cons实现——有没有办法使构造函数更具可读性？ 我决定在C++中实现一个基本的 CONS/COD>实现，主要是为了获得不带C++ 11的可变模板功能，即使它是非常有限的。我的问题是：该类的构造函数非常不可读，而且可能会变得更糟，这取决于模板中嵌套的cons。这是因为构造函数 cons< int, cons< int, cons<std::string> > > x(4, cons< int, cons<std::string> >(5, cons<std::string>("Hello"))); consx（4，cons（5，cons（“你好”））；

是一个相当多的口，难以阅读，所以我希望它是理想的

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

cons>x（4,5，“你好”）；

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

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();
}

struct null\u t
{
null_t（）
{
}
运算符int（）
{
返回NULL；
}
};
模板struct cons:public null\u t
{
公众：
typedef_Ty1_Ty1；
typedef_Ty2_Ty2；
类型定义cons_Myt；
反对意见（）
：var_x（），var_y（）
{
}
cons（常数Ty1和变量x，常数Ty2和变量y=null\t（））
：var_x（_var_x），var_y（_var_y）
{
}
cons（施工期和施工期）
：var_x（_Rhs._var_x），var_y（_Rhs.var_y）
{
}
模板cons（const cons和Rhs）
：var_x（_Rhs.var_x），var_y（_Rhs.var_y）
{
}
_Myt和运算符=（常数Myt和Rhs）
{
var_x=_Rhs.var_x；
var_y=_Rhs.var_y；
归还*这个；
}
模板\u Myt&operator=（const cons和Rhs）
{
var_x=_Rhs.var_x；
var_y=_Rhs.var_y；
归还*这个；
}
_Ty1&x（）
{
返回变量x；
}
_Ty2&y（）
{
返回变量；
}
私人：
_Ty1变种x；
_Ty2变种；
};
int main（）
{
cons>x（4，cons（5，cons（“你好”））；
//理想情况下，cons>x（4,5，“你好”）；
std:：cout您在模板领域，因此您可以定义即使使用也不会编译的构造函数。只需确定一个限制，比如15种类型（伪元组大小）。然后提供15个构造函数


顺便说一下，在Andrei Alexandrescu的《现代C++设计》一书中，我们可以查到<强> <强>的实现。如果你没有机会阅读这本书，你可能也可以在洛基图书馆的实现中找到它。这本书可以作为介绍洛基的本质方面的介绍。

您还可以查看。可能Boost支持您的C++11之前的编译器。那么Boost tuple很可能是一个更好的解决方案，而且无论如何，工作量更少！；-）
您处于模板领域，因此您可以定义即使使用也不会编译的构造函数。只需确定一个限制，比如15种类型（伪元组大小）.然后提供15名施工人员


顺便说一下，在Andrei Alexandrescu的《现代C++设计》一书中，我们可以查到<强> <强>的实现。如果你没有机会阅读这本书，你可能也可以在洛基图书馆的实现中找到它。这本书可以作为介绍洛基的本质方面的介绍。

您还可以查看。可能Boost支持您的C++11之前的编译器。那么Boost tuple很可能是一个更好的解决方案，而且无论如何，工作量更少！；-）
您处于模板领域，因此您可以定义即使使用也不会编译的构造函数。只需确定一个限制，比如15种类型（伪元组大小）.然后提供15名施工人员


顺便说一下，在Andrei Alexandrescu的《现代C++设计》一书中，我们可以查到<强> <强>的实现。如果你没有机会阅读这本书，你可能也可以在洛基图书馆的实现中找到它。这本书可以作为介绍洛基的本质方面的介绍。

您还可以查看。可能Boost支持您的C++11之前的编译器。那么Boost tuple很可能是一个更好的解决方案，而且无论如何，工作量更少！；-）
您处于模板领域，因此您可以定义即使使用也不会编译的构造函数。只需确定一个限制，比如15种类型（伪元组大小）.然后提供15名施工人员


顺便说一下，在Andrei Alexandrescu的《现代C++设计》一书中，我们可以查到<强> <强>的实现。如果你没有机会阅读这本书，你可能也可以在洛基图书馆的实现中找到它。这本书可以作为介绍洛基的本质方面的介绍。

您还可以查看。可能Boost支持您的C++11之前的编译器。那么Boost tuple很可能是一个更好的解决方案，而且无论如何，工作量更少！；-）
如果您有需要修改的工作代码，请转到代码审阅：堆栈溢出用于诊断和修复损坏的代码：-）
typedef\1_Ty1；
what？@Paranaix：在模板结构中完全有意义。您将参数存储在结构中。如果您有需要修改的工作代码，请转到代码审阅：堆栈溢出用于诊断和修复损坏的代码：-）
typedef(u Ty1)；
what？@Paranaix：在模板结构中完全有意义。您将参数存储在结构中。如果您有需要修改的工作代码，请转到代码审阅：堆栈溢出用于诊断和修复损坏的代码：-）
typedef\u Ty1\u Ty1；
what？@Paranaix:在模板结构中完全有意义。您将参数存储在结构中。如果您有工作代码，则需要进行润色，请转到代码审阅：堆栈溢出用于诊断和修复损坏的代码：-）typedef\u Ty1\u Ty1；what？@Paranaix:在模板结构中完全有意义。您将参数存储在结构中。