Перегруженный оператор +

#include <iostream>
#include <string> 
using namespace std;
 
class mwork
{
public: 
    int m[]={5,6,7};
    int n[]={2,3,8};
    
public: 
    int operator + (const int & other) {
    int temp[];    
    for(int i=0;i<3;i++)
    temp[i]=m[i]+n[i];
    }
};
 
int main()
{
 mwork ooo;
 ooo.m = {5,6,7};
 ooo.n = {2,3,8};
 ooo.p = ooo.m+ooo.n;
}

#include <iostream>
 
using namespace std;
 
struct mwork
{
    int arr[3];
 
    mwork operator + (const mwork& other) const
    {
        mwork temp;
        for (int i = 0; i < 3; i++)
            temp.arr[i] = arr[i] + other.arr[i];
        return temp;
    }
};
 
int main()
{
    mwork m = { 5,6,7 };
    mwork n = { 2,3,8 };
    mwork p = m + n;
}

#include <iostream>
#include <vector>
 
using namespace std;
 
typedef vector<int> vec;
vec operator+(const vec& a, const vec& b)
{
    vec result;
 
    const size_t size = a.size();
    if (size == b.size())
    {
        for (size_t i = 0; i < size; i++)
        {
            result.push_back(a[i] + b[i]);
        }
    }
    return result;
}
 
    
int main()
{
    vec A = { 1, 2, 3 };
    vec B = { 4, 5, 6 };
 
    vec C = A + B + B;
 
    for (const int& c : C)
    {
        cout << c << " ";
    }
}

template<typename T>
std::vector<T> operator + (const std::vector<T>& left, const std::vector<T>& right)
{   
    using vec_t = std::vector<T>;
    const vec_t& max_size(left.size() > right.size() ? left : right);
    const vec_t& min_size(left.size() < right.size() ? left : right);
    vec_t result(max_size); // только одно копирование
    for (size_t i = 0; i < min_size.size(); i++)
    {
        result[i] += min_size[i];
    }
    return result;
}
 
template<typename T>
std::vector<T> operator + (std::vector<T> left, std::vector<T> right)
{   // от 0 до 2 копирований при передаче параметров
    std::vector<T> max_size(std::move(left.size() > right.size() ? left : right));
    std::vector<T> min_size(std::move(left.size() < right.size() ? left : right));
 
    for (size_t i = 0; i < min_size.size(); i++)
    {
        max_size[i] += min_size[i];
    }
    return max_size;
}

void f2(string s);         // bad: potentially expensive