C++实现设计模式： An extensible Factory Pattern example

I have read the book Api Design For C++recently , and I must say that it is a masterpiece.
There is a section to introduce the Factory Pattern, I think it is the best practical example for this pattern which I have read.
So I code it according the example, made little modification and added some annotation, then now share with you guys.

Example from:  
Api Design For C++, Martin Reddy
Section: 3.3.3 Extensible Factory Example

renderer.h

#include <iostream>
#include <string>

class IRenderer
{
public:
    virtual void Render()=0;
    virtual ~IRenderer()
    {
        std::cout<< "delete IRenderer object."<<std::endl;
    }
};

class UserRenderer:public IRenderer
{
public:
    ~UserRenderer() 
    {
        std::cout<< "delete UserRenderer object."<<std::endl;
    }
    bool LoadScene(const std::string &filename) 
    { 
        return true; 
    }

    void SetViewportSize(int w, int h) {}
    void SetCameraPosition(double x, double y, double z) {}
    void SetLookAt(double x, double y, double z) {}
    void Render() 
    { 
        std::cout << "User Render" << std::endl; 
    }
    
    static IRenderer* Create() 
    { 
        return new UserRenderer(); //Pay attention: this method must be static.
    }
    
};

rendererfactory.h

#include "renderer.h"
#include <string>
#include <map>

class RendererFactory
{
public:
    typedef IRenderer* (*CreateCallback)();
    static void RegisterRenderer(const std::string& type, CreateCallback cb);
    static void UnregisterRender(const std::string& type);
    static IRenderer* CreateRenderer(const std::string& type);

private:
    typedef std::map<std::string, CreateCallback> CallbackMap;
    static CallbackMap mRenderers;
};

rendererfactory.cpp

#include "rendererfactory.h"

RendererFactory::CallbackMap RendererFactory::mRenderers;

void RendererFactory::RegisterRenderer(const std::string &type, RendererFactory::CreateCallback cb)
{
    mRenderers[type] = cb;
}

void RendererFactory::UnregisterRender(const std::string &type)
{
    mRenderers.erase(type);
}

IRenderer* RendererFactory::CreateRenderer(const std::string &type)
{
    CallbackMap::iterator it = mRenderers.find(type);
    if(it!=mRenderers.end())
    {
        return (it->second)();
    }
    return NULL;
}

mainFile.cpp

#include <iostream>
#include "rendererfactory.h"

using namespace std;

int main()
{
    //Register a new renderer
    RendererFactory::RegisterRenderer("user", UserRenderer::Create);

    //create an instance of our new renderer
    IRenderer* render = RendererFactory::CreateRenderer("user");
    render->Render();
    delete render; //Remember to release the resources on heap.

    getchar()
    return 0;
}