operator+ for template class

Hi everyone,

When I try to overload the operator+ for a template class, the gnu g++-4.x compiler generates the following error message on the 'return' statement in the body of the operator definition:

../Vector.h:73: error: no matching function for call to ‘Vector<double>::Vector(Vector<double>&)’
../Vector.h: In constructor ‘Vector<T>::Vector(const size_t&) [with T = double]’:
../Vector.h:69: instantiated from ‘Vector<T> Vector<T> :: operator+(const Vector<T>&) [with T = double]’


Voila the code:

Code:

---

template<typename T>
class Vector
{
 public:
  Vector( void);
  explicit Vector( Vector<T> const&);  // copy constructor
  explicit Vector( size_t const&); // zero value

  Vector<T> operator+( Vector<T> const& vec2)
  {
    Vector<T> result( vec2.size());
    for( int i=0; i<result.size(); i++) {
      result[i] = this->vec[i] + vec2[i];
    }
    return result; // line 73, which generates error message
  }

 private:
  size_t N;
  T* vec;

};

---

It searches for a kind of copy constructor; without the keyword 'explicit' it suggests the one-argument constructor as a candidate. But implementing this not-so-pretty copy constructor seems really awkward to me. Has it got something to do with all my 'const' declarations?

I know that I do not need to specialise the return type of the operator because of argument deduction, but my goal is to use traits to determine (map) the return type. This is a small simplification to hunt down the bug.

Thanks a lot in advance!!

Why do you want the copy constructor to be explicit?

Quote:

---

Originally Posted by laserlight

Why do you want the copy constructor to be explicit?

---

original reply:

ehm... don't know. I always declare one-argument constructors or one-argument functions 'explicit', think it is just a bad habit. By the way, you're fast! tnx

corrected reply:

well I just remembered why I wanted to declare the copy constructor as 'explicit'. I want to create cast constructors as well (with the usage of traits), so to make the distinction between the copy constructor and the cast constructor...

Making the copy constructor "explicit" causes horrible breakage, as you discover... I can't think of a single sane reason why you'd want to.

Quote:

---

Originally Posted by brewbuck

Making the copy constructor "explicit" causes horrible breakage, as you discover... I can't think of a single sane reason why you'd want to.

---

Yes, the 'explicit' copy constructor caused the problem.

But why exactly? Does the compiler try to cast implicitly the argument to a 'const' argument?

Quote:

---

Originally Posted by MarkZWEERS

Yes, the 'explicit' copy constructor caused the problem.

But why exactly? Does the compiler try to cast implicitly the argument to a 'const' argument?

---

No, the act of returning ANY sort of object will invoke its copy constructor in an implicit way. So making the copy constructor explicit breaks all kind of fundamental behaviors.