Question

我目前正面临一个我无法解决的问题。基本上我正在尝试做的是在C ++中实现一些类似linq的行为。

我将从标题中的代码开始：

template<typename T, template<class = T> class A,
         template<class = T, template<class=T> class = A> class C>
class queryable
{
public:
    typedef T value_type;
    typedef A<value_type> allocator_type;
    typedef C<value_type, allocator_type> container_type;    // (1)
    typedef queryable<T, A, C> type;
    queryable(container_type const &) { }
    template<typename _Out> queryable<_Out, A, C> select(/* some delegate */);
    // more methods etc
}

这就是我希望它被实例化的方式：

std::vector<int> my_vec;
queryable<std::vector<int> > q(my_vec);

毋庸置疑这不起作用（其他我不会在这里:)）

现在更奇怪的是，即使这似乎也不起作用：

std::vector<int> my_vec;
queryable<int, std::allocator, std::vector> q(my_vec);

正如你所看到的（通过查看select函数），对我来说不仅仅是使用这样的东西很重要：

template<typename T> class queryable;

有关如何解决此问题的任何建议？这甚至可能吗？

任何帮助将不胜感激！

编辑：我得到的错误：

../entry.cpp:19:58: error: type/value mismatch at argument 3 in template parameter list for ‘template<class T, template<class> class A, template<class, template<class> class<template-parameter-2-2> > class C> class failproof::collections::queryable’
../entry.cpp:19:58: error:   expected a template of type ‘template<class, template<class> class<template-parameter-2-2> > class C’, got ‘template<class _Tp, class _Alloc> class std::vector’
../entry.cpp:19:61: error: invalid type in declaration before ‘;’ token

编辑2：

据我所知，编译器抱怨C不接受2个类参数，而是1个类参数和1个模板化类参数（1），因为我将C定义为这样。有什么方法可以解决这个问题吗？

Answer 1

有一种通用方法可以“爆炸”一个类型来测试它是否是由模板创建的，并提取传递给该模板的类型。如果您愿意，也可以访问模板本身并将其他参数传递给它。

vector是类模板。当您向其应用参数时，您会得到类似vector<int>的内容，这是模板类。 模板类是一种特定类型，与任何其他类型一样，它恰好是通过类模板创建的。

如果类型为T，目标是测试它是否为模板类，如果是，则可以访问类模板用于创建它，以及访问传递给类模板的参数。在这个示例中，我只是测试某个东西是一个arg还是两个arg模板，但是这个技术可以很容易地扩展。

（从技术上讲，vector是一个双精度模板。第二个参数有一个默认值，因此vector<int>实际上是vector<int, allocator<int> >，但它基本上仍然是一个双精度模板，而不是一个arg模板。）

最好的起点是sample code I've put on ideone。我会在这个答案的最后复制Exploder代码。

我从

开始

typedef list<int> list_of_ints;

然后继续使用Exploder模板访问上述所有信息。例如，Exploder<list_of_ints> :: type_1是传递给模板的第一个参数，在本例中为int。第二个参数（这是默认参数）为allocator<int>，可通过Exploder<list_of_ints> :: type_2访问。

typedef Exploder<list_of_ints> :: type_2  should_be_an_allocator_int;

鉴于第二种类型，我们知道它是由模板创建的，我们可以使用int访问其参数类型Exploder< should_be_an_allocator_int > :: type_1，但实际访问allocator更有意思而是模板，并传递一个不同的参数。在此示例中，下一行评估为allocator<double>。

typedef Exploder< should_be_an_allocator_int >
           :: rebind<double> :: type should_be_an_allocator_double;

因此，即使您的list<...,...>类型不使用默认分配器，您也可以访问使用的分配器，以及任何类模板用于创建分配器类型。

现在我们有了合适的分配器，我们可以回到我们原来的模板类 list<int>并将int替换为double：

Exploder<list_of_ints> :: rebind<double, should_be_an_allocator_double> :: type

要验证所有这些是否有效，示例代码使用typeid(...).name()来打印各种对象的实际类型以及它应该是正确的类型。你可以看到它们匹配。

（另外，有些模板的参数不是类型，而是其他类模板，甚至其他模板模板。应该可以提取所有这些，但我不打算在此讨论。）

（最后一个有趣的技术说明。某些类型，例如allocator，有一些名为rebind的东西允许这种访问。但上面使用的技术适用于所有模板类，即使是那些没有他们自己的rebind）

模板Exploder的完整代码

有关完整演示，请参阅sample code I've put on ideone。

template <class>
struct Exploder;

template<class T, template<class> class Template>
struct Exploder< Template<T> > {
        static const char * description() { return " One-arg template. Arg 1 is a type "; }
        typedef T type_1;
        template <class V>
        struct rebind {
                typedef Template<V> type;
        };
};
template<class T, class U, template<class,class> class Template>
struct Exploder< Template<T,U> > {
        static const char * description() { return " Two-arg template. All args are types, as opposed to being (unapplied) templates. "; }
        typedef T type_1;
        typedef U type_2;
        template <class V,class W>
        struct rebind {
                typedef Template<V,W> type;
        };
};
template<class S, class T, class U, template<class,class,class> class Template>
struct Exploder< Template<S,T,U> > {
        static const char * description() { return " Three-arg template. All args are types, as opposed to being (unapplied) templates. "; }
        typedef S type_1;
        typedef T type_2;
        typedef U type_3;
};

Answer 2

标准容器（分配器）的第二个模板参数是类型，而不是模板，因此您需要将第三个参数更改为

template<typename, typename> class C

（请注意，模板参数规范中的默认参数不起任何作用，因此我在此省略它们。）

然后你应该能够将模板实例化为

queryable<int, std::allocator, std::vector>

您可能最好只对容器类型进行参数化，然后使用其value_type和allocator_type定义：

template <typename C> class queryable
{
public:
    typedef typename C::value_type value_type;
    typedef typename C::allocator_type allocator_type;
    typedef C container_type;
};

（一个缺点是您无法直接访问分配器模板;但是，您可以使用分配器类型的嵌套rebind定义您需要为其他类型实例化该模板。）

另外，typedef iterator const const_iterator;错了;声明一个不可修改的迭代器，可以用于修改序列，而const_iterator应该是可修改的迭代器< em>不能用于修改序列。

Answer 3

（关于术语的说明。vector是类模板，即没有任何参数。vector<int>是模板类，即一个类几乎和其他类一样，除了它是由模板创建的。）

可以根据需要使用它，其中queryable采用一个模板参数：

queryable< vector<int> > q;

这意味着querable是一个只有一个参数的模板：

template <typename T>
struct queryable;

然后使用具有多个参数的专业化：

template <typename ValueType, template<class T,class = allocator<T> > class ContainerTemplate>
struct queryable< ContainerTemplate<Contained> > {
        typedef ValueType value_type;
        typedef ContainerTemplate<ValueType> container_type;
        typedef typename container_type :: allocator_type A;
        // typedef ContainerTemplate <WhateverOtherValueTypeYouWish> ...
        // typedef A :: rebind <SomeOtherType> ...
};

最后两行，注释掉，显示如何使用ContainerTemplate作为类模板，根据需要创建其他类型。 ContainerTemplate为vector或list或set或类似内容。

正如@MikeSeymour指出的那样，使用rebind可能是访问分配器类模板的方法。

ideone

上的示例代码

模板参数演绎

3 个答案:

模板Exploder的完整代码