Question

我有一些带有函数的类。在所有类中，函数具有相同的名称和参数类型，但返回类型不同。我需要一些模板功能，可以自动检测正确的模板替换而无需尖括号。

测试代码来说明问题：

struct Float
{
    static Float convert(int i)
    {
        return Float{static_cast<float>(i)};
    }

    float _f;
};

struct Int
{
    static Int convert(int i)
    {
        return Int{i};
    }

    int _i;
};

template<typename T>
T convert(int i)
{
    return T::convert(i);
}


int main()
{
    Float f1 = convert<Float>(10);
    Int i1 = convert<Int>(10);

    // Float f2 = convert(10); compilation error
    // Int i2 = convert(10); compilation error

    return 0;
}

P.S。模板让我疯狂但我无法理解它们。

Answer 1

不确定它是否完全符合您的需求，但您可以使用类和模板化转换运算符模拟您想要的内容：

class convert {
    int arg;
public:
    convert(int arg) : arg(arg) {}

    template<class T>
    operator T() const {
      return T::convert(arg);
    }
};

由于模板参数推导适用于模板化转换运算符，您可以这样写：

Float f1 = convert(10);
Int i1 = convert(10);

就像你想要的那样。

Answer 2

为什么需要转换功能？您可以使用单个参数构造函数执行相同的工作。

struct Float
{
    Float(int i)
    {
        _f =  static_cast<float>(i);
    }

    float _f;
};

struct Int
{
    Int(int i)
    {
        _i = static_cast<int>(i);
    }

    int _i;
};

int main()
{
    Float f2 = 10;
    Int i2   = 10;

    return 0;
}

如果您担心对构造函数的隐式调用，可以将其设为显式

struct Float
{
    explicit Float(int i)
    {
        _f =  static_cast<float>(i);
    }

    float _f;
};

int main()
{
    Float f2 = Float(10);
    return 0;
}

如果具有相同名称和相同类型的输入参数的函数可以生成不同的返回类型，则会影响代码的可读性。

自动检测返回类型的模板功能

2 个答案: