Це хороша закономірність: заміна тривалої функції рядом лямбда?

Нещодавно я натрапив на таку ситуацію.

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

По-перше, Aявляє собою об'єкт у фізичному світі, що є сильним аргументом для нерозбиття класу. Зараз, calculate()виявляється, досить довга і складна функція. Я сприймаю три можливі структури для цього:

• запишіть це як стінку тексту - переваги - вся інформація знаходиться в одному місці
• писати privateфункції класу в класі та використовувати їх у calculateтілі тіла - недоліки - решта класу не знає / не піклується / не розуміє про ці методи

• написати calculateтак:

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

Чи можна це вважати хорошою чи поганою практикою? Чи виявляє такий підхід якісь проблеми? Загалом, чи слід вважати це добрим підходом, коли я знову стикаюся з тією ж ситуацією?

Редагувати:

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

Усі ці методи:

• отримати значення
• обчислити деякі інші значення, не використовуючи стан
• зателефонуйте до деяких із "підмодельних об'єктів", щоб змінити їх стан.

Виявляється, що, за винятком set_room_size()цих методів, просто передає потрібне значення суб'єктам. set_room_size()з іншого боку, робить пару екранів незрозумілих формул, а потім (2) робить половину екрана виклику наборів підпредметів, щоб застосувати різні отримані результати. Тому я розділив функцію на дві лямбда і називаю їх у кінці функції. Якби мені вдалося розділити це на більш логічні шматки, я б виділив більше лямбда.

Незважаючи на те, мета поточного питання полягає у визначенні того, чи повинен такий спосіб мислення зберігатись, чи він у кращому випадку не додає цінності (читабельність, ремонтопридатність, здатність налагодження тощо).

Ні, це, як правило, не вдалий зразок

Те, що ви робите, - це розбиття функції на більш дрібні функції за допомогою лямбда. Однак є набагато кращий інструмент для розбивання функцій: функції.

Як ви бачили, лямбдаси працюють, але вони означають набагато набагато набагато більше, ніж просто розбиття функції на локальні біти. Лямбди роблять:

• Закриття Можна використовувати змінні у зовнішній області всередині лямбда. Це дуже потужно і дуже складно.
• Перепризначення. Хоча ваш приклад ускладнює виконання завдання, завжди потрібно звертати увагу на ідею, що код може змінювати функції в будь-який час.
• Першокласні функції. Ви можете передати лямбда-функцію іншій функції, виконуючи щось відоме як "функціональне програмування".

Щойно ви внесете лямбда в суміш, наступний розробник, який подивиться на код, повинен негайно подумки завантажити всі ці правила, готуючись побачити, як працює ваш код. Вони не знають, що ви не збираєтесь використовувати весь цей функціонал. Це дуже дорого, порівняно з альтернативами.

Це як використовувати маточку для садівництва. Ви знаєте, що ви використовуєте його лише для викопування маленьких ям для квітів цього року, але сусіди будуть нервувати.

Подумайте, що все, що ви робите, - це візуально групувати свій вихідний код. Компілятор насправді не переймається тим, що ви бавили речі з лямбдами. Насправді я б очікував, що оптимізатор негайно скасує все, що ви робили під час компіляції. Ви чисто задовольняєтесь наступному читачеві (спасибі за це, навіть якщо ми не погоджуємось з методологією! Код читається набагато частіше, ніж написано!). Все, що ви робите, - це групування функціональності.

• Функції, розміщені локально в потоці вихідного коду, будуть виконуватись так само добре, не викликаючи лямбда. Знову ж таки, все важливо - читач може це прочитати.
• Коментарі у верхній частині функції говорять "ми ділимо цю функцію на три частини", а потім великі довгі рядки // ------------------між кожною частиною.
• Ви також можете помістити кожну частину розрахунку у власну сферу. Це бонус негайно довести, що не викликає сумнівів, що не існує змінної розподілу між частинами.

РЕДАКТУВАННЯ: Побачивши вашу редагування з прикладом коду, я схиляюся до того, що нотація коментарів є найчистішою, з дужками для забезпечення меж, які пропонують коментарі. Однак якщо будь-який з функцій повторно використовувався в інших функціях, я рекомендую замість цього використовувати функції

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

Я думаю, ти зробив неправильне припущення:

По-перше, A являє собою об'єкт у фізичному світі, що є сильним аргументом для нерозбиття класу.

Я не згоден з цим. Наприклад, якби у мене був клас, який представляє автомобіль, я б точно хотів розділити його, тому що я, безумовно, хочу, щоб менший клас представляв шини.

Ви повинні розділити цю функцію на менші приватні функції. Якщо це дійсно здається відокремленим від іншої частини класу, то це може бути ознакою того, що клас слід відокремити. Звичайно, важко сказати без явного прикладу.

Я не бачу переваги використання лямбда-функцій у цьому випадку, оскільки це насправді не робить код чистішим. Вони були створені, щоб допомогти програмуванню функціонального стилю, але це не так.

Те, що ви написали, трохи нагадує вкладені об’єкти функцій у стилі Javascript. Це знову ж таки ознака того, що вони тісно належать разом. Ви впевнені, що вам не слід складати для них окремий клас?

Підводячи підсумок, я не думаю, що це гарна модель.

ОНОВЛЕННЯ

Якщо ви не бачите жодного способу інкапсулювати цю функціональність у значущому класі, то ви можете створити допоміжні функції, що охоплюють файли, які не є членами вашого класу. Зрештою, це C ++, дизайн OO не обов'язковий.