如何让带转换构造函数的wrapper<int>在重载决议中优先于wrapper<double>

问题背景 #

我正在设计一个wrapper模板类，用于处理带特殊逻辑的算术参数。初始代码运行正常：

#include <stdio.h>

template <class T>
struct wrapper {
    wrapper(const T& o): value(o) {}
    T value;
};

void func(wrapper<int> a) {
    printf("int: %d\n", a.value);
}

int main () {
    func(1); // 输出 int: 1
    func(1.0); // 输出 int: 1
}

但添加func(wrapper<double>)重载后，调用func(1)出现编译歧义：

#include <stdio.h>

template <class T>
struct wrapper {
    wrapper(const T& o): value(o) {}
    T value;
};

void func(wrapper<int> a) {
    printf("int: %d\n", a.value);
}

void func(wrapper<double> a) {
    printf("double: %.2f\n", a.value);
}

int main () {
    func(1); // 编译报错：重载调用歧义
    // func(1.1);
}

编译器报错信息：

<source>: In function 'int main()':
<source>:18:9: error: call of overloaded 'func(int)' is ambiguous
   18 |     func(1);
      |     ~~~~^~~
<source>:9:6: note: candidate: 'void func(wrapper<int>)'
    9 | void func(wrapper<int> a) {
      |      ^~~~
<source>:13:6: note: candidate: 'void func(wrapper<double>)'
   13 | void func(wrapper<double> a) {
      |      ^~~~

问题原因 #

传入int类型的1时，编译器有两条等价的隐式转换路径：

• 路径1：int直接转换为wrapper<int>（仅一次用户定义转换）
• 路径2：int先转换为double（标准转换），再转换为wrapper<double>（用户定义转换）
  这两条转换序列的优先级相同，导致重载决议无法确定调用哪个版本。

解决方案 #

方法一：区分构造函数的匹配优先级（无需修改调用代码） #

修改wrapper类，添加精确匹配类型的构造函数，让精确转换的优先级高于跨类型转换：

#include <stdio.h>

template <class T>
struct wrapper {
    // 精确匹配T类型的构造函数，优先级最高
    wrapper(T o) : value(o) {}

    // 处理跨类型转换的模板构造函数，优先级较低
    template <class U>
    wrapper(const U& o) : value(static_cast<T>(o)) {}

    T value;
};

void func(wrapper<int> a) {
    printf("int: %d\n", a.value);
}

void func(wrapper<double> a) {
    printf("double: %.2f\n", a.value);
}

int main () {
    func(1); // 输出 int: 1，优先匹配wrapper<int>
    func(1.1); // 输出 double: 1.10
    func(2.0); // 输出 int: 2，保留原有跨类型转换逻辑
}

原理：当传入int时，wrapper<int>的精确构造函数匹配度更高，转换序列更短，编译器会优先选择对应的func重载；跨类型转换的逻辑依然保留，不影响原有功能。

方法二：使用显式构造函数（需修改调用代码） #

给wrapper的构造函数添加explicit关键字，强制调用时显式指定类型，从根源避免隐式转换歧义：

#include <stdio.h>

template <class T>
struct wrapper {
    explicit wrapper(const T& o): value(o) {}
    T value;
};

void func(wrapper<int> a) {
    printf("int: %d\n", a.value);
}

void func(wrapper<double> a) {
    printf("double: %.2f\n", a.value);
}

int main () {
    func(wrapper<int>(1)); // 显式构造wrapper<int>
    func(wrapper<double>(1.1)); // 显式构造wrapper<double>
}

优点：代码更清晰，避免隐式转换带来的意外问题；缺点：需要修改所有调用func的代码。

内容的提问来源于stack exchange，提问作者xujh