So i've been trying to think of the best way to decide which graphics interface to use on initialization of my engine. I really like in C# how you can create an interface, inherit from it, then declare an object of that interface and initialize it with one of the inherited classes. I know thats not exactly possible with C++ because you can't create an object from an interface.

I know i'm missing something here, but i was hoping i might get a little insight from some of you here. The way i've decided to go about it, although its going to change once i find a better way, is create an IGraphics interface, then create directx and opengl classes that inherit from that interface. in the app, i have one member for each of those inherited classes. i load in the options file, then initialize the graphics based on whats in the options file. to do this, i have a function which returns a reference to one of those members and then i initialize the graphics. here's some code snippet of what i'm doing, and let me know your thoughts and hopefully a better way of doing this.

application class

class App
{
private:
    // both these inherit from the IGraphics interface
    static GraphicsD3D11_1 m_GraphicsD3D11_1;
    static GraphicsOpenGL m_GraphicsOpenGL;

public:
    IGraphics *Graphics();

    // more stuff
}

function which decides which api to use

IGraphics *App::Graphics()
{
    switch (m_Settings.m_GraphicsAPI)
    {
        case GraphicsAPI_D3D11_1:
        {
            return &m_GraphicsD3D11_1;
	}
	case GraphicsAPI_OPENGL:
	{
            return &m_GraphicsOpenGL;
	}
	default:
            return NULL;
    }
    return NULL;
}

then when i need to use the graphics api, i just call it like this:

Graphics()->Initialize(); // just an example of a call to initialize the graphics

any suggestions on a better way to do this. my worry is that it is not the most performant solution, and especially since i need to have declared a member for each graphics api

yeah, thats a good answer. i was trying to make the engine as flexible as possible, but i'll just go with one

This is not a thing most real games do. Either you write your game using one API or you write it in the other.

What about different versions of an API, eg dx9 vs dx11? I've seen quite a few games that support both.

I really like in C# how you can create an interface, inherit from it, then declare an object of that interface and initialize it with one of the inherited classes. I know thats not exactly possible with C++ because you can't create an object from an interface.

They both work the same way:
C#: MyInterface foo = null; foo = new MyDerived();
C++: MyInterface* foo = nullptr; foo = new MyDerived();
The only difference is that C# hides pointer syntax from you (all class/interface variables in C# are always pointers/references).

In your example code, you're creating an instance of both D3D and GL, and then returning one or the other. It would probably be better to only create one or the other, e.g.

class App
{
private:
    unique_ptr<IGraphics> m_Graphics;
public:
    IGraphics *Graphics();
}

App::App(const Settings& settings)
{
    switch (settings.m_GraphicsAPI)
    {
        case GraphicsAPI_D3D11_1:
        {
            m_Graphics = make_unique<m_GraphicsD3D11_1>(); break;
	}
	case GraphicsAPI_OPENGL:
	{
            m_Graphics = make_unique<m_GraphicsOpenGL>(); break;
	}
    }
}

What about different versions of an API, eg dx9 vs dx11? I've seen quite a few games that support both.

I do that by compiling two different EXEs for the game. A launcher program then selects the appropriate EXE to run.
The game selects the renderer using #ifdef's rather than interfaces.
Doing the selection via runtime interfaces is of course possible, it's just slower and more complex IMHO.

You will need to either devise your own shader language, and convert to either API at runtime, or just hand-write all your shaders for both APIs.

OpenGL is a real stick in the mud here... I can write HLSL shaders (with a few macros for portability) and then pre-compile the same source files into binary shaders for PC-D3D9 / PC-D3D11 / XB360 / XB1 / PS3 / PS4 / WiiU / etc... i.e. my shaders source files work on every platform except Mac/Linux/Android/iOS/WebGL.
Unfortunately yeah, when it comes to porting to GL, I have to use a dodgy HLSL->GLSL translator, then a GLSL->AST optimizing compiler (because you can't trust GL drivers to actually optimize your code), then a AST->GLSL converter (because GL requires you to ship ASCII instead of binary shaders)
Really not worth the effort if you can avoid it!