隐式转换为模板

Question

我的示例如下表明，从非模板类型到模板类型的隐式转换将无法像仅涉及非模板类型的那样无缝地转换。有没有办法让他们继续工作？

例子：

struct point; 

template<unsigned d> struct vec { 
    vec() { } 
    // ... 
}; 

template<> struct vec<2> { 
    vec() { } 
    vec(const point& p) { /* ... */ } // Conversion constructor 
    // ... 
}; 

struct point { 
    operator vec<2>() { return vec<2>(/* ... */); } // Conversion operator 
}; 

template<unsigned d> vec<d> foo(vec<d> a, vec<d> b) { 
    return vec<d>(/* ... */); 
} 

template<unsigned d1, unsigned d2> 
vec<d1 + d2> bar(vec<d1> a, vec<d2> b) { 
    return vec<d1 + d2>(/* ... */); 
} 

int main(int argc, char** argv) { 
    point p1, p2; 
    vec<2> v2; 
    vec<3> v3; 
    foo(v2, p1); 
    foo(p2, v2); 
    foo(p1, p2); 
    bar(v3, p1); 
} 

有没有办法让这个代码自动转换从point到vec<2>？

我知道我可以超载foo和bar允许point参数，使用显式转换委托给vec实施。但是，对所有参数组合进行此操作将变得乏味，特别是对于具有许多此类参数的功能。所以我对解决方案不感兴趣，我必须为每个函数的每个参数组合重复代码。

看来，转换构造函数和转换运算符都不足以实现这一点。至少我的gcc 4.7.1报告了no matching function call，虽然它在一个通知中命名了所需的功能，说明‘point’ is not derived from ‘vec<d>’。

Answer 1

没有直接的方式来获得point到vec<2>转换，因为当函数调用foo(v1,p1)被处理的时候，期望一个vec<2>为第二个参数的函数foo还不存在。它只是一个函数模板，为了将其实例化为foo(const vec<2> &,const vec<2> &)，必须给出具有这些确切参数类型的函数调用。

为了工作代码，编译器将不得不猜测既如何实例化一个模板参数，和什么类型的point参数转换为。这在一般情况下是太多了（尽管在你的特定代码中它看起来很简单，因为没有其他可能的方法来解释程序员的意图）。

在解决这个方面，我能想到的唯一的事情就是创建高度模板转换功能：

template <typename T> 
struct make_vec 
{ }; 

template <unsigned d> 
struct make_vec<vec<d>> 
{ 
    static constexpr unsigned dim = d; 
    using type = vec<dim>; 

    static const type &from(const type &v) 
    { return v; } 
}; 

template <> 
struct make_vec<point> 
{ 
    static constexpr unsigned dim = 2; 
    using type = vec<dim>; 

    static type from(const point &p) 
    { return type(p); } 
}; 

template <typename T> 
typename make_vec<typename std::decay<T>::type>::type make_vec_from(T&& arg) 
{ return make_vec<typename std::decay<T>::type>::from(std::forward<T>(arg)); } 

，然后实现foo和bar用作一般模板（接受所有种类型，不仅vec<d>，使用上面定义make_vec给定的类型转换为右种vec<d>）：

namespace detail { 
    /* Your original implementation of foo. */ 
    template<unsigned d> vec<d> foo(vec<d>, vec<d>) { 
    return vec<d>(/* ... */); 
    } 
} 

/* Templated version of foo that calls the conversion functions (which do 
    nothing if the argument is already a vec<d>), and then calls the 
    foo() function defined above. */ 
template <typename T, typename... Ts> 
typename make_vec<typename std::decay<T>::type>::type foo(T&& arg, Ts&&... args) 
{ return detail::foo(make_vec_from(arg),make_vec_from(args)...); } 

在的情况下您还需要一种计算返回类型的方法，即vec<d1+d2+d3...>。为此，和运算是必需的，也是模板：

template <typename... Ts> 
struct dsum { 
    static constexpr unsigned value = 0; 
}; 

template <typename T, typename... Ts> 
struct dsum<T,Ts...> { 
    static constexpr unsigned value = make_vec<typename std::decay<T>::type>::dim + dsum<Ts...>::value; 
}; 

然后，bar()返回类型为vec<dsum<T,Ts...>::value>。

一个完全工作的例子是在这里：http://liveworkspace.org/code/nZJYu$11

不完全是简单的，但可能是值得的，如果你真的有争论非常多的不同的组合。