runtime error

[aortizb]

Hi all,

Can somebody tell me why this code does not work and how to fix it? It compiles but runtime errors appear:

#include <iostream>
#include <vector>
using namespace std;  

template <class T>
class Vec
{
public:
  // constructors
  Vec(int length); 
  Vec(int length, T typeValue); 
  Vec(const Vec<T>& rhsObj); 
  const Vec<T>& operator=(const Vec<T>& rhsObj);
  const Vec<T>& operator=(T& typeValue);
  const Vec<T>& operator*=(T typeVal);
  const Vec<T> operator*(T typeVal) const;
  const T& operator()(int index) const;
  T& operator()(int index);
  int getSize() const;
  ~Vec();
private:
  vector<T> myVec_;
};


template<class T> 
Vec<T>::
Vec(int length)
{
  myVec_ = vector<T>(length);
}

template<class T> 
Vec<T>::
Vec(int length, T typeValue)
{
  myVec_ = vector<T>(length,typeValue);
}

template<class T> 
Vec<T>::
Vec(const Vec<T>& rhsObj) 
{
  vector<T> myVec_(rhsObj.myVec_);
}

template<class T> 
const Vec<T>& 
Vec<T>::
operator=(const Vec<T>& rhsObj)
{
  myVec_ = rhsObj.myVec_;
  return *this;
}

template<class T> 
const Vec<T>& 
Vec<T>::
operator=(T& typeValue)
{
  for (unsigned i = 0; i < myVec_.size(); i++)
    (*this)(i) = typeValue;
  return *this;
}

template<class T>
const Vec<T>&
Vec<T>::
operator*=(T typeVal)
{  
  for (unsigned i = 0; i < myVec_.size(); i++)
  {
    (*this)(i) *= typeVal; 
  }
  return *this;
} 

template<class T>
const Vec<T>
Vec<T>::
operator*(T typeVal) const
{
  return (Vec<T>(*this) *= typeVal);
} 

template<class T>
const T&
Vec<T>::
operator()(int index) const
{
  return myVec_[index];
} 

template<class T>
T&
Vec<T>::
operator()(int index)
{
  return myVec_[index];
} 

template<class T> 
int
Vec<T>::
getSize() const
{
  return (myVec_.size());
}

template<class T> 
Vec<T>::
~Vec()
{
}


// ******************************************************************************
// overloading externally since the first argument is not an object: typeVal*obj1
// ******************************************************************************
template<class T>
const Vec<T>
operator*(const T typeVal, const Vec<T>& obj1)
{
  return (obj1*typeVal);
}


int main()
{
  Vec<double> x(3,4);
  Vec<double> d = x*2.0;
  cout << d(0) << " " << d(1) << " " << d(2) << endl;
  return 0;
}

[Bazzy]

You need to tell us what the error is and when it occurs

[jsmith]

Your copy constructor is wrong.

You don't even need one; the default member-wise copy version provided by the compiler will suffice.

[aortizb]

Thanks jsmith. The problem is in the copy constructor. I just commented it and now the code works. Just to understand a little bit more, why the copy constructor defined as above is wrong?

Thanks.

[jsmith]

You are declaring a variable myVec_ inside the function that shadows the class member myVec_.
The assignment is assigning to the local variable, not to the class member.

[kempofighter]

template<class T> 
Vec<T>::
Vec(const Vec<T>& rhsObj) 
{
  vector<T> myVec_(rhsObj.myVec_);
}

Syntactically it looks like you are simply creating a temporary object within the constructor which happens to have the same name as the class attribute. Since this is the constructor, you'd want to use the initializer list. When it is all said and done, the object that was constructed has an empty myVec_ object. Then you try to make a call to its operator() function will attempts to access an empty vector using its operator[] which causes undefined behavior. You can confirm this by setting breakpoints and stepping into the copy constructor and operator() functions (assuming that they weren't inlined by the compiler). Anyway, as jsmith indicates the copy constructor and assignment operator aren't necessary.

[aortizb]

ok. thanks jsmith and kempofighter. Now, the correct constructor is:

template<class T> 
Vec<T>::
Vec(const Vec<T>& rhsObj) 
{
  myVec_ = rhsObj.myVec_;
}

or

template<class T> 
Vec<T>::
Vec(const Vec<T>& rhsObj) :  myVec_ (rhsObj.myVec_)
{
}

Also, is there any way I can do the following in the main() function:

int main()
{
  Vec<double> x(3,4);
  Vec<double> d = 2*x;
  cout << d(0) << " " << d(1) << " " << d(2) << endl;
  return 0;
}

without incurring in a compilation error because of 2 can be interpreted as more than one type? I mean I would like this to compile independently if I use 2*x or 2.0*x

Thanks again.

[aortizb]

user Robertlzw suggested me this:

template<class T, class U>
const Vec<T>
operator*(const U typeVal, const Vec<T>& obj1)
{
  return (obj1*typeVal);
}

which actually works pretty good.
Thanks.