Operator () overloading, cannot return by value.

Hi All,

   Im a newbie to C++, I am trying to customize the vector template
STL to a template Class. My code is shown below. Im confused about
something and maybe somebody here might be able to help me.

   Lets say X is my vector, which contains 10 elements. I want to
assign elements indexed 2 to 5 to another vector Y, so I want to do it
like Y = X(2,5). So what I do is i overload the () operators, as
marked in (a) below. This creates a new intermidate Vector class Z,
via the constructor that is marked (b) below. The intermediate vector
class is returned to (a), which thens try to return by value. However
my memory always gets destroyed. This makes sense because I created a
variable which has scope only in (a).

   However, when I add to vectors X + Y, again an intermediate result
is created. This is done in (c) below. The X (lhs) argument is used to
call another constructor which then creates a copy Z, and adds Y (rhs)
to that copy Z. Now Z is then returned but it does not get destroyed.

   So to sum up, why does memory gets destroyed in the first case but
not in the second. And how to avoid this problem in the first case?

Thanks in advance.

/*------------------------------------------------
This is package for Vectors, Matrices (Template Class)
--------------------------------------------------*/
#include <iostream>
#include <vector>
#include <math.h>
#define to ,
using namespace std;

//********************** START: VECTOR *************************
template <typename TYPE>
class Vector {
    vector<TYPE> v;
public:
    //********************************************************
    // Selectors
    const TYPE& operator[](const int& k) const { return v[k]; } //default
[] indexing
    const TYPE& operator()(const int& k) const {return v[k];}
    int size() const {return v.size();} //returns the size

    const Vector<TYPE> operator()(const int& i,const int& j) <---- (a)
        return Vector<TYPE>(v, i, j);

    //********************************************************
    // Constructors and Destructor
    Vector() { };
    ~Vector(){ };

    //********************************************************
    //plus operation
    Vector<TYPE>& operator+=(const Vector<TYPE>& rhs){
        for (int k = 0; k < rhs.size(); k++){
            if (k < v.size())
                v[k] += rhs[k];
            else v.push_back(rhs[k]);
        }
        return *this;
    }

    //********************************************************
    // Copiers
    //copy constructors
    Vector( const Vector<TYPE>& val) { //copy constructor for
intermediate results (like x + y)
        for (int k = 0; k < val.size(); k++)
            v.push_back(val[k]);
    }
    Vector( const Vector<TYPE>& val, const int& i, const int& j)
{ <----- (b)
        //this constructor is used to create copy when indexing a range
        for (int k = i; k <=j; k++){
            if (k<val.size())
                v.push_back(val[k]);
            else v.push_back(0);
        }
    }

    //assignments
    Vector<TYPE>& operator=(const Vector<TYPE>& rhs) {
        v.clear();
        for (int k = 0; k < rhs.size(); k++)
            v.push_back(rhs[k]);
        return *this;
    }
};

//********************************************************
//plus operation
template <typename TYPE>
inline const Vector<TYPE> operator+(const Vector<TYPE>& lhs, const
Vector<TYPE>& rhs)
{
    return Vector<TYPE>(lhs) += rhs; <----- (c)
}

//********************** END: VECTOR *************************