Сложение двух векторов и запись результата в третий вектор

#include <iostream>
#include <vector>
 
int main()
{
    float q=0, summ [5];
    std::vector<float> v;
    std::vector<float> c;
    std::vector<float> x;
    for (int i=0; i<5; ++i){
    std::cout<<"Vvedite v["<<i<<"] ";
    std::cin>>q;
    v.push_back(q);
    }
    //for (int i=0; i<v.size(); ++i)
    //std::cout<<v[i]<<std::endl;
    std::cout<<std::endl;
    for (int i=0; i<5; ++i){
    std::cout<<"Vvedite c["<<i<<"] ";
    std::cin>>q;
    c.push_back(q);
    }
    //for (int i=0; i<c.size(); ++i)
    //std::cout<<c[i]<<std::endl;
    std::cout<<std::endl;
    for (int i=0; i<5; ++i){
        summ[i]=v[i]+c[i];
        x.push_back(summ[i]);
    }
    for (int i=0; i<x.size(); ++i)
    std::cout<<x[i]<<std::endl;
    std::cin.get();
    return 0;
}

for (int i=0; i<5; ++i){
        x[i]=v[i]+c[i];
    }

#include <iostream>
#include <ctime>
#include <vector>
#include <algorithm>
#include <iterator>
 
void show (const std::vector <float> &);
 
int main (void)
{
    const int SIZE=5;
    std::vector <float> A;
    std::vector <float> B;
    std::vector <float> REZULT (SIZE);
 
    float tmp;
    // fill vector A
    for (int i=0; i<SIZE; i++) {
        std::cout << "A[" << i <<"]: ";
        std::cin >> tmp;
        A.push_back (tmp); }
    // fill vector B
    for (int i=0; i<SIZE; i++) {
        std::cout << "B[" << i <<"]: ";
        std::cin >> tmp;
        B.push_back (tmp); }
    // 
    std::vector <float> :: iterator A_=A.begin();
    std::vector <float> :: iterator B_=B.begin();
    std::vector <float> :: iterator REZULT_=REZULT.begin();
 
    for (REZULT_; REZULT_!=REZULT.end(); REZULT_++, A_++, B_++)
        *(REZULT_)=*(A_) + *(B_);
    // output
    std::cout << "Vector A: ";
    show (A);
    std::cout << "Vector B: ";
    show (B);
    std::cout << "Vector REZULT: ";
    show (REZULT);
 
    system ("pause");
    return 0;
}
 
void show (const std::vector <float> &vec)
{
    std::copy (vec.begin(), vec.end(), std::ostream_iterator <int> (std::cout, " "));
    std::cout << std::endl;
}

x.push_back(v[i] + c[i]);

/////////////////////////////////////////////////////////////////////////
//  Сложение векторов.
/////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <functional>
/////////////////////////////////////////////////////////////////////////
typedef float                      T_float_elem;
typedef std::vector<T_float_elem>  T_float_nums;
typedef std::string                T_str;
/////////////////////////////////////////////////////////////////////////
T_float_nums  input_float_nums(const T_str&  vect_name, int vect_size)
{
    struct T_input_num
    {
        T_str  name_;
        int    count_;
        //---------------------------------------------------------------
        T_input_num(T_str  name) : name_(name), count_(0)
        {};
        //---------------------------------------------------------------
        void operator() (T_float_elem&  elem)
        {
            std::cout << name_
                      << '['
                      << ++count_
                      << ']'
                      << " = ";
            std::cin >> elem;        
        }
    };
    T_float_nums  float_nums(vect_size);
    std::for_each(float_nums.begin(), float_nums.end(), T_input_num(vect_name));
    return  float_nums;
}
/////////////////////////////////////////////////////////////////////////
T_float_nums  operator+ (const T_float_nums& v1, const T_float_nums& v2)
{ 
    int  min_size = std::min(v1.size(), v2.size());
    T_float_nums  v_res(min_size);
    std::transform(v1.begin(), v1.begin() + min_size, 
                   v2.begin(), v_res.begin(), std::plus<T_float_elem>());
    return v_res;
}
/////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    std::cout << "Введите размерность векторов: ";
    int vect_size;
    std::cin >> vect_size;
    T_float_nums  V1 = input_float_nums("V1", vect_size);
    std::cout << std::endl;
    T_float_nums  V2 = input_float_nums("V2", vect_size);
    T_float_nums  V_sum = V1 + V2;
    std::cout << std::endl
              << "Сумма векторов: "
              << std::endl;
    std::copy(V_sum.begin(), V_sum.end(), 
              std::ostream_iterator<T_float_elem>(std::cout, "\n"));
    std::cout << std::endl;
    return 0;
}

std::locale::global(std::locale(""));

template<class T> 
vector<T> sumvectors(vector<T>& v1, vector<T>& v2)
{
    int min_size = std::min(v1.size(), v2.size());
    int max_size = std::max(v1.size(), v2.size());
    
    vector<T> res(min_size);
        
    std::transform(v1.begin(), v1.begin() + min_size, v2.begin(), res.begin(), std::plus<T>());
 
    //дополняем результирующий вектор оставшимися значениями после elem + min_size
    for (int i = 0; (v1.begin() + min_size + i) != v1.end(); i++)
        res.push_back(*(v1.begin() + min_size + i));
    
    for (int i = 0; (v2.begin() + min_size + i) != v2.end(); i++)
        res.push_back(*(v2.begin() + min_size + i));
 
    return res;
 
}

#include <iostream>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::vector     < int   >   T_int_values;
///////////////////////////////////////////////////////////////////////////////
template < typename TT_cont >
TT_cont     cont_sum
    (
        TT_cont     const   &   A,
        TT_cont     const   &   B
    )
{
    auto    A_is_greater    (
                                A.size()    >=  B.size()
                            );
 
    TT_cont     res     =   A_is_greater
                                ?   A
                                :   B;
 
    auto    res_elem_it     =   res.begin();
 
    for (
            auto    elem    :   A_is_greater
                                    ?   B
                                    :   A
        )
    {
        (*res_elem_it++)    +=  elem;
    }
 
    return res;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    auto    v   =   cont_sum    (
                                    T_int_values{ 10,   10          },
                                    T_int_values{ 1,    1,  1,  1   }
                                );
 
    for( auto   elem    :   v )
    {
        std::cout   <<  elem    <<  '\t';
    }
 
    std::cout   <<  std::endl;
}