Esta es también una pregunta que hice en un comentario en uno de Miško Heveryconversaciones de google eso estaba relacionado con la inyección de dependencia, pero quedó enterrado en los comentarios.

Me pregunto cómo puede funcionar el paso de fábrica / constructor de conectar las dependencias en C ++.

Es decir. tenemos una clase A que depende de B. El constructor asignará B en el montón, pasará un puntero a B en el constructor de A mientras también asigna en el montón y devolverá un puntero a A.

¿Quién limpia después? ¿Es bueno dejar que el constructor limpie después de que haya terminado? Parece ser el método correcto ya que en la charla dice que el constructor debe configurar los objetos que se espera que tengan la misma vida útil o al menos las dependencias tienen una vida útil más larga (también tengo una pregunta al respecto). Lo que quiero decir en el código:

class builder {
public:
    builder() :
        m_ClassA(NULL),m_ClassB(NULL) {
    }
    ~builder() {
        if (m_ClassB) {
            delete m_ClassB;
        }
        if (m_ClassA) {
            delete m_ClassA;
        }
    }
    ClassA *build() {
        m_ClassB = new class B;
        m_ClassA = new class A(m_ClassB);
        return m_ClassA;
    }
};

Ahora, si hay una dependencia que se espera que dure más que la vida útil del objeto en el que lo estamos inyectando (por ejemplo, ClassC es esa dependencia), entiendo que deberíamos cambiar el método de compilación a algo como:

ClassA *builder::build(ClassC *classC) {
    m_ClassB = new class B;
    m_ClassA = new class A(m_ClassB, classC);
    return m_ClassA;
}

¿Cuál es tu enfoque preferido?