Although I'm a committed fan of handle-based systems when it comes to managing resources in the context of game development, I wanted to try another approach this time, something more resembling the contemporary C++ style. All that effort just for the sake of curiosity to see how it would compete. So I involved the std::shared_ptr and std::weak_ptr both used in a somehow inverse scenario that offers an explicit resource management through create/destory() functions. Instead of typical handles, the system emits std::weak_ptrs as resource identifiers, which brings some advantages. The key thing here, compared to handles, is the ease of debugging it brings, especially when a decent debugger is available, which Visual C++ 2012 that I use surely has! The debugger certainly understands the standard C++ constructs better than a custom system of handles, and thus can provide some fancy insights into the internals. See the code + some screenshots below to get the idea:

Besides some obvious pros, the approach also has a bunch of cons. There's some overhead caused by additional memory allocations, and more importantly the shared ref. counter that the smart pointers use internally needs to be protected in a multi-threaded environment (each time a std::weak_ptr gets copied or converted to std::shared_ptr, then when the std::shared_ptr goes out of the scope), which might prove quite expensive. Please note that typical handles don't suffer from this. Handles are also semantically clearer as they serve as pure identifiers that encourage one to think twice before invoking an operation through them.