Resource Manager in C++ for Games
The ResourceManager class
You should probably use a std::unordered_map&lt;&gt; (from the &lt;unordered_map&gt; header) instead of a std::map, since resources don't really need to be ordered as far as I can see. This will give you some speed, even if you're not concerned by that.
Consider throwing an exception from the getResource() function if the dynamic_cast&lt;&gt; fails. Right now, it is up the caller to check that the returned pointer is not null, it might be better if the function simply throws an exception so that client code does not have to wrap every single call with a check.
This is up to you, since now the client might have to wrap calls in try-catches. However, it certainly makes errors pop up a lot more visibly and at the call location, instead of possibly later if the client forgets to check for null.
The addResource implementation
You never check that resource is not null, which a pointer can be. Consider checking or taking a Resource&amp; instead to ensure that you are operating on an existing value.
Your insertion into the map looks like this:
mResources.insert(std::pair&lt;std::string, Resource*&gt;(name, resource));

std::map&lt;&gt; and std::unordered_map&lt;&gt; both have the emplace() member function. The function takes the arguments to construct the key-value-pair internally (thus avoiding copy/move operations). You can instead write your return statement like so:
mResources.emplace(name, resource);

This looks cleaner and is more efficient.

Be careful with your map, I don't know what unload resource does, but it better call delete if that's (dynamically) how you're allocating your resources. However, a better idea might instead to use std::unique_ptr&lt;&gt; with a custom deleter. Here's a mock implementation:
#include &lt;iostream&gt;
#include &lt;memory&gt;

struct resource
{
    void unload_resource() { std::cout &lt;&lt; &quot;unloaded\n&quot;; }
};

struct resource_free
{
    void operator()(resource* r)
    {
        r-&gt;unload_resource();
        delete r;
    }
};

int main()
{
    std::unique_ptr&lt;resource, resource_free&gt; pres{ new resource };
}

This will simplify the implementation of the destructor as std::unique_ptr&lt;&gt; takes care of properly releasing your resource. You can make an alias for ease of use: using resource_ptr = std::unique_ptr&lt;...&gt;. This allows you to write your map variable declaration in an easier to read way:
std::unordered_map&lt;std::string, resource_ptr&gt; mResources;