为什么这两种矢量加法有区别？ 我已经写了两种在C++中添加多个向量的方法。输入参数是多个向量

方法1：添加简单方法

此方法包含一个add1函数，该函数被递归调用，并通过使用循环添加两个向量，直到参数的尾部被添加到一起。存储在临时向量中的每个向量相加的结果

此方法的一部分包含添加功能代码：

template<typename V, typename T>
std::vector<V> function(const std::vector<V>& left1, const std::vector<T>& right1)
{
    std::vector<double> temp(left1.size());
    for (int i=0; i<(int)left1.size(); i++)
        temp1[i] = left1[i] + right1[i];
    return temp1;
}

模板
std:：vector函数（const std:：vector和left1，const std:：vector和right1）
{
std:：vector temp（left1.size（））；
对于（inti=0；iYes），分配内存的速度很慢

以下是一个更有效的解决方案：

template<class T0, class...Ts>
std::vector<T0>& increment( std::vector<T>& V0, std::vector<Ts> const&... Vs){
  for( T0& e:V0 ){
    auto i=std::addressof(e)-V0.data();
    (e+= ... +=Vs[i]); // binary left fold
  }
  return V0;
}
template<class T0, class...Ts>
std::vector<T0> add( std::vector<T> V0, std::vector<Ts> const&.. Vs){
  increment(V0, Vs...);
  return std::move(V0);
}

这样才能有效地添加

然后努力使两个参数的增量更有效。
原因是什么？第一个方法比第二个方法花费的时间更长。--关于某个操作或函数花费的时间长度的问题应附有1）使用编译器，2）用于编译程序的设置，即优化，3）a演示测试代码。我认为您的怀疑是正确的。方法1创建N个临时向量，方法2只创建结果向量。似乎足够清楚。要扩展@M.a的建议：
template std:：vector add\u vectors（std:：vector result，const Rest&Rest…{std:：transform（result.begin（），result.end（），Rest.begin（），result.begin（），std:：plus{}）；（return result；）
在这里发布时是否更改了名称？add1的定义在哪里？
template<typename V, typename ... T>
std::vector<V> add_vectors_singleloop(
    const std::vector<V>& first, const T&... rest)
{
    std::vector<V> result_vec(first.size());
    std:: vector size_vec = (int)(first.size());
    for (int i = 0 ; i < size_vec ; i++)
    {   
        result_vec[i] = add_elems(i, first, rest...);
    }
    return result_vec;
}

template<class T0, class...Ts>
std::vector<T0>& increment( std::vector<T>& V0, std::vector<Ts> const&... Vs){
  for( T0& e:V0 ){
    auto i=std::addressof(e)-V0.data();
    (e+= ... +=Vs[i]); // binary left fold
  }
  return V0;
}
template<class T0, class...Ts>
std::vector<T0> add( std::vector<T> V0, std::vector<Ts> const&.. Vs){
  increment(V0, Vs...);
  return std::move(V0);
}

template<class T0, class T1>
std::vector<T0>& increment( std::vector<T>& V0, std::vector<T1> const& V1){
  for( T0& e:V0 ){
    auto i=std::addressof(e)-V0.data();
    e+= V1[i];
  }
  return V0;
}
template<class T0, class...Ts>
std::vector<T0>& increment( std::vector<T>& V0, std::vector<Ts> const&... Vs){
  ((void)increment(V0, Vs), ...);
  return V0;
}