Question

我正在尝试为我的编程任务实现Euclidean向量。我需要重载operator *来为具有任意相同维度的两个向量提供点积计算。以3D矢量为例：

矢量＆lt; 3＆GT; v1，v2; //两个3D矢量。

double dotProduct = v1 * v2;

dotProduct的值应为v1 [0] * v2 [0] + v1 [1] * v2 [1] + v1 [2] * v2 [2]

所以，我的问题是如何在numeric.h头文件中不使用任何显式循环和std :: accumulate（）操作来获取此值？因为这项任务禁止这些。

P.S。我可以将算子（自定义）与STL算法一起使用。

Answer 1

如果你真的想要避免使用显式循环和算法（不只是std::accumulate），你可以使用std::valarray代替：

std::valarray<double> a;
std::valarray<double> b;

// code to put data in a and b goes here

double dotProduct = (a * b).sum();

我在这里使用double作为类型，但你可以（当然）使用对你正在处理的数据/情况有意义的任何类型。

Answer 2

您可以使用std::inner_product，请参阅http://en.cppreference.com/w/cpp/algorithm/inner_product

double dotProduct = std::inner_product(v1.begin(), v1.end(), v2.begin());

Answer 3

如果您不能使用显式循环，也许您的老师要求您使用递归。

template<int N>
int VectorSum(const Vector<N>& v1, const Vector<N>& v2, int m) {
  if(m) return v1[m]*v2[m] + VectorSum(v1, v2, m-1);
  return v1[0]*v2[0];
}

template<int N>
int operator+(const Vector<N>& v1, const Vector<N>& v2) {
  return VectorSum(v1, v2, N-1);
}

Answer 4

我碰巧读了一篇关于它的文字，所以我把它复制给你。可能是它在书中介绍：C ++模板：完整指南。

#include <iostream>

template<int DIM,typename T>
struct DotProduct {
    static T execute(const T v1[],const T v2[]);
};
template<int DIM,typename T>
T DotProduct<DIM,T>::execute(const T v1[],const T v2[]) {
    return v1[0]*v2[0] + DotProduct<DIM-1,T>::execute(v1+1,v2+1);
};

template<typename T>
struct DotProduct<1,T> {
    static T execute(const T v1[],const T v2[]);
};

template<typename T>
T DotProduct<1,T>::execute(const T v1[],const T v2[]) {
    return v1[0]*v2[0];
};

int main()
{
    int v1[] = {1,2,3}; 
    int v2[] = {4,5,6};
    int r2 = DotProduct<3,int>::execute(v1,v2);
    std::cout << r2 << std::endl;
    return 0;
}

如何在不使用循环或std :: accumulate（）的情况下计算向量的总和？

4 个答案: