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<TYPEv;

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<TYPEoperator()(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;

}

};