Template function not generated?

[binarybob0001]

I'm trying to make a simple vector class using meta programming. I'm using GCC's 3.3.4 compiler. Here's the code.

template<int N, int I = 0, int Stride = 1>
class VecOps 
{
enum { loopflag = (I < N-1) ? 1 : 0 };
public:
 template<class expr>
 static inline void Zero(typename expr::iterator v) {
  v[I] = typename expr::value_type();
  VecOps<loopflag*N, loopflag*(I+1)>::Zero(v);
 }
};

template<>
class VecOps<0>
{
public:
 template<class expr>
 static inline void Zero(typename expr::iterator v) {
 }
};

template<class T, std::size_t dims>
class Vector
{
public: //exactly the same a boosts array class definitions
 typedef T                                     value_type;            
 typedef T*                                    iterator;              
 typedef const T*                              const_iterator;        
 typedef std::reverse_iterator<iterator>       reverse_iterator;      
 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 typedef T&                                    reference;             
 typedef const T&                              const_reference;       
 typedef std::size_t                           size_type;             
 typedef std::ptrdiff_t                        difference_type;
private:
 value_type v[dims];
public:
 Vector() {
  VecOps<dims>::Zero(begin()); //error references this
 }
 
 iterator begin() {
  return &v[0];
 }
 
 iterator end() {
  return &v[dims-1];
 }
};

When compiling, I get the following error:
error: no matching function for call to `VecOps<3, 0, 1>::Zero(int*)
What am I doing wrong? GCC compiled the blitz++ library perfectly.

[Paul McKenzie]

Please include all necessary header files.

Regards,

Paul McKenzie

[Paul McKenzie]

Also, please include the main() program that instantiates this type.

Regards,

Paul McKenzie

[binarybob0001]

OK, here's repost with all the modifications McKenzie asked for.

#include <cstdlib>
#include <iterator>

template<int N, int I = 0, int Stride = 1>
class VecOps 
{
enum { loopflag = (I < N-1) ? 1 : 0 };
public:
 template<class expr>
 static inline void Zero(typename expr::iterator v) {
  v[I] = typename expr::value_type();
  VecOps<loopflag*N, loopflag*(I+1)>::Zero(v);
 }
};

template<>
class VecOps<0>
{
public:
 template<class expr>
 static inline void Zero(typename expr::iterator v) {
 }
};

template<class T, std::size_t dims>
class Vector
{
public: //exactly the same a boosts array class definitions
 typedef T                                     value_type;            
 typedef T*                                    iterator;              
 typedef const T*                              const_iterator;        
 typedef std::reverse_iterator<iterator>       reverse_iterator;      
 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 typedef T&                                    reference;             
 typedef const T&                              const_reference;       
 typedef std::size_t                           size_type;             
 typedef std::ptrdiff_t                        difference_type;
private:
 value_type v[dims];
public:
 Vector() {
  VecOps<dims>::Zero(begin());
 }
 
 iterator begin() {
  return &v[0];
 }
 
 iterator end() {
  return &v[dims-1];
 }
};

int main(int argc, char *argv[])
{
 Vector<int, 3> v;
 return EXIT_SUCCESS;
}

[Kheun]

This one compile but I am not sure if it meets your needs.

template<int N, int I = 0, int Stride = 1>
class VecOps 
{
enum { loopflag = (I < N-1) ? 1 : 0 };
public:
 template<class expr>
 static inline void Zero(typename expr &v) {
	 v.begin()[I] = typename expr::value_type();
  VecOps<loopflag*N, loopflag*(I+1)>::Zero(v);
 }
};

template<>
class VecOps<0>
{
public:
 template<class expr>
 static inline void Zero(typename expr &v) {
 }
};

template<class T, std::size_t dims>
class Vector
{
public: //exactly the same a boosts array class definitions
 typedef T                                     value_type;            
 typedef T*                                    iterator;              
 typedef const T*                              const_iterator;        
 typedef std::reverse_iterator<iterator>       reverse_iterator;      
 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 typedef T&                                    reference;             
 typedef const T&                              const_reference;       
 typedef std::size_t                           size_type;             
 typedef std::ptrdiff_t                        difference_type;
private:
 value_type v[dims];
public:
 Vector() {
  VecOps<dims>::Zero(*this); //error references this
 }
 
 iterator begin() {
  return &v[0];
 }
 
 iterator end() {
  return &v[dims-1];
 }
};

int main()
{
	Vector<int, 10> v;
}

[binarybob0001]

Dope, dumb mistake. I know exactly what is happening now. The template is actually generating the function for Vector::iterator. It then looks to find Vector::iterator::iterator. It gets confused and says there is no matching function call. Here's the declaration the compiler sees.

void VecOps<3, 0, 1>::Zero( int*::iterator v)

You would think that this would set off all sort of errors, but I guess not.
Thanks for the help.

[Kheun]

In fact, both of these lines in your original code fail to compile.

 static inline void Zero(typename expr::iterator v) {
  v[I] = typename expr::value_type();
  //...

The second line requires value_type to be available by expr. Thus, by passing *this into VecOps<...>::Zero(), I am making Vector<...>::value_type available in VecOps<...>::Zero()

[binarybob0001]

I suppose there is only one solution then. That is to add another template argument (maybe a couple because of other things I will be using the class for). Here's what I came up with (I'm not sure if my modification a good).

template<int N, typename expr1, typename expr2 = expr1, int I = 0, int Stride = 1>
class VecOps 
{
 enum { loopflag = (I < N-1) ? 1 : 0 };
 typedef typename expr1::iterator iterator;
 typedef typename expr1::const_iterator const_iterator;
 typedef typename expr1::value_type value_type;
 typedef VecOps<loopflag*N, expr1, expr2, loopflag*(I+N)> Next;
public:
 static inline void Zero(iterator v) {
  v[I] = value_type();
  Next::Zero(v);
 }
};

template<typename expr1>
class VecOps<0, expr1>
{
 typedef typename expr1::iterator iterator;
 typedef typename expr1::const_iterator const_iterator;
 typedef typename expr1::value_type value_type;
public:
 static inline void Zero(iterator v) {
 }
};

template<class T, std::size_t dims>
class Vector
{
public: //exactly the same a boosts array class definitions
 typedef T                                     value_type;            
 typedef T*                                    iterator;              
 typedef const T*                              const_iterator;        
 typedef std::reverse_iterator<iterator>       reverse_iterator;      
 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 typedef T&                                    reference;             
 typedef const T&                              const_reference;       
 typedef std::size_t                           size_type;             
 typedef std::ptrdiff_t                        difference_type;
private:
 value_type v[dims];
 typedef VecOps<dims, Vector> Ops;
public:
 Vector() {
  Ops::Zero(begin());
 }
 
 iterator begin() {
  return &v[0];
 }
 
 iterator end() {
  return &v[dims-1];
 }
};

int main(int argc, char *argv[])
{
 Vector<int, 3> v;
 return EXIT_SUCCESS;
}

I also discovered that instantiating a template like this does not seems to be possible.
VecOps<3>::Zero<Vector>(...);
Is there any reason why this is illegal?

[Kheun]

I also discovered that instantiating a template like this does not seems to be possible.
VecOps<3>::Zero<Vector>(...);
Is there any reason why this is illegal?

Sorry, I have not idea if the code is legal. Probably you like to test it with Comeau compiler since it is one of the best compiler that conform to the standard.

[exterminator]

I also discovered that instantiating a template like this does not seems to be possible.
VecOps<3>::Zero<Vector>(...);
Is there any reason why this is illegal?

It is invalid as it does not help instantiate neither the first VecOps template nor its specialization. When you say <3> - which template do you expect to get instantiated? First? - No - minimum requirement for that is an int and a type for expr1. Second? - No - minimum requirement for that is a type for expr1. In fact, I think this is wrong:

template<typename expr1>
class VecOps<0, expr1>

I think that specialization parameter (second line above) has to be a distinct type. Guys, correct me if I am wrong. Regards.