Типы данных в ООП

type& operator +(type &T1, type& T2)
{
    type T(T1);
    /*прибавляем к T, T2*/
   return T;
}

#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <stdexcept>
#include <cstring>
////////////////////////////////////////////////////////////////////////////////
template <class T>
class Foo
{
    std::size_t _size;
    std::size_t _realSize;
    T*          _arr;
    //--------------------------------------------------------------------------
    static const std::size_t STEP = 50;
    //--------------------------------------------------------------------------
public:
    explicit Foo(const std::size_t& size):
        _size(size),
        _realSize(STEP > size ? STEP : size + STEP),
        _arr(new T[_realSize])
    {
 
    }
    //--------------------------------------------------------------------------
    explicit Foo(): Foo(0)
    {
 
    }
    //--------------------------------------------------------------------------
    ~Foo()
    {
        delete[] _arr;
    }
    //--------------------------------------------------------------------------
    void push_back(const T elem)
    {
        if(_size == _realSize)
        {
            T* tmp = new T[_realSize];
            std::memcpy(tmp, _arr, _realSize * sizeof(T));
            delete[] _arr;
            _arr = new T[_realSize + STEP];
            std::memcpy(_arr, tmp, _realSize * sizeof(T));
            delete[] tmp;
            _realSize += STEP;
        }
        _arr[size++] = elem;
    }
    //--------------------------------------------------------------------------
    T& at(const std::size_t pos) const
    {
        if(_size > pos)
            return _arr[pos];
        else
            throw std::out_of_range("pos >= size");
    }
    //--------------------------------------------------------------------------
    const std::size_t size() const
    {
        return _size;
    }
    //--------------------------------------------------------------------------
    const Foo<T> operator+ (const Foo<T>& f)
    {
        Foo<T> ret(std::max(f.size(), _size));
 
        const std::size_t min = std::min(f.size(), _size);
        const std::size_t max = std::max(f.size(), _size);
 
        for(std::size_t i = 0; i < min; ++i)
            ret.at(i) = _arr[i] + f.at(i);
 
        for(std::size_t i = min; i < max; ++i)
            ret.at(i) = _arr[i];
 
        for(std::size_t i = min; i < max; ++i)
            ret.at(i) = f.at(i);
 
        return ret;
    }
    //--------------------------------------------------------------------------
    Foo& operator= (const Foo& f)
    {
        _size = f.size();
        if(_realSize)
            delete[] _arr;
        _realSize = f._realSize;
        _arr = new T[_realSize];
        std::memcpy(_arr, f._arr, _realSize * sizeof(T));
    }
};
////////////////////////////////////////////////////////////////////////////////
int main()
{
    Foo<int> f1(3);
    Foo<int> f2(5);
    for(std::size_t i = 0; i < 3; ++i)
        f1.at(i) = i;
    for(std::size_t i = 0; i < 5; ++i)
        f2.at(i) = i * 2;
    Foo<int> f3 = f1 + f2;
    for(std::size_t i = 0; i < 5; ++i)
        std::cout << f3.at(i) << " ";
    std::cout << std::endl;
    return 0;
}