模板参数推导

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 的内容，它是一个模板类。模板类是一种特定类型，与任何其他类型一样，它只是恰好是通过类模板创建的。

目标是，给定一个类型 T，测试它是否是一个模板类，如果是，则访问该类模板用于创建它，还用于访问传递给类模板的参数。在此示例中，我只是测试某个东西是一个参数模板还是两个参数模板，但该技术可以轻松扩展。

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

最好的起点是这个 我放在 ideone 上的示例代码。我将在本答案末尾复制 Exploder 代码。

我首先

typedef list<int> list_of_ints;

使用 Exploder 模板来访问上述所有信息。例如，Exploder； :: type_1 是传递给模板的第一个参数，在本例中为 int。第二个参数（这是默认参数）是 allocator，可以通过 Exploder 访问。 :: 类型_2。

typedef Exploder<list_of_ints> :: type_2  should_be_an_allocator_int;

给定第二种类型（我们知道它是由模板创建的），我们可以使用 Exploder 访问其参数类型 int。 should_be_an_allocator_int > :: type_1，但更有趣的是实际访问 allocator 模板并向其传递不同的参数。在此示例中，下一行的计算结果为allocator。

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

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

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

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

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

（此外，某些模板的参数不是类型，而是其他类模板，甚至其他模板模板。应该可以提取所有这些，但我我不会在这里对此进行深入研究。）

（最后一个有趣的技术说明。某些类型，例如分配器，具有称为重新绑定的东西来允许这种访问。但上面使用的技术适用于所有模板类，即使是那些没有自己的模板类的rebind)

模板 Exploder 的完整代码

请参阅我放在 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;
};

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

此外，typedef iterator const const_iterator; 是错误的；声明一个不可修改迭代器，可以用于修改序列，而const_iterator应该是一个可修改 不能用于修改序列的迭代器。

Answer 3

（术语说明。vector 是一个类模板，即没有任何参数。vector 是一个模板类，即一个类几乎与任何其他类一样，只是它是由模板创建的。）

可以按照您的意愿使用它，其中 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 上的示例代码