Linking error with static template class members

The more I think about it, the more I have a feeling I have to change my design but here's the problem, anyway.

I have a templated class. This class has a static class member variable, which is a templated stl_container. Then there is a class derived from this one that tries to call this member variable in a source file, but results in a linker error. Here's some simplified code:

Code:

// in a header file
template <typename T>
class A {
static stl_container<T*>* container;
};

class B : public A<MyClass> {
void do_something();
};

//in a source file
//memory allocation for "container" is in different source file

void B::do_something() {
do_something_to(container);
}

This gives me a linker error saying it can't find "container" being called from "do_something". Which, if I think about it, makes sense because there is no other object file for it to link from.

So I can think of one solution which would be to dump the definition of "do_something" into the class body so it doesn't have to resolve the linking error. But I've got other non-class functions that have to access "container" so that's a no go.

So how do you declare, allocate and use a templated static class variable? Is it possible?

I need this thing to be static because "class A" is a actually a node in a graph structure that links to other nodes in the graph and info on the overall graph (kept in the container) can be updated by any node.

After some googling and tinkering, I've found a solution, but I can't say I understand why it works.

Code:

// in a header file
template <typename T>
class A {
static stl_container<T*>* container;
};

//you need a second declaration outside the body of the class
//in the header
template <typename T>
typename A<T>::stl_container<T*>* container;

Why you need the second declaration is beyond me. But it works.

Why is that so surprising? You have to do that even without templates.

Code:

class A
{
public:
    static int x;
};

int A::x;

int main()
{
    A::x = 0;
    return 0;
}

How could it be otherwise? How does the compiler magically decide which .cpp module the definition of the static member should come from? The "static int x" is only a declaration -- you still need to define the variable in some specific .cpp module.

My previous understanding was that static member variables have to be defined outside the class body, not just declared. Isn't a statement like

Code:

int A::x;

allocating memory as well, and therefore, a definition?

But when you have a template declaration

Code:

template <typename T>
typename A<T>::stl_container<T*>* container;

it's not allocating any memory. It's just repeating a declaration made earlier, n'est ce pas? Seems a little byzantine.

Why should the template syntax deviate from the non-template syntax?

True. Consistency is important.

It's the same as with non-templates.
It may be a declaration or implementation, but one instantiated, when the class is instantiated, it becomes a definition. That is generally a rule of templates - they are a declaration sorts of, but once instantiated, a definition for those particular types is created.