模板化时未发生隐式转换答案

【问题标题】：Implicit conversion not happening when I templatize模板化时未发生隐式转换
【发布时间】：2010-12-04 02:44:55
【问题描述】：

这里有几个相关但不同的类。一个包含浮动列表；一个只包含一个。有时我想，说，将这些相乘。在这种情况下，我想将非列表“提升”为列表。这是代码，它的工作方式正是我想要的。

#define LIST_SZ 4

class Vec1;

class Vec1_list {

    public:
        Vec1_list() {}
        Vec1_list(const Vec1& in);

        float x[LIST_SZ];
};

class Vec1 {

    public:
        Vec1() {}
        Vec1(const float& in);

        float x;
};

Vec1::Vec1(const float& in) {
    x = in;
}

Vec1_list::Vec1_list(const Vec1& in) {
    for (int i = 0; i < LIST_SZ; i++) {
        x[i] = in.x;
    }
}

Vec1_list operator*(const Vec1_list& a, const Vec1_list& b) {
    Vec1_list tmp;

    for (int i = 0; i < LIST_SZ; i++) {
        tmp.x[i] = a.x[i]*b.x[i];
    }

    return tmp;
}

int main(void) {
    Vec1 v1;
    Vec1_list v2, v3, answer;

    answer = v1*v3;
}

但现在说我想这样模板化它......

#define LIST_SZ 4

template <typename T> class Vec1;

template <typename T>
class Vec1_list {

    public:
        Vec1_list() {}
        Vec1_list(const Vec1<T>& in);

        T x[LIST_SZ];
};

template <typename T>
class Vec1 {

    public:
        Vec1() {}
        Vec1(const T& in);

        T x;
};

template <typename T>
Vec1<T>::Vec1(const T& in) {
    x = in;
}

template <typename T>
Vec1_list<T>::Vec1_list(const Vec1<T>& in) {
    for (int i = 0; i < LIST_SZ; i++) {
        x[i] = in.x;
    }
}

template <typename T>
Vec1_list<T> operator*(const Vec1_list<T>& a, const Vec1_list<T>& b) {
    Vec1_list<T> tmp;

    for (int i = 0; i < LIST_SZ; i++) {
        tmp.x[i] = a.x[i]*b.x[i];
    }

    return tmp;
}

int main(void) {
    Vec1<float> v1;
    Vec1_list<float> v2, v3, answer;

    answer = v1*v3;
}

'mult' 导致编译器这次阻塞 - 它不会自动调用我的 Vec1 -> Vec1_list 构造函数。这是 C++ 中的一个事实，还是我可以使用一些方法来自动发生这种情况？另一种选择是我需要大量的功能。

【问题讨论】：

标签： c++ templates type-conversion

【解决方案1】：

您必须将operator* 声明为Vec1_list 类的友元，以便在Vec1_list 实例化时将其实例化，然后进行转换。

编辑：为此，请将 operator* 定义移动到 Vec1_list 类模板声明中：

friend static Vec1_list operator*(const Vec1_list& a, const Vec1_list& b){
    /* ... */
}

【讨论】：

【解决方案2】：

模板参数推导不考虑您通过转换构造函数进行的用户定义转换。

模板推导试图找到函数模板参数的替换，使参数化类型相同到参数类型。如果不能，则允许（我在这里简化）：const / volatile 限定修改或“派生到基”指针转换。

这在标准 [temp.deduct.call] 的第 14.8.2.1/3 节中有描述。

【讨论】：

【解决方案3】：

我不知道为什么它没有提升到所需的Vec1_list。但如果不可能，那么总是可以这样做：

template <typename T>
Vec1_list<T> operator*(const Vec1<T>& a, const Vec1_list<T>& b) {

    return Vec1_list<T>(a)*b;;
}

顺便说一句，我还在挖掘原来的问题。

【讨论】：