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

template<class T> T& vec_func(vector<T>& v, vector<T>& vv) {
    vector<T> local_vec(v.size());
    T sum;
    if (v.size()==vv.size()) {
        for (int i=0; i<v.size(); ++i) {
            local_vec[i] = v[i] + vv[i];
        }   
    }
    if (v.size()!=vv.size()) {
            cout << "The sizes of vectors aren't equal!";
            return -1;
        }
 
}

template<class T> 
typename vector<T>::iterator vec_func(vector<T>& v, vector<T>& vv)

template<class T> vector<T> * addition_of_vectors(vector<T>& first_vector,
        vector<T>& second_vector) {
    vector<T> *addition_result_vector = 0; // = NULL; or = nullptr; depends on using c++ standart
    if (first_vector.size() == second_vector.size()) {
        addition_result_vector = new vector<T>(first_vector.size());
        for (int i = 0; i < first_vector.size(); ++i) {
            addition_result_vector[i] = first_vector[i] + second_vector[i];
        }
    } else {
        cout << "The sizes of vectors aren't equal!";
    }
    return addition_result_vector;
}

 addition_result_vector[i] = first_vector[i] + second_vector[i];

(*addition_result_vector)[i] = first_vector[i] + second_vector[i];

    std::vector<int> first_integer_vector;
    first_integer_vector.push_back(5);
    first_integer_vector.push_back(20);
    std::vector<int> second_integer_vector;
    second_integer_vector.push_back(11);
    second_integer_vector.push_back(3);
 
    std::vector<int> *pointer_to_addition_result_vector = addition_of_vectors(
            first_integer_vector, second_integer_vector);

template<class T> vector<T>& sum_of_vectors(vector<T>& first, vector<T>& second) {
    vector<T> some_vector(first.size());
    if (first.size() == second.size()) {
        for (int i=0; i<first.size(); ++i) {
            some_vector[i] = first[i] + second[i];
        }
 
    }
    else {
        cout << "Sizes of vector are not equal!"; 
        return -1;
    }
    return some_vector;
}

int main() {
    vector<int> v1;
    vector<int> v2;
    for (int i=0; i<5; ++i) {
        v1.push_back(i*2);
        v2.push_back(i*3);
    }
 
 
    vector<int> some_one = sum_of_vectors(v1, v2);
    
 
    system("pause");
        
}

template<class T> vector<T>& sum_of_vectors(vector<T>& first, vector<T>& second) {
    vector<T> some_vector(first.size());

    return -1;
    }
    return some_vector;

vector<T>&

 const int  к vector<int>

vector<int>* some_vector = addition_of_vectors(v1, v2);

vector<int> v1;
vector<int> v2;
    for (int i=0; i<5; ++i) {
        v1.push_back(i*2);
    }
 
    for (int i=0; i<6; ++i) {
        v2.push_back(i*3);
}

vector<int>* some_vector = addition_of_vectors(v1, v2);

vector<int> v1;
vector<int> v2;
    for (int i=0; i<5; ++i) {
        v1.push_back(i*2);
    }
 
    for (int i=0; i<6; ++i) {
        v2.push_back(i*3);
        }

vector<int>* some_vector

 addition_result_vector = new vector<T>(first_vector.size());

template <typename T>
std::vector<T>* vec_fun(const std::vector<T>& v, const std::vector<T>& v2)
{
    std::vector<T>* local_vec = new std::vector<T>(v.size());
    
    /* some code */
    
    return local_vec;
}

  addition_result_vector = new vector<T>(first_vector.size());

 if (pointer_to_addition_result_vector) {   //Only if function returned some address
        cout << "Result vector pointer : " << pointer_to_addition_result_vector
                << endl;
        for (int i = 0; i < (*pointer_to_addition_result_vector).size(); ++i) {
 
            cout << "result[" << i << "] = "
                    << (*pointer_to_addition_result_vector)[i] << endl;
        }
        delete pointer_to_addition_result_vector; // prevent memory leaks

(*addition_result_vector)[i] = first_vector[i] + second_vector[i];

*(addition_result_vector)[i] = first_vector[i] + second_vector[i];

template<class T>
vector<T> * vec_func(vector<T> & result
                     , vector<T> const & first_vector
                     , vector<T> const & second_vector)
{
    size_t firstSize = first_vector.size();
    if (firstSize == second_vector.size())
    {
        result.resize(firstSize);
        for (size_t i = 0; i < firstSize; ++i)
        {
            result[i] = first_vector[i] + second_vector[i];
        }
    }
    else
    {
        cout << "The sizes of vectors aren't equal!";
    }
    return &result;
}
 
int main(int argc, char* argv[])
{
    vector<int> a;
    //....
    vector<int> b;
 
    vector<int> res;
    //...
    vector<int> * resP = vec_func(res, a, b);
}

addition_result_vector = new vector<T>(first_vector.size());

addition_result_vector = new vector<T>(first_vector.size());