避免隐式转换

>我正在做一个项目，该项目需要为大数字库提供一个通用C++包装器，如果库提供这样的 C 样式函数：

//assignment
lib_set(lib_type data, lib_type input);
lib_set_si(lib_type data, long input);
lib_set_ui(lib_type data, unsigned long input);
//addition
lib_add(lib_type data, lib_type input);
lib_add_ui(lib_type data, unsigned long input);

为了避免在不需要的时候创建临时对象，我最终得到了这样的东西：

class wrapper
{
private:
    lib_type data;
public:
    wrapper()
    {
        lib_set_ui(this->data, 0UL);
    }
    wrapper (const wrapper &input)
    {
        lib_set(this->data, input.data);
    }
    wrapper (const long input)
    {
        lib_set_si(this->data, input);
    }
    wrapper (const unsigned long input)
    {
        lib_set_ui(this->data, input);
    }
    wrapper &operator+= (const wrapper &input)
    {
        lib_add(this->data, input.data);
        return *this;
    }
    wrapper &operator+= (const unsigned long input)
    {
        lib_add_ui(this->data, input);
        return *this;
    }
};

不幸的是，如果我这样做：

wrapper x(2);
x += -2;

编译器（GCC/VS2010）甚至不会发出警告，说我正在尝试隐式地unsigned long int，这绝对不是我想要得到的......

那么，在这种情况下，我将如何重载 wrapper 类的运算符，以便在不需要时不需要创建临时wrapper对象？如果我删除wrapper &operator+= (const unsigned long input)重载，那么我将不得不使用这样的东西：

wrapper x(2);
x += wrapper(-2);
x += -2;//implicitly casts -2 to wrapper

但我认为我不能依赖编译器可能能够优化掉额外对象的事实......