Czy to dobry wzór: zastąpienie długiej funkcji serią lambdów?

Niedawno wpadłem na następującą sytuację.

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

Po pierwsze, Areprezentuje obiekt w świecie fizycznym, co jest silnym argumentem za nierozdzielaniem klasy. Teraz calculate()okazuje się dość długą i skomplikowaną funkcją. Widzę trzy możliwe struktury:

• napisz to jako ścianę tekstu - zalety - wszystkie informacje są w jednym miejscu
• pisz privatefunkcje użytkowe w klasie i używaj ich w calculateciele - wady - reszta klasy nie zna / nie dba / nie rozumie tych metod

• napisz calculatew następujący sposób:

  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);
  }
  

Czy można to uznać za dobrą lub złą praktykę? Czy takie podejście ujawnia jakieś problemy? Podsumowując, czy powinienem uznać to za dobre podejście, gdy znów mam do czynienia z tą samą sytuacją?

EDYTOWAĆ:

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.
    ...
}

Wszystkie te metody:

• uzyskać wartość
• oblicz inne wartości bez użycia stanu
• wywołać niektóre z „obiektów podmodelu”, aby zmienić ich stan.

Okazuje się, że poza set_room_size()tymi metodami po prostu przekazują żądaną wartość do podobiektów. set_room_size()z drugiej strony wykonuje kilka ekranów niejasnych wzorów, a następnie (2) wykonuje pół ekranu wywoływania seterów podobiektów w celu zastosowania różnych uzyskanych wyników. Dlatego podzieliłem funkcję na dwie lambdy i wywołałem je na końcu funkcji. Gdybym był w stanie podzielić to na bardziej logiczne części, izolowałbym więcej lambdów.

Niezależnie od tego, celem obecnego pytania jest ustalenie, czy taki sposób myślenia powinien się utrzymywać, czy w najlepszym razie nie stanowi wartości dodanej (czytelność, łatwość konserwacji, zdolność debugowania itp.).

Nie, ogólnie nie jest to dobry wzór

To, co robisz, polega na rozbiciu funkcji na mniejsze funkcje za pomocą lambda. Istnieje jednak znacznie lepsze narzędzie do dzielenia funkcji: funkcji.

Lambdy działają, jak widzieliście, ale znaczą o wiele, wiele więcej, niż zwykłe rozbicie funkcji na lokalne elementy. Lambdas:

• Domknięcia. Możesz używać zmiennych w zakresie zewnętrznym wewnątrz lambda. Jest to bardzo potężne i bardzo skomplikowane.
• Zmiana przypisania Podczas gdy twój przykład utrudnia wykonanie zadania, zawsze należy zwrócić uwagę na pomysł, że kod może zamieniać funkcje w dowolnym momencie.
• Funkcje pierwszej klasy. Możesz przekazać funkcję lambda do innej funkcji, robiąc coś zwanego „programowaniem funkcjonalnym”.

Gdy tylko włączysz lambdy do miksu, następny programista, który zajrzy do kodu, musi natychmiast załadować mentalnie wszystkie te reguły, przygotowując się do zobaczenia, jak działa Twój kod. Nie wiedzą, że nie będziesz korzystać z całej tej funkcjonalności. Jest to bardzo kosztowne w porównaniu do alternatyw.

To tak, jakbyś używał motyki do ogrodnictwa. Wiesz, że używasz go tylko do kopania małych dziur na tegoroczne kwiaty, ale sąsiedzi się denerwują.

Pomyśl, że wszystko, co robisz, to grupowanie kodu źródłowego wizualnie. Kompilator tak naprawdę nie dba o to, abyś curry rzeczy z lambdas. W rzeczywistości spodziewałbym się, że optymalizator natychmiast cofnie wszystko, co właśnie zrobiłeś podczas kompilacji. Obsługujesz wyłącznie kolejnego czytelnika (Dziękujemy za zrobienie tego, nawet jeśli nie zgadzamy się co do metodologii! Kod jest czytany znacznie częściej niż jest napisany!). Wszystko, co robisz, to funkcja grupowania.

• Funkcje umieszczone lokalnie w strumieniu kodu źródłowego działałyby równie dobrze, bez wywoływania lambda. Ponownie liczy się tylko to, że czytelnik może to przeczytać.
• Komentarze u góry funkcji mówią „dzielimy tę funkcję na trzy części”, po których następują duże długie linie // ------------------między każdą częścią.
• Możesz także umieścić każdą część obliczeń we własnym zakresie. Ma to tę zaletę, że natychmiast dowodzi ponad wszelką wątpliwość, że nie ma podziału zmiennych między częściami.

EDYCJA: Patrząc na twoją edycję z przykładowym kodem, pochylam się, aby notacja komentarza była najczystsza, z nawiasami, aby wymusić granice sugerowane przez komentarze. Jednak jeśli którakolwiek z funkcji może być ponownie użyta w innych funkcjach, zalecam użycie funkcji zamiast tego

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}
        ...
    }
}

Myślę, że źle przyjęłeś:

Po pierwsze, A reprezentuje obiekt w świecie fizycznym, co jest silnym argumentem za tym, aby nie dzielić klasy.

Nie zgadzam się z tym. Na przykład, gdybym miał klasę reprezentującą samochód, zdecydowanie chciałbym go podzielić, ponieważ z pewnością chcę, aby mniejsza klasa reprezentowała opony.

Tę funkcję należy podzielić na mniejsze funkcje prywatne. Jeśli naprawdę wydaje się oddzielony od innej części klasy, może to oznaczać, że klasa powinna być oddzielona. Oczywiście trudno powiedzieć bez wyraźnego przykładu.

W tym przypadku nie widzę korzyści z używania funkcji lambda, ponieważ tak naprawdę nie czyści kodu. Zostały one stworzone, aby wspomóc programowanie w stylu funkcjonalnym, ale to nie wszystko.

To, co napisałeś, przypomina trochę zagnieżdżone obiekty funkcyjne w stylu Javascript. Co znowu jest znakiem, że należą do siebie ściśle. Czy jesteś pewien, że nie powinieneś tworzyć dla nich osobnej klasy?

Podsumowując, nie sądzę, że jest to dobry wzór.

AKTUALIZACJA

Jeśli nie widzisz żadnego sposobu na zawarcie tej funkcjonalności w znaczącej klasie, możesz utworzyć funkcje pomocnicze o zasięgu pliku, które nie są członkami twojej klasy. To w końcu C ++, projektowanie OO nie jest koniecznością.