static variable in templates

I ran into a problem with templates. What do I do to access a static member for a templated class?
I want the same static variable for every type of instantaniation of the class.
When I tried these I got errors.

Code:

template<int ivar = 5>
class MyClass{
public:
static double stvar;
//blah...
};

MyClass::stvar = .5;        //syntax error before '::' token.
double MyClass::stvar = .5;   //Multiple defenition of MyClass<5>::stvar

What is happening here? and How do I access the static variable?

I don't know what you're trying to do here, but if you're trying to initialize the variables, then you do it in the constructor.

Try this:

Code:

#include<iostream>
using namespace std;

template<int ivar = 5>
class MyClass
{
public:
	static double stvar;
	
};

template<int ivar> 
double MyClass<ivar>::stvar = .5;


int main()
{
	cout<<MyClass<30>.stvar<<endl;
	cout<<MyClass<60>.stvar<<endl;

	return 0;
}

I don't know too much about templates, but from what I can gather it's generally not a good idea to use non-type parameters because they are restrictive, and templating a class with only a non-type parameter doesn't seem like a very good idea.

I think you can accomplish what you want doing this:

Code:

#include<iostream>
using namespace std;

template<typename T>
class MyClass
{
public:
	static double stvar;
	
	//some stuff with type T
	
};

template<typename T> 
double MyClass<T>::stvar = .5;


int main()
{
	cout<<MyClass<int>.stvar<<endl;
	cout<<MyClass<double>.stvar<<endl;
	

	return 0;
}

>> if you're trying to initialize the variables, then you do it in the constructor
Static variables are not initialized in the constructor, arjunjay had it right but did not specify the template argument.

>> from what I can gather it's generally not a good idea to use non-type parameters because they are restrictive
There's nothing wrong with doing that. Look at boost::array.

Originally Posted by Daved

>> from what I can gather it's generally not a good idea to use non-type parameters because they are restrictive
There's nothing wrong with doing that. Look at boost::array.

From what I've read, the primary rationale for non-type parameters is precisely for specifying size and range limits for containers. Is that what the op is doing?

It's irrelevant to the question, and there is no way of knowing anyway, since the posted code doesn't show how ivar is used one way or the other. So you should be careful about making a blanket statement regarding something not being a good idea when it is perfectably acceptable in many instances, one of which might be currently in use.

So you should be careful about making a blanket statement regarding something not being a good idea

I didn't make a blanket statement, I qualified it, and I gave the reason why. In addition, I gave an example of how the same thing could be achieved without a non-type parameter.

Thanks for this.

template<int ivar>
double MyClass<ivar>::stvar = .5;

>>From what I've read, the primary rationale for non-type parameters is precisely for specifying >>size and range limits for containers. Is that what the op is doing?
Yup.

>>In addition, I gave an example of how the same thing could be achieved without a non-type >>parameter.
In your example how does the 'typename' stand instead of the array size which is a integer and not a type?

From your examples I also come to understand that you have different static variables for different parameters which is something I want to avoid.Can it be done?
I'm not using Global variables because I find most posters say its really BAAAAD.

The only way to get one common static variable in all instantiations of a template is to put it into a base class. Since that base is an implementation detail, it should be inherited as private or protected:

Code:

class MyBase
{
protected:
  static int instanceCount;
};

template<typename T>
class MyTemplate : private MyBase
{
  void foo() {
    trace(instanceCount);
  }
};

};