C++ 自动检测模板函数的返回类型

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

用于说明问题的测试代码：

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;
}

struct Float
{
静态浮点转换（int i）
{
返回浮点{static_cast（i）}；
}
浮动(f),；
};
结构整型
{
静态整数转换（INTI）
{
返回Int{i}；
}
int_i；
};
样板
T转换（int i）
{
返回T：：convert（i）；
}
int main（）
{
浮点f1=转换（10）；
Int i1=转换（10）；
//浮点f2=转换（10）；编译错误
//Int i2=转换（10）；编译错误
返回0；
}

---

p.S.模板让我疯狂，我想要但无法理解它们。

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

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

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

---

就像您想要的一样。

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

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

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

---

正如您所希望的。

为什么需要转换功能？您可以使用单参数构造函数来完成相同的工作

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
{
浮动（int i）
{
_f=静态铸件（i）；
}
浮动(f),；
};
结构整型
{
Int（Int i）
{
_i=静态铸件（i）；
}
int_i；
};
int main（）
{
浮动f2=10；
Int i2=10；
返回0；
}

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

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

    float _f;
};

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

struct Float
{
显式浮点（int i）
{
_f=静态铸件（i）；
}
浮动(f),；
};
int main（）
{
浮动f2=浮动（10）；
返回0；
}

---

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

为什么需要convert函数？您可以使用单参数构造函数来完成相同的工作

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
{
浮动（int i）
{
_f=静态铸件（i）；
}
浮动(f),；
};
结构整型
{
Int（Int i）
{
_i=静态铸件（i）；
}
int_i；
};
int main（）
{
浮动f2=10；
Int i2=10；
返回0；
}

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

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

    float _f;
};

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

struct Float
{
显式浮点（int i）
{
_f=静态铸件（i）；
}
浮动(f),；
};
int main（）
{
浮动f2=浮动（10）；
返回0；
}

---

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

模板选择“不带尖括号”需要参数推断。函数的返回类型不是参数。所以你可以放心，你不能从这里得到。模板选择“没有尖括号”需要参数推导。函数的返回类型不是参数。所以你可以放心，你不能从这里到那里。太好了。这可能是将函数模板化为其返回类型的唯一方法。这是个好把戏，我会记住的。好把戏。对我来说足够好了。只想用这种方式添加

Float f1=convert（10）

不起作用。但是它可以被替换为

Float f1=static_cast（convert（10））

@IvanRomanov-嗯，是的，这就是它的长短。你可以有一个，但不能有另一个，因为现在它不再是一个函数了。这可能是将函数模板化为其返回类型的唯一方法。这是个好把戏，我会记住的。好把戏。对我来说足够好了。只想用这种方式添加

Float f1=convert（10）

不起作用。但是它可以被替换为

Float f1=static_cast（convert（10））

@IvanRomanov-嗯，是的，这就是它的长短。你可以有一个，但不能有另一个，因为现在它不再是函数了。我不能使用构造函数。类必须支持聚合初始化。我也有很多类，我不想重复函数。全局

：：convert

函数执行一个常见的简单操作<代码>返回T:：convert（i*2）：：convert函数执行一个常见的简单操作<代码>返回T:：convert（i*2）例如。