Vendimi su contenitori IoC, per favore

Ho visto diversi consigliare l'uso di contenitori IoC nel codice. La motivazione è semplice. Prendi il seguente codice iniettato di dipendenza:

class UnitUnderTest
{
    std::auto_ptr<Dependency> d_;
public:
    UnitUnderTest(
        std::auto_ptr<Dependency> d = std::auto_ptr<Dependency>(new ConcreteDependency)
    ) : d_(d)
    {
    }
};


TEST(UnitUnderTest, Example)
{
    std::auto_ptr<Dependency> dep(new MockDependency);
    UnitUnderTest uut(dep);
    //Test here
}

Into:

class UnitUnderTest
{
    std::auto_ptr<Dependency> d_;
public:
    UnitUnderTest()
    {
        d_.reset(static_cast<Dependency *>(IocContainer::Get("Dependency")));
    }
};


TEST(UnitUnderTest, Example)
{
    UnitUnderTest uut;
    //Test here
}

//Config for IOC container normally
<Dependency>ConcreteDependency</Dependency>

//Config for IOC container for testing
<Dependency>MockDependency</Dependency>

(Quanto sopra è ipotetico esempio C ++ ovviamente)

Anche se sono d'accordo sul fatto che questo semplifica l'interfaccia della classe rimuovendo il parametro del costruttore di dipendenza, penso che la cura sia peggiore della malattia per un paio di motivi. Innanzitutto, e questo è un grosso problema per me, questo rende il tuo programma dipendente da un file di configurazione esterno. Se hai bisogno di una singola distribuzione binaria, semplicemente non puoi usare questi tipi di contenitori. Il secondo problema è che l'API ora è debolmente e peggio, stringly digitato. L'evidenza (in questo esempio ipotetico) è l'argomento della stringa sul contenitore IoC e il cast sul risultato.

Quindi .. ci sono altri vantaggi nell'utilizzare questo tipo di contenitori o non sono d'accordo con quelli che raccomandano i contenitori?