Operator () overloading, wrong overload gets called

Hi all,

    Im having a problem with my code. Im programming a vector class,
and am trying to overload the () operator in 2 different situations.
The first situation is to assign values, e.g. Y = X(1,2), the elements
1 and 2 of X gets assigned to Y. In this case, the operator ()
overload should create a copy that is unmodifiable. In the 2nd case, I
want do assign values to elements 1 and 2, e.g. X(1,2) = Y. Then in
this case, the values must be updated. I update by instantiating a
custom iterator class which has an overloaded = operator. Below is my
code. Sorry its a little long.

   The issue now is that when I do Y = X(1,2), I always end up calling
the overload that is meant for the 2nd situation, rather than the
first. I hope I can get some advice.

Thanks in advance.

//********************************************************
// Main Vector Class
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

    //********************************************************
    // VectorItr Class
    // this is a custom iterator class for Vector
    // it wraps the standard vector iterator class
    class VectorItr : public
std::iterator<std::random_access_iterator_tag, TYPE> {
        typename vector<TYPE>::iterator vitr;
        int n; int *ptr;
    public:

        //assignments
        VectorItr& operator= (const Vector<TYPE>& rhs) {
            //using the iterator, populate the Vector<TYPE>
            if (ptr == NULL) //for range
                rhs.assign(vitr,n,rhs);
            else {
                for (int k=0; k<n; k++)
                    *(vitr+ptr[k]) = rhs[k];
            }
            return *this; //should i return this?
        }

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

        VectorItr( Vector<TYPE>& val, const int& i, const int& j) {
            //this is used for range assignment
            //this constructor is used to initialize the beginning of the
            //iterator, and the number of elements that need to be assigned
            vitr = val.begin()+i; n = j-i+1; ptr = NULL;
        }

        VectorItr( Vector<TYPE>& val, int ind[], const int n2) {
            //this is used for index assignment
            //this constructor is used to initialize the beginning of the
            //iterator, and the number of elements that need to be assigned
            vitr = val.begin(); n = n2; ptr = &ind[0];
        }

    };

    const Vector<TYPE> operator()(const int& i, const int& j) const
    {
        return Vector<TYPE>(*this, i, j);
    }

    VectorItr operator()(const int& i, const int& j)
    {
        return VectorItr (*this, i, j);
    }

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

    //********************************************************
    // 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) {
        //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);
        }
    }
    //can i make an initialization that does something like v = {1, 2 3};

    //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;
    }

    //********************************************************
    // vector container functions
    void push_back(TYPE val) {v.push_back(val);}
    typename vector<TYPE>::iterator begin() { return v.begin();}
    typename vector<TYPE>::iterator end() { return v.end();}
    void assign(typename vector<TYPE>::iterator itr, const int& n, const
Vector<TYPE>& val) const {
        //Maybe I should group this under copiers
        for (int k=0; k<n; k++){
            *itr = val[k]; itr++;
        }
        //return *this; //should i return this?
    }

    template <size_t N> //trick to get array size in automatically!
    Vector<TYPE>& assign(int (&val)[N]) {
        v.assign(val, val+N);
        return *this;
    }

};