Quote:
1. Is it possible to write the above in C++?

Not easily. C++ templates are far more flexible than Java's generics. I'm sure there is a SFINAE method of testing the above.

In most cases C++ programmers will use a form of "duck typing" for templates. That is, if the class provided as a template argument does everything it is required to do at compile time, then it is consider to map to the "concept" the template type requires.

This is a far more powerful and interesting mechanism than Java has. For example, the Standard C++ Library specifies various iterator concepts, and because pointers map those concepts then you can use pointers or aggregate types as iterators. C++0x was going to make the approach more explicit, allowing for concept interfaces and concept maps, but last I heard this was abandoned as being too complex.

2. No. Concrete template types are unrelated. You could have a non-template base class, and then derive subclasses from it. Whether that is a good idea depends on what a StateManager does.

If I understand what you're saying correctly, what you need to do is use pointers to the desired type hierarchy, rather than instances. In C++, templates give you compile-time polymorphism -- you get multiple behaviors, but they are known statically at compile time.

In order to get different runtime behavior, you need virtual dispatch, which you get through pointers.

This is akin to the problem in C++ that you can't create a container (say, std::vector) which contains actual instances of a type and its subtypes. Instead, you create a vector of pointers to the desired base type, deal with the dereference overhead, and must ensure that instances are allocated and deallocated properly.

Of course, Java must be doing something similar to this in the background through its own type system, but it expresses it differently since the language doesn't expose pointers.