Linker problem with template specialisation

[tsotsi]

I have the following code:

enum foo
{
null_foo,
foo1,
foo2
};

template<typename T>
struct data
{
T val;
bool set;

template<typename U>
data<T>& operator=(const U &that)
{
val = that;
set = true;
return *this;
}
};

struct foo_1 { };
struct foo_2 { };

template<typename Tstruct map_foo_type { static foo const id =
null_foo; }; // worst match
template<struct map_foo_type<foo_1{ static foo const id = foo1; };
template<struct map_foo_type<foo_2{ static foo const id = foo2; };

Using the above code, I want to be able to do the following:

data<intmid = map_foo_type<foo1>::id;

When I compile with gcc 3.3.6 I get a linker error - undefined symbol
mep_foo_type<foo1>::id

If I have an intermediate step:

foo id = map_foo_type<foo1>::id
data<intmid = id;

then it links fine.

Alternately, if I change operator= above to take const U data, rather
than a reference to const U, it also links fine!

What is the problem please?

Thanks
Steve

[Ondra Holub]

[e-mail] napsal:

I have the following code:

enum foo
{
null_foo,
foo1,
foo2
};

template<typename T>
struct data
{
T val;
bool set;

template<typename U>
data<T>& operator=(const U &that)
{
val = that;
set = true;
return *this;
}
};

struct foo_1 { };
struct foo_2 { };

template<typename Tstruct map_foo_type { static foo const id =
null_foo; }; // worst match
template<struct map_foo_type<foo_1{ static foo const id = foo1; };
template<struct map_foo_type<foo_2{ static foo const id = foo2; };

Using the above code, I want to be able to do the following:

data<intmid = map_foo_type<foo1>::id;

When I compile with gcc 3.3.6 I get a linker error - undefined symbol
mep_foo_type<foo1>::id

If I have an intermediate step:

foo id = map_foo_type<foo1>::id
data<intmid = id;

then it links fine.

Alternately, if I change operator= above to take const U data, rather
than a reference to const U, it also links fine!

What is the problem please?

Thanks
Steve

data<intmid = map_foo_type<foo1>::id; calls constructor taking one
parameter. It is not assignment operator. Just define constructor in
simillar way as assignment operator and it should work.

[Ondra Holub]

[e-mail] napsal:

I have the following code:

enum foo
{
null_foo,
foo1,
foo2
};

template<typename T>
struct data
{
T val;
bool set;

template<typename U>
data<T>& operator=(const U &that)
{
val = that;
set = true;
return *this;
}
};

struct foo_1 { };
struct foo_2 { };

template<typename Tstruct map_foo_type { static foo const id =
null_foo; }; // worst match
template<struct map_foo_type<foo_1{ static foo const id = foo1; };
template<struct map_foo_type<foo_2{ static foo const id = foo2; };

Using the above code, I want to be able to do the following:

data<intmid = map_foo_type<foo1>::id;

When I compile with gcc 3.3.6 I get a linker error - undefined symbol
mep_foo_type<foo1>::id

If I have an intermediate step:

foo id = map_foo_type<foo1>::id
data<intmid = id;

then it links fine.

Alternately, if I change operator= above to take const U data, rather
than a reference to const U, it also links fine!

What is the problem please?

Thanks
Steve

data<intmid = map_foo_type<foo1>::id; calls constructor taking one
parameter. It is not assignment operator. Just define constructor in
simillar way as assignment operator and it should work.

[Ondra Holub]

On 29 Kvì, 11:44, [e-mail] wrote:

I have the following code:

enum foo
{
null_foo,
foo1,
foo2

};

template<typename T>
struct data
{
T val;
bool set;

template<typename U>
data<T>& operator=(const U &that)
{
val = that;
set = true;
return *this;
}

};

struct foo_1 { };
struct foo_2 { };

template<typename Tstruct map_foo_type { static foo const id =
null_foo; }; // worst match
template<struct map_foo_type<foo_1{ static foo const id = foo1; };
template<struct map_foo_type<foo_2{ static foo const id = foo2; };

Using the above code, I want to be able to do the following:

data<intmid = map_foo_type<foo1>::id;

When I compile with gcc 3.3.6 I get a linker error - undefined symbol
mep_foo_type<foo1>::id

If I have an intermediate step:

foo id = map_foo_type<foo1>::id
data<intmid = id;

then it links fine.

Alternately, if I change operator= above to take const U data, rather
than a reference to const U, it also links fine!

What is the problem please?

Thanks
Steve

Sorry for double post of previous comment.

You should also change map_foo_type<foo1>::id; to
map_foo_type<foo>::id;, because template map_foo_type takes as
argument typename, not type foo. So you have to pass there foo,
instead of foo1.

[Barry]

On May 29, 5:44*pm, [e-mail] wrote:

I have the following code:

enum foo
{
* * null_foo,
* * foo1,
* * foo2

};

template<typename T>
struct data
{
* * T val;
* * bool set;

* * template<typename U>
* * data<T>& operator=(const U &that)
* * {
* * * * val = that;
* * * * set = true;
* * * * return *this;
* * }

};

struct foo_1 { };
struct foo_2 { };

template<typename Tstruct map_foo_type { static foo const id =
null_foo; }; // worst match
template<struct map_foo_type<foo_1{ static foo const id = foo1; };
template<struct map_foo_type<foo_2{ static foo const id = foo2; };

initialize them outside of the class.
template<typename Tstruct map_foo_type
{ static foo const id; }; // worst match

template <typename T>
foo const map_foo_type<T>::id = null_foo;

template<struct map_foo_type<foo_1{ static foo const id; };
template<struct map_foo_type<foo_2{ static foo const id; };

foo const map_foo_type<foo_1>::id = foo1;
foo const map_foo_type<foo_2>::id = foo2;

>
Using the above code, I want to be able to do the following:

* * data<intmid = map_foo_type<foo1>::id;

foo_1

here calls copy constructor other than assignment operator as marked
else thread

>
When I compile with gcc 3.3.6 I get a linker error - undefined symbol
mep_foo_type<foo1>::id

If I have an intermediate step:

foo id = map_foo_type<foo1>::id
data<intmid = id;

then it links fine.

Alternately, if I change operator= above to take const U data, rather
than a reference to const U, it also links fine!

What is the problem please?