模板参数的模板化模板专业化

Question

Say you have the following:

SomeType *x;
std::vector<std::unique_ptr<SomeType>> v;

And you want to call a function like this:

do_something(v.begin(), v.end(), x);

Say do_something is templated, and you want to make a specialization for the case of container<unique_ptr<T>> . Even if not for specialization, let's simply say we want to have the container templatized but always assuming inside it is a unique_ptr .

I tried the following:

template<template <typename X, typename Y> class C, typename T, typename Allocator>
inline int do_something(typename C<std::unique_ptr<T>, Allocator>::iterator first,
                        typename C<std::unique_ptr<T>, Allocator>::iterator last,
                        const T* value)
{ ... }

But g++, clang and cl.exe all fail to deduce the type of C . What's ambiguous here? And what can I do about it?

Answer 1

Anything to the left of :: is a non-deduced context.

Here's something that will allow your function to be called on any iterator whose value_type is a std::unique_ptr .

#include <type_traits>

template <typename T>
struct is_unique_ptr : public std::false_type {};
template <typename T, typename D>
struct is_unique_ptr<std::unique_ptr<T,D>> : public std::true_type {};

template <typename Iter, typename T>
auto do_something(Iter first, Iter last, const T* value) ->
std::enable_if_t<is_unique_ptr<typename std::iterator_traits<Iter>::value_type>
                 ::value, int>
{ ... }

Note this now includes not just Container::iterator but Container::reverse_iterator and any other "wrapper" iterator with the same value_type . (But not Container::const_iterator .)