Casting DirectX interfaces - c++

Question

I'm trying to put interface pointers to different types of shaders in a vector like this:
std::vector<ID3D11DeviceChild*> shaders;
ID3D11VertexShader* VS;
// ... instantiate and init VS
shaders.push_back(static_cast<ID3D11DeviceChild*>(VS));
// and when VS is needed again:
ID3D11VertexShader* VS = static_cast<ID3D11VertexShader*>(shaders[i]);
// use VS here
My question is whether this method for type casting COM interfaces is safe. I know it would work for normal polymorphic class hierarchies, but I'm not sure about COM.

Answer 1

First, I'd suggest storing smart pointers instead of raw owning pointers inside an STL container like std::vector, e.g.
std::vector<CComPtr<ID3D11DeviceChild>> shaders;
Using raw owning pointers inside STL containers is a source of leaks, potential bugs and exception unsafe code (observing raw pointers are fine, though).
To downcast from ID3D11DeviceChild* to ID3D11VertexShader*, consider using QueryInterface() (again, using ATL smart pointers like CComPtr simplifies the code):
CComPtr<ID3D11VertexShader> spVertexShader;
HRESULT hr = (shaders[i])->QueryInterface(IID_PPV_ARGS(&spVertexShader));
if (FAILED(hr))
...
PS
Unless I'm missing something, since ID3D11VertexShader is a derived class of ID3D11DeviceChild, you don't need the static_cast here:
shaders.push_back(static_cast<ID3D11DeviceChild*>(VS));
This should be fine:
shaders.push_back(VS);
Note on CAdapt
Note that you may need to use CAdapt with std::vector:
std::vector<CAdapt<CComPtr<ID3D11DeviceChild>>> shaders;
A conformant C++11 STL implementation should not require CAdapt, but I think it's necessary at least with VS2008 and VS2010.
I'm not sure about more modern versions of Visual Studio, but it seems they fixed that, e.g.:
you may want to read the paragraph titled "Resistance to overloaded address-of operators" in this Visual C++ blog post.

Answer 2

ID3D11VertexShader inherits from ID3D11DeviceChild so you don't even need to use static_cast<ID3D11DeviceChild*> to push them to vector. The safer way to downcast vector elements to shader is to use QueryInterface:
CComPtr<ID3D11VertexShader> vs;
if (S_OK == shaders[i]->QueryInterface(IID_ID3D11VertexShader,
reinterpret_cast<void**>(&vs)))
{
// Use vs here
}

Answer 3

It is safe for as long as you're absolutely sure the vector only contains ID3D11VertexShader, in which case you should just use it instead of ID3D11DeviceChild.
If you intend the vector to contain a mix of interface pointers, each with the common ancestor ID3D11DeviceChild, you're better off relying on QueryInterface, both for storing into and retrieving from the vector.
Remember, correct code is better than fast code, at least to begin with.
When you profile, if, and only if, you find out that QI is a bottleneck, then you should do something about it, but I recommend you use a vector of structs which has a pointer to a ID3D11DeviceChild and an interface identifier (IID) so you can inspect at runtime which kind of interface pointer you stored:
struct DeviceChildPtr {
ID3D11DeviceChild *ptr;
REFIID riid;
};
std::vector<DeviceChildPtr> shaders;
// ... instantiate, initialize ...
DeviceChildPtr shader;
shader.ptr = static_cast<ID3D11DeviceChild*>(VS);
shader.iid = IID_ID3D11VertexShader;
shaders.push_back(static_cast<ID3D11DeviceChild*>(shader));
// ...
DeviceChildPtr shader = shaders[i];
// If you only ever use global IIDs, you may replace IsEqualIID with ==
// This is like a half-baked QueryInterface that only checks for a specific IID
if (IsEqualIID(shader.riid, IID_ID3D11VertexShader) {
ID3D11VertexShader* VS = static_cast<ID3D11VertexShader*>(shader.ptr);
// ... use ...
}
If you ever go through this path, remember to comment why (performance?) and how (casting, safety through runtime interface type check) you're doing it this way instead of using QueryInterface.
My guess is, since internally DX itself will most likely use QueryInterface, you shouldn't find a bottleneck here.