Question

我想知道是否有办法解决这个问题，或者至少是一种更好的方法来完全使用模板：

template <typename T, typename U>
double sum(const vector<T>& vt, const vector<U>& vu)
{
    // . . .
    double sum = 0;
    for (int i = 0; i < size; ++i)
        sum += convert(vt[i] * vu[i]);
    return sum;
}

T和U应该是数字，例如double，int或支持这些操作的任何其他类（我不熟悉模板）。

有没有办法摆脱这个convert()函数（获取特定类的数字成员）并只写sum += vt[i] * vu[i]？

Answer 1

如果您为所有double和{{1>将隐式转换运算符定义为double（或一个double以及其他类型，可以提升为T） }}，U和vt[i]将转换为vu[i] s，乘法结果将为double，就像您想要的那样。

示例：

double

但你必须决定返回什么。

Answer 2

我认为你有点希望。

template <typename T, typename U, typename resultType = double >
resultType sum(const vector<T>& vt, const vector<U>& vu)
{
    // . . .
    resultType sum = 0;
    for (size_t i = 0; i < vt.size(); ++i) {
        // two versions of sum - coerced to resultType before and after
        // multiplication
        sum += static_cast<resultType>(vt[i]) * static_cast<resultType>(vu[i]);
        sum += static_cast<resultType>(vt[i] * vu[i]);
    }
    return sum;
}

sum+=的2个版本会产生不同的结果。如果sum是一个整数，则可能发生截断。

在double和int之间的乘法中，类型提升发生在一个中，但在另一个中被标准化。

更新

使用resultType = double T和U是双倍的 - 然后结果是相同的。

T是整数U是双。 T被提升为两倍，结果是一样的。

T和U是整数。 sum += static_cast<double>( vt[i] * vu[i] );乘以整数，可能溢出并返回不同的结果。

使用resultType = int

T和U是double - 结果是数字的整数截断，或结果的整数截断。

static_cast（5.3）* static_cast（3.7）; =＆GT; 15

static_cast（5.3 * 3.7）; =＆GT; static_cast（19.61）=＆gt; 19

T是整数U是双。如上 T和U是整数。两者都是一致的。

有一个班级和一个

operator double() const { return value; }

正如其他帖子中所建议的那样，第一个总和+ =将起作用，而第二个总和依赖于至少一个数字类型，因此编译器可以尝试显式的double转换。

使用两个class，sum += static_cast<resultType>(vt[i]) * static_cast<resultType>(vu[i]);将成功找到double运算符，但sum += static_cast<resultType>(vt[i]) * static_cast<resultType>(vu[i]);将失败。

还有

等功能

operator *( const class X &lhs, const class U & rhs )
{

    return static_cast<double>(lhs) * static_cast<double>(rhs);
}

有助于编译器。

Answer 3

为什么不使用数字标题中定义的inner_product（）算法？

内积算法计算两个相同长度序列的内积。返回的值类型由第四个参数确定。

#include <numeric>
#include <iostream>
#include <vector>
#include <functional>
#include <iomanip> 

int main()
{
    using namespace std;
    vector<double> a{0, 1.1, 2, 3.1, 4};
    vector<int> b{5, 4, 2, 3, 1};

    double r1 = inner_product(begin(a), end(a), begin(b), 0.0);
    cout << setiosflags(ios::fixed)  << std::setprecision(5)
              << "Inner product of a and b: " << r1 << '\n';


}

Answer 4

如果您希望能够撰写sum += vt[i] * vu[i];，则必须定义 ad-hoc 产品，以定义T和U的产品通过在这些类型上提供double转换运算符或这些类型的某种组合，为这些类型返回double。

定义从类到双精度的转换

4 个答案:

更新