在运行时或编译时更改API？

Question

I'm coding a game engine class and I've been suggested to add this #define to deal with multiple APIs in this manner:

#ifdef OGL
    typedef COpenGl CBaseApi;
#elif defined( OGLES )
    typedef COpenGlEs CBaseApi;
#elif defined( DX9 )
    typedef CDirectX9 CBaseApi;
#elif defined( DX10 )
    typedef CDirectX10 CBaseApi;
#elif defined( DX11 )
    typedef CDirectX11 CBaseApi;
#endif

And I have two questions: How can I get the above to work?

I tried:

class CBaseAPI
{
    //abstract class, virtual functions
} 
class COpenGL : public CBaseAPI
{
    //implementations
}

But it didn't work as I expected.

And the second question is, is this #define method better than using a factory of some sort? I was initially doing this:

//inside the Main program
myGameEngine.Initialize(GraphicAPI::DirectX11);

//inside the Initialize function
void GameEngine::Initialize(GraphicAPI graphicAPI)
{
    switch(graphicAPI)
    {
        case GraphicAPI::DirectX11:
        {
            //Defined as private members:                
            //BaseAPI graphicAPI;

            //class CDirectX11 : public BaseAPI

            graphicAPI = new CDirectX11(); 
        }
        //other cases here
    }
}

Are there any pros and cons to these methods, and what is the preferred one?

Answer 1

You seem to have a typedef with the same name as a base class (CBaseApi). That won't fare well.

Did you mean something like:

class CBaseAPI
{
    //abstract class, virtual functions
};
class COpenGlEs : public CBaseAPI
{
    // implementations  
};

#ifdef OGL
    typedef COpenGl BaseApiImpl;
#elif defined( OGLES )
    typedef COpenGlEs BaseApiImpl;
#elif defined( DX9 )
    typedef CDirectX9 BaseApiImpl;
#elif defined( DX10 )
    typedef CDirectX10 BaseApiImpl;
#elif defined( DX11 )
    typedef CDirectX11 BaseApiImpl;
#endif

Answer 2

The second one is terrible. Two-phase initialization is very error prone, and in the general case, there is absolutely no need whatsoever for your game to change rendering APIs at run-time. It's a complete waste of time and performance to use interfaces and inheritance, not to mention a loss of nice strong typing.

For the #define, there is no need for the classes to be linked by inheritance. You might do better with a template, but conditional compilation is what the preprocessor was made for. Simple usage scenario:

class OGL {
public:
    void dostuff();
};
class DX {
public:
    void dostuff();
};
class GameEngine {
#ifdef USE_OPENGL
    OGL BaseAPI;
#else
    DX BaseAPI;
#endif
public:
    void dostuff() { BaseAPI.dostuff(); }
};

Also, CClass? Owch. You need to find new learning materials, buddy.