Template

Hi all,

I am having trouble with class definition with template. The following is a simple example:

Code:

template <class DataType>
struct TestStruct {
  DataType key;
};

template <class s, class d>
class DummyClass {
public:
  d getKey(s<d> *var) {
    return var->key = 10;
  }
};

int main() {
  DummyClass<TestStruct, double> myClas;
  return 0;
}

It produces an error because of s<d>.

If I write:

Code:

template <class DataType>
struct TestStruct {
 DataType key;
};

template <class s, class d>
class DummyClass {
public:
 d getKey(s *var) {
   return var->key = 10;
 }
};

int main() {
 DummyClass<TestStruct<double>, double> myClas;
 return 0;
}

It works just fine. But that is not I want because I need to use "double" twice. Can anyone help?

You want a template template:

Code:

template <class DataType>
struct TestStruct {
  DataType key;
};

template <template <class T> class s, class d>
class DummyClass {
public:
  d getKey(s<d> *var) {
    return var->key = 10;
  }
};

int main() {
  DummyClass<TestStruct, double> myClas;
  return 0;
}

your suggestion does not work.

What errors are you getting? And what compiler are you using?

Prelude's code is correct. (And I double checked this with GCC 3.3).

I use visual c++ version 6. There are many errors, but the first 2 are:
error C2954: template definitions cannot nest
error C2951: template declarations are only permitted at global or namespace scope

What compiler are you using? Most compilers have different deficiencies with regard to templates.

If you cannot use a "better" compiler, you can always go with a less desirable option and specify the template parameter when instantiating your object:

Code:

template <class DataType>
struct TestStruct {
  DataType key;
};

template <class s, class d>
class DummyClass {
public:
  d getKey(s *var) {
    return var->key = 10;
  }
};

int main() {
  DummyClass<TestStruct<double>, double> myClas;
  return 0;
}

I originally coded that way, but I was thinking a user may erroneously instantiate

Code:

DummyClass<TestStruct<double>, int> myClas;

which of course results in error(s). So to keep error to the minimal I figured removing redundant data-type declarations.

>I use visual c++ version 6.
Then you're screwed. Get a better compiler, or suffer the inadequacies of your trying to use a non-conforming compiler in a standard world.

MSVC 6 is an outdated compiler. It is not standards compliant (there was no standard when it was released), and it does things "its own way".

GCC comes bundled with the Dev-C++ IDE.
Also, I believe you can download MS compilers for free, but all you get is the command line compiler (no IDE -- you'll have to use something else for editing).

Cheers

*edit*
Okay. Prelude beat me to the point and was more direct.

Thanx

another approach is to provide a typedef within the template for any internal type you may want to make accessible to other templates:

Code:

template <class DataType>
struct TestStruct {
 typedef DataType value_type;
 DataType key;
};

template <class s>
class DummyClass {
typedef typename s::value_type value_type;
public:
  value_type getKey(s *var) {
   return s->key;
 }
};

int main() {
 DummyClass< TestStruct<double> > myClas;
 return 0;
}

This one works! Moreover it is much compact. Thanx legend

Umm.. Slightly offTopic, but aren't you suppose to use typename instead of class?

"class" is a synonym for "typename" within a template parameter declaration that is a type.

So "template<class T>" == "template<typename T>".

Found something interesting:
http://blogs.msdn.com/slippman/archi...11/212768.aspx

gg