1) boost::shared_pointer_cast<>'s template argument should be the type parameter of the shared pointer type, not the shared pointer's type. In other words boost::static_pointer_cast<gameobject>(sPtr); instead of boost::static_pointer_cast<boost::shared_ptr<GameObject>>(sPtr). However, in this case, the cast isn't necessary. You can construct a weak_ptr to a base class directly from a shared_ptr to a derived class.

2) You can't apply constraints of that sort with C++'s templates. In this case, if you try using the template with a class that doesn't have an implicit conversion from it's pointer type to GameObject * then you'll get a compiler error.

Also, as mentioned in your previous thread, you're still passing an unconstructed object to the shared_ptr. Further, your clean up function doesn't call the destructor when all the shared_ptrs go out of scope.

A derived class can call a base class constructor via the member initialization list. Ex:

struct Base {
Base(int id) {
// stuff
}
};

struct Derived : Base {
Derived(int id) : Base(id) {
// stuff
}
};


If you want to pass an argument to a base class constructor, then a derived class constructor has to do it. That's just how C++ works. Friending another class just gives that other class access to private and protected members of the first class. It doesn't affect construction in any way.