c++ - 模板参数推导

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 ，测试它是否是一个模板类，如果是，则获取对用于创建的类模板的访问权它，以及访问传递给类模板的参数。在此示例中，我只是测试某些东西是单参数模板还是双参数模板，但该技术可以轻松扩展。

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

最好的起点是这个 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;
};