C++ am I misunderstanding output parameters

Question

I'm building a very basic object loader with DirectX and I decided I wanted to separate its logic from the main portion of my program and put it into its own class (as it probably should be).

The problem I'm having is that my Loader needs access to some of my MainWindow variables such as a DX11 SwapChain to handle the backbuffer for frame rendering.

I'm very new to C++ so I am not sure if I am utilizing pointers efficiently here, but it would be of great help if someone could tell me if what I'm doing is wrong or maybe suggest a more efficient way of handling the problem.

Main Window:

// Global variables
IDXGISwapChain* g_swapChain;  // Pointer to global swap chain 

// Obj loader init example - pass the reference of global swap chain?
ObjectLoader l( &g_swapChain );

// Condensed method call as you don't need to see all parameters
loader.__loadModel("model.obj");

Now, in my ObjectLoader class, what sort of pointer would I set up in order to be able to constantly reference my Main Windows g_swapChain? Am I right in thinking that I should use a double pointer, such as, with the encapsulated class global being a reference to that double pointer.

private: 
IDXGISwapChain& loader_swapChain;

public: 
ObjectLoader::ObjectLoader( IDXGISwapChain** swapChain ) 
{
     loader_swapChain = swapChain;
}

The example below demonstrates where I would need to use MainWindow's swapchain.

ObjectLoader::__loadModel(std::string fielname)
{
     if (modelLoaded)
           ...
     else {
          // this is an example of where I want to use the swap chain in MainWindow
          loader_swapChain->SetFullscreenState(false, NULL);
     }
}

Coming from a Java background, this pointer stuff is giving me headache - hopefully what I am asking makes sense, if not please ask and I will provide more information.

Answer 1

You mixing references and pointers, it won't compile.

I don't think pointer to pointer is really needed.

You can do it like this with reference:

private: 
ID3D11SwapChain& loader_swapChain;

public: 
ObjectLoader::ObjectLoader( ID3D11SwapChain& swapChain ) : loader_swapChain( swapChain )
{
}

or if you want to use pointer:

private: 
ID3D11SwapChain* loader_swapChain;

public: 
ObjectLoader::ObjectLoader( ID3D11SwapChain* swapChain ) : loader_swapChain( swapChain )
{
}

EDIT

if the meaning is to change the global pointer after inited, than a pointer to pointer is possible solution.

a pointer to pointer version:

private: 
ID3D11SwapChain** loader_swapChain;

public: 
ObjectLoader::ObjectLoader( ID3D11SwapChain** swapChain ) : loader_swapChain( swapChain )
{
}

Note that a global variable is not so good solution, better use a singleton.

Answer 2

// Global variables
IDXGISwapChain* g_swapChain;  // Pointer to global swap chain 

OK so far.

Is the global swap chain ever changed? That is, do you ever make g_swapChain point to a different chain? Or is it constant once you set it?

// Obj loader init example - pass the reference of global swap chain?
ObjectLoader l( &g_swapChain );

This is a "reference" in one sense, but it's not a C++ "reference" (you're taking the address of something, so you're forming a pointer) so it's best to avoid using the term reference ambiguously.

private: 
IDXGISwapChain& loader_swapChain;

public: 
ObjectLoader::ObjectLoader( IDXGISwapChain** swapChain ) 
{
     loader_swapChain = swapChain;
}

This can't possibly work, firstly, that's not how you set a reference member variable. Reference members must be initialized in the class mem-initializer-list not by assigning something to them. As written, you don't initialize the reference (so it will not compile) and then you try to assign something to the target of the reference (you can't "re-seat" a reference, so assigning to one doesn't change what it refers to, it assigns to the thing it refers to).

So initializing a reference member must be done like:

ObjectLoader::ObjectLoader( IDXGISwapChain** swapChain ) 
: loader_swapChain(swapChain)
{ }

However this still won't compile, because you're trying to set a reference to a thing with the value of a pointer to a pointer to a thing ... that's nonsense, they're completely different types.

SHR's answer shows some correct ways to create a member variable that refers to something else, and how to initialize it correctly.