Factory pattern across Dll boundaries using unique_ptr

Question

I am looking for the input from developers who had some experience with IoC frameworks like Castle (in .NET) or in Java.

However, I am looking for something similar implemented using C++. That excludes COM, for reasons I can explain later. Is there a way to implement a pattern like a Factory, Abstract Factory or Service Provider in C++, mostly, but not exclusively on Windows platform?

Specifically, IoC should allow for an unknown number of implementations of interface(s) that can be discovered and loaded by the client app at runtime.

As the answer I am hoping for either:

1. a link to the specific commercial or open source C++ IoC implementation, or
2. personal experiences trying to implement it, with the list of a few major gotchas, if any.

Due to unexpected downvotes I have to add some additional specifications (which may have not been clear from the OP):

1. It is Ok if implementation requires a closed system, where all the components are required to link to the same version of C++ runtime library. This is not great, but is acceptable. I have been working for decade on software that installed the required version of C++ runtime, as the part of client application software installation. IOW, this is an issue for broad compatibility, but not the answer to the question that I am asking here.

2. I am mentioning unique_ptr because it is a C++ standard. Custom smart pointer would be Ok too. I expect that unique_ptr is probably better explored by now.

3. I am not asking for a draft code on how to use custom deleter with unique_ptr. Much less for a code that doesn't even compile. This is the answer that got all the upvotes. Sadly, after I commented like "this is like a blind trying to lead a deaf", the rage to punish me as the alleged offender, and to support the alleged victim, got blown out of proportions and resulted in irrational downvotes and upvotes. I am truly saddened that on a site like SO such a thing can derail purely technical problem and turn it into personal rants about politeness. It would be more polite to abstain from throwing clueless code drafts at the questions that clearly ask for actual implementation experiences. (a)

4. After not getting any sensible answer or a good link, I spent quite some time trying to create a sample implementation myself. I tried it in both Release and Debug builds under MSVC 2010 and it worked as I expected. That is the answer which I didn't vote as accepted, since it is my answer to my own question. I still hope for a good comments from people who are actually experienced in these issues. This answer has 2 downvotes, even if the code does what it says it does, if you actually try to compile and run it.

(a) link to the meaning of the offensive, impolite and rude phrase that caused righteous indignation, according to McGraw-Hill Dictionary of American Idioms and Phrasal Verbs and Cambridge Idioms Dictionary:

Blind leading the Blind

Answer 1

If we take a look at the unique_ptr class, we can see by default it uses an instance of the default_delete class. The default_delete class is has the following method: void operator()(T *ptr) const. To implement a custom deleter you would need to create a class looking something like the following (code adapted from here):

class MyDeleter
{
public:
    MyDeleter(FactoryReference *f)
    {
        m_factoryRef = f;
    }
    void operator()(IFace *ptr) const
    {
        delete ptr;
        m_factoryRef->unloadDLL();
    }
private:
    FactoryReference *m_factoryRef;
};

std::unique_ptr<IFace, MyDeleter> GetIFace()
{
    FactoryReferece *myFactory = /* a factory reference */;
    return new std::unique_ptr<IFace, MyDeleter>(myFactory->getIFaceSubclass(), MyDeleter(myFactory));
}

Answer 2

It can be done. Here is a skeleton for sample implementation that I tested. It was built with Visual C++/VS 2010.

Interface is declared in header Iface.h:

#pragma once

#include <memory>
#include <string>

#ifdef IFACE_EXPORTS
#define IFACE_API __declspec(dllexport)
#else
#define IFACE_API __declspec(dllimport)
#endif

namespace Generic
{

class Iface
{
public:
   virtual void DoSomething(std::string const&) = 0; 
   virtual ~Iface() {};
};

IFACE_API std::unique_ptr<Iface> GetIface();

typedef std::unique_ptr<Iface> (*GetIfaceType)();

}

Several Dlls implement this interface, while the third Dll called Factory, dynamically loads one of them. In turn, Factory exports a function for use by applications which would link to it implicitly (i.e. via export lib.)

Here is FactoryIface.h, to be included by client apps:

#pragma once

#include <memory>
#include "Iface.h"

#ifdef FACTORY_EXPORTS
#define FACTORY_API __declspec(dllexport)
#else
#define FACTORY_API __declspec(dllimport)
#endif

class FACTORY_API IFaceCustomDeleter
{
   void* hMod_;
public:
   IFaceCustomDeleter(void* hMod=nullptr);
   void operator()(Generic::Iface* ptr);
};

FACTORY_API std::unique_ptr<Generic::Iface, IFaceCustomDeleter> FactoryGetIface();

Note that custom deleter class must be exported. That was the first thing that I forgot to do. Building client app quickly pointed to it. Below is the crucial part, the implementation of FactoryGetIface() in Factory Dll:

// A trick to get decorated name of exported function
std::string DecoratedName;

namespace Generic
{
   std::unique_ptr<Iface> GetIface()
   {
      DecoratedName = __FUNCDNAME__;
      return std::unique_ptr<Iface>(nullptr);
   }
}

using namespace Generic;

// for keeping Iface from dynamically loaded DLL
std::unique_ptr<Iface> ExternalIface;

// Custome deleter implementation

IFaceCustomDeleter::IFaceCustomDeleter(void* hMod) 
   : hMod_(hMod) 
{
}

void IFaceCustomDeleter::operator()(Iface* ptr)
{
   ExternalIface.reset(nullptr);
   if(hMod_)
      ::FreeLibrary((HMODULE)hMod_);
}


FACTORY_API std::unique_ptr<Generic::Iface, IFaceCustomDeleter> FactoryGetIface()
{
   // determine path of DLL to load for Iface implementation
   auto path = L".\\IfaceImplB.dll";

   auto hmod = ::LoadLibrary(path);
   if(hmod)
   {
      GetIface(); // get decorated name

      GetIfaceType ptrGetIface;
      ptrGetIface = (GetIfaceType)::GetProcAddress(hmod, DecoratedName.c_str());
      // Alternatively, use full decorated name like below:
      //ptrGetIface = (GetIfaceType)::GetProcAddress(hmod,
      //"?GetIface@Generic@@YA?AV?$unique_ptr@VIface@Generic@@U?$default_delete@VIface@Generic@@@std@@@std@@XZ");

      if(ptrGetIface)
      {
         ExternalIface = ptrGetIface();
         ExternalIface->DoSomething("Hello from Factory");
         IFaceCustomDeleter del(hmod);
         return std::unique_ptr<Generic::Iface, IFaceCustomDeleter>(ExternalIface.get(), del);
      }
   }

   IFaceCustomDeleter del;
   return std::unique_ptr<Generic::Iface, IFaceCustomDeleter>(nullptr, del);
}

Note that Dll path is hard-coded: this is just a sample but it compiles and works. In actual application, one could have, for ex. parsing some xml specifying Dll to load.

Very basic console app that uses Iface via Factory goes like this:

#include "FactoryIface.h"

int _tmain(int argc, _TCHAR* argv[])
{
   {
      std::unique_ptr<Generic::Iface, IFaceCustomDeleter> iface = FactoryGetIface();
      iface->DoSomething("Hello from Factory user");
   }

    return 0;
}

When I run it I get output like this:

In IfaceImplB constructor
Doing something: Hello from Factory
Doing something: Hello from Factory user
In IfaceImplB destructor