¿Puedo implementar el patrón Factory Method en C++ sin usar new?

Question

Estoy trabajando en un entorno incrustado (Arduino/AVR ATMega328) y quiero implementar el patrón Factory Method en C++. Sin embargo, el compilador que estoy usando (avr-gcc) no admite la palabra clave new. ¿Hay alguna forma de implementar este patrón sin usar new?

Answer 1

Dado que el compilador AVR se basa en el compilador gcc, es muy probable que admita la palabra clave nueva. ¿Cuál es exactamente el error que está recibiendo? Supongo que es un error de enlace/compilación en la línea de una función no definida, es decir, un operador nuevo. Hay una diferencia entre el nuevo operador y el operador nuevo, el primero se usa para crear objetos y el último se usa para asignar memoria a los objetos. El nuevo operador llama al operador nuevo para el tipo de objeto que se está creando, luego inicializa la tabla v del objeto y llama a los constructores del objeto. Reading this FAQ dice que el operador nuevo no está definido en las bibliotecas estándar. Esto es fácil de solucionar, simplemente definir una:

void *operator new (size_t size) 
{ 
    return some allocated memory big enough to hold size bytes 
} 

y tendrá que definir un eliminar así:

void operator delete (void *memory) 
{ 
    free the memory 
} 

La única cosa que añadir es la gestión de la memoria, la asignación y liberación de bloques de memoria. Esto se puede hacer de manera trivial, teniendo cuidado de no dañar ninguna memoria asignada existente (el código, datos estáticos/globales, la pila).Debería tener dos símbolos definidos: uno para el inicio de la memoria libre y otro para el final de la memoria libre. Puede asignar dinámicamente y liberar cualquier porción de memoria en esta región. Tendrá que administrar esta memoria usted mismo.

Answer 2

¿Se puede hacer malloc? Si es así, puedes malloc tu objeto de esa manera.

¿Cuál es la naturaleza de los objetos que desea crear en la fábrica?

• ¿Son imputables?
• ¿La fábrica solo está destinada a producir un conjunto limitado de objetos que puedan conocerse en tiempo de compilación?

Si la respuesta es sí a ambas preguntas, puede asignar estáticamente la memoria para su conjunto de objetos inmutables y dejar que el método de fábrica devuelva los punteros al objeto apropiado.

Esto no funcionará si la respuesta es no a cualquiera de las preguntas. También con este enfoque, usted tiene el problema de tener siempre esa memoria asignada.

Answer 3

Si no hay forma de instanciar una clase en tiempo de ejecución, supongo que esto no es posible. Todo lo que podría hacer es asignar previamente algunos objetos en el momento de la compilación, crear referencias a ellos y devolverlos cuando sea necesario.

Answer 4

¿Qué tal algo como esto?

MyClass *objp = (MyClass*)malloc(sizeof(MyClass)); 
*objp = MyClass(); // or any other c'tor 

EDIT: He olvidado mencionar, que asume MyClass tiene un operador de asignación.

EDIT2: Otra cosa que olvidé - sí, hay una gotcha (es C++, siempre hay errores). Tendrás que llamar manualmente al objeto para el objeto, ya que no puedes usarlo gratis.

Answer 5

Si está utilizando la fábrica significa que desea un comportamiento de enlace dinámico que indique que tiene algunas funciones virtuales. Aunque, puede ser posible asignar la memoria para el objeto usando malloc() el vtable de la clase no se configurará correctamente y, por lo tanto, la llamada a las funciones virtuales se bloqueará. No veo ninguna forma de hacerlo cuando se requiere enlace dinámico.

Answer 6

Una manera que he resuelto este problema en un sistema integrado con estrictas normas de codificación (donde no se nos permitía usar "nuevo" o "eliminar") era crear una matriz estática del objeto deseado. Y luego use punteros estáticos para los objetos ya asignados, almacenando estos valores devueltos (usando variables estáticas y/o variables de miembros) para la posterior ejecución de los diversos objetos.

// Class File --------------------------------------------------- 
class MyObject { 
    public: 
     MyObject* getObject(); 

    private: 
     const int MAX_POSSIBLE_COUNT_OF_OBJECTS = 10; 
     static MyObject allocatedObjects[MAX_POSSIBLE_COUNT_OF_OBJECTS]; 

     static allocatedObjectIndex = 0; 
}; 

// Implementation File ------------------------------------------ 

// Instantiate a static array of your objects. 
static MyObject::allocatedObject[MAX_POSSIBLE_COUNT_OF_OBJECTS]; 

// Your method to return already created objects. 
MyObject* MyObject::getObject() { 

    if (allocatedObjectIndex < (MAX_POSSIBLE_COUNT_OF_OBJECTS - 1)) { 
     return allocatedObjects[allocatedObjectIndex++]; 
    } else { 
     // Log error if possible 
     return NULL; 
    } 
} 

Tenga en cuenta. Todo esto es de memoria ya que no he escrito ningún C++ en más de 8 meses.

También Nota: Esto tiene un serio inconveniente ya que está asignando un montón de RAM en tiempo de compilación.

Answer 7

La idea general del método de fábrica es la creación de objetos, lo que significa un consumo de memoria en montón. En un sistema integrado, la RAM lo limita y necesita tomar todas las decisiones de diseño teniendo en cuenta los límites de memoria. El ATmega328 solo tiene 2 KB de RAM. Recomendaría no utilizar memoria asignada dinámicamente en un espacio tan reducido.

Sin conocer su problema con más detalle, recomendaría estáticamente declarar un puñado de instancias de la clase y volver a utilizar esas instancias de alguna manera. Esto significa que necesita saber cuándo y por qué se crean sus objetos y, ASÍ COMO IMPORTANTE, cuándo y por qué terminan; entonces necesita averiguar cuántos necesita tener activados al mismo tiempo y cuántos es posible tener activo a la vez.

Dean