Error in template class - c++

Question

Hi I am trying to build empty functions for templates so that I can later fill in the details. Here is my code:
namespace my {
template <class T>
class Sptr {
private:
//some kind of pointer
//one to current obj
T obj;
size_t reference_count;
//one to original obj
public:
template <typename U> Sptr(U *);
Sptr(const Sptr &);
//template <typename U> Sptr(const Sptr<U> &);
~Sptr();
T* operator->() {return &obj;};
template <typename U> Sptr<T> &operator=(const Sptr<U> &);
//overload *,->,=,copy-constructor
// const-ness should be preserved.
// Test for null using safe-bool idiom
// Static casting, returns a smart pointer
};
template <typename U> Sptr<U>::Sptr(U* u) {
//do something
}
template <typename T> Sptr<T>::Sptr(const Sptr<T> &copyObj) {
//do copy constructor stuff
}
template <typename T> Sptr<T>::Sptr& operator=(const Sptr<T> &T) {
return *this;
}
}
But I get the following error when I compile it.
Sptr.hpp:30:24: error: prototype for ‘my::Sptr<T>::Sptr(U*)’ does not match any in class ‘my::Sptr<T>’
Sptr.hpp:17:3: error: candidates are: my::Sptr<T>::Sptr(const my::Sptr<T>&)
Sptr.hpp:16:25: error: template<class T> template<class U> my::Sptr::Sptr(U*)
Sptr.hpp:38:24: error: ‘my::Sptr<T>::Sptr’ names the constructor, not the type
How do I solve them?

Answer 1

template <typename U> Sptr<U>::Sptr(U* u) {
//do something
}
should be
template <typename T>
template <typename U>
Sptr<T>::Sptr(U* u) {
//do something
}
similarly for the other member function templates.

Answer 2

The way you define member functions of a class template is incorrect. Here is how you should define the constructor template:
template<typename T> // <== template parameter declaration for Sprt<T>
template<typename U> // <== template parameter declaration for constructor
Sptr<T>::Sptr(U* u) {
//do something
}
And here is how you should define the operator =:
template <typename T> // <== template parameter declaration for Sprt<T>
template<typename U> // <== template parameter declaration for operator
Sptr<T>& Sptr<T>::operator=(const Sptr<U> &t) {
return *this;
}

Answer 3

You define both the constructor and operator= as template functions. I'm not sure you actually want that. Shouldn't they just be taking T as arguments? Are you sure you don't want this for your constructor declaration:
Sptr(T*);
If you really do want them to be function templates, this is incorrect:
template <typename U> Sptr<U>::Sptr(U* u) {
//do something
}
When you have a function template inside a function class, you need to give both sets of template arguments:
template <typename T>
template <typename U>
Sptr<T>::Sptr(U* u) {
//do something
}