Thread: template declarators

given:

Code:

struct A {

 } a;

how does this work with templates?

Code:

temaplate<class T>
struct A
{
  T data;
};
     
int main( )
{

A<int> a;    //You can change the data type to basically anything you want here at object creation
             //It will change the type qualifier for the 'data' struct variable

return 0;

}

Heh, well you could aways try testing it Some templates actually require a constructor and destructor to compile. Other than that, I believe an empty structure takes up one byte of space (please someone jump in with a correction).

[edit]
I guess I misunderstood what you meant.
[/edit]

I suppose I'm being too vague here.

consider:

Code:

typedef struct foo { } bar, baz;

foo f;
bar r;
baz z;

I want to use the same syntax with templates.

ok, here's what I was hoping for:

Code:

template <class T> typedef struct foo { } bar, baz;

foo <int> f;
bar <int> r;
baz <int> z;

in other words, typedef the template itself - not a particular parameterization of the template.

>> But if you are just wanting foo and bar and baz to be the same structure, why not use macros?

I'd rather not use macros at all - I was just hoping there was some obscure feature of the language that would allow you to do this.

>> I'm really not sure why you are wanting to do this.

why does anyone want to typedef anything? maybe because it's easier to type?

You can't have typedef templates, so what you're trying to do is impossible. Sorry. Basically, in order to allow your idea, this would need to be possible:

Code:

template <typename T> typedef vector<T> dynarray<T>;

Admittedly, that would allow cool stuff:

Code:

template <typename T> typedef vector<vector<vector<T> > > vec3d<T>;

But it doesn't exist. It is being discussed as a language extension, but there is some weird stuff that needs to be resolved, especially when it comes to function parameter deduction.

Code:

template <typename T> typedef T CT<T>;

template <typename T>
void whee(CT<T> arg);

It's very hard to correctly deduct the type here.

As a workaround for now, you can use nested typedefs:

Code:

template <typename T>
struct vec3d
{
  typedef vector<vector<vector<T> > > t;
};

vec3d<int>::t myvec;