¿Es este un buen patrón: reemplazar una función larga con una serie de lambdas?

Recientemente me encontré con la siguiente situación.

class A{
public:
    void calculate(T inputs);
}

En primer lugar, Arepresenta un objeto en el mundo físico, que es un fuerte argumento para no dividir la clase. Ahora, calculate()resulta ser una función bastante larga y complicada. Percibo tres posibles estructuras para ello:

• escríbalo como un muro de texto - ventajas - toda la información está en un solo lugar
• escribir privatefunciones de utilidad en la clase y usarlas en calculateel cuerpo de la persona - desventajas - el resto de la clase no sabe / no se preocupa por esos métodos

• escribe de calculatela siguiente manera:

  void A::calculate(T inputs){    
      auto lambda1 = () [] {};    
      auto lambda2 = () [] {};    
      auto lambda3 = () [] {};
  
      lambda1(inputs.first_logical_chunk);
      lambda2(inputs.second_logical_chunk);
      lambda3(inputs.third_logical_chunk);
  }

¿Se puede considerar esto una buena o mala práctica? ¿Este enfoque revela algún problema? Con todo, ¿debería considerar esto como un buen enfoque cuando me enfrento nuevamente a la misma situación?

EDITAR:

class A{
    ...
public:
    // Reconfiguration of the algorithm.
    void set_colour(double colour);
    void set_density(double density);
    void set_predelay(unsigned long microseconds);
    void set_reverb_time(double reverb_time, double room_size);
    void set_drywet(double left, double right);
    void set_room_size(double value);;

private:
    // Sub-model objects.
    ...
}

Todos esos métodos:

• obtener un valor
• calcular algunos otros valores, sin usar el estado
• llame a algunos de los "objetos de submodelo" para cambiar su estado.

Resulta que, con excepción set_room_size(), esos métodos simplemente pasan el valor solicitado a los subobjetos. set_room_size(), por otro lado, hace un par de pantallas de fórmulas oscuras y luego (2) hace media pantalla para llamar a los colocadores de subobjetos para aplicar los diversos resultados obtenidos. Por lo tanto, he separado la función en dos lambdas y las llamo al final de la función. Si hubiera podido dividirlo en partes más lógicas, habría aislado más lambdas.

En cualquier caso, el objetivo de la pregunta actual es determinar si esa forma de pensar debe persistir o, en el mejor de los casos, no agrega valor (legibilidad, facilidad de mantenimiento, capacidad de depuración, etc.).

No, este no es generalmente un buen patrón.

Lo que estás haciendo es dividir una función en funciones más pequeñas usando lambda. Sin embargo, hay una herramienta mucho mejor para dividir funciones: funciones.

Las lambdas funcionan, como has visto, pero significan mucho, mucho, mucho, mucho más que simplemente dividir una función en bits locales. Las lambdas hacen:

• Cierres. Puede usar variables en el ámbito externo dentro de la lambda. Esto es muy poderoso y muy complicado.
• Reasignación Si bien su ejemplo dificulta la tarea, siempre hay que prestar atención a la idea de que el código puede intercambiar funciones en cualquier momento.
• Funciones de primera clase. Puede pasar una función lambda a otra función, haciendo algo conocido como "programación funcional".

En el instante en que incorporas lambdas a la mezcla, el siguiente desarrollador que mire el código debe cargar mentalmente de inmediato todas esas reglas en preparación para ver cómo funciona tu código. No saben que no vas a utilizar toda esa funcionalidad. Esto es muy costoso, en comparación con las alternativas.

Es como usar una azada trasera para hacer tu jardinería. Sabes que solo lo estás usando para cavar pequeños agujeros para las flores de este año, pero los vecinos se pondrán nerviosos.

Considere que todo lo que está haciendo es agrupar su código fuente visualmente. Al compilador en realidad no le importa que currieses cosas con lambdas. De hecho, esperaría que el optimizador deshaga inmediatamente todo lo que acaba de hacer cuando se compila. Está atendiendo al siguiente lector (¡Gracias por hacerlo, incluso si no estamos de acuerdo con la metodología! ¡El código se lee con mucha más frecuencia de lo que se escribe!). Todo lo que está haciendo es agrupar la funcionalidad.

• Las funciones ubicadas localmente dentro de la secuencia de código fuente funcionarían igual de bien, sin invocar lambda. Nuevamente, todo lo que importa es que el lector pueda leerlo.
• Los comentarios en la parte superior de la función dicen "estamos dividiendo esta función en tres partes", seguidos de grandes líneas largas // ------------------entre cada parte.
• También puede poner cada parte del cálculo en su propio ámbito. Esto tiene la ventaja de demostrar inmediatamente, más allá de toda duda, que no existe un intercambio variable entre las partes.

EDITAR: al ver su edición con un código de ejemplo, me inclino hacia la notación de comentarios como la más limpia, con corchetes para imponer los límites que sugieren los comentarios. Sin embargo, si alguna de las funciones fuera reutilizable en otras funciones, recomendaría usar funciones en su lugar

void A::set_room_size(double value)
{
    {
        // Part 1: {description of part 1}
        ...
    }
    // ------------------------
    {
        // Part 2: {description of part 2}
        ...
    }
    // ------------------------
    {
        // Part 3: {description of part 3}
        ...
    }
}

Creo que hiciste una mala suposición:

En primer lugar, A representa un objeto en el mundo físico, que es un fuerte argumento para no dividir la clase.

No estoy de acuerdo con esto. Por ejemplo, si tuviera una clase que represente un automóvil, definitivamente querría dividirlo, porque seguramente quiero una clase más pequeña que represente los neumáticos.

Debería dividir esta función en funciones privadas más pequeñas. Si realmente parece separado de la otra parte de la clase, entonces eso puede ser una señal de que la clase debería estar separada. Por supuesto, es difícil saberlo sin un ejemplo explícito.

Realmente no veo la ventaja de usar funciones lambda en este caso, porque realmente no hace que el código sea más limpio. Fueron creados para ayudar a la programación de estilo funcional, pero esto no es eso.

Lo que escribió se parece un poco a los objetos de función anidados de estilo Javascript. Lo cual es nuevamente una señal de que están estrechamente unidos. ¿Estás seguro de que no deberías hacer una clase separada para ellos?

En resumen, no creo que este sea un buen patrón.

ACTUALIZAR

Si no ve ninguna forma de encapsular esta funcionalidad en una clase significativa, puede crear funciones auxiliares de ámbito de archivo, que no son miembros de su clase. Esto es C ++ después de todo, el diseño OO no es obligatorio.