Точки останова в повторяющихся фрагментах кода

[cyberdev]

Часто бывает, что один и тот же фрагмент кода повторяется очень много раз в разных участках программы. Чтобы много раз не переписывать один и тот же фрагмент во время его редактирования в Делфи, например, существуют локальные подпрограммы.

program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

  procedure Proc();
    var
      a, b, c : Integer;

    procedure Sub1();
    begin
      Dec(c, b);
      Inc(c);
    end;

    procedure Sub2();
    begin
      Dec(c, a);
    end;

  begin
    a := 1; b := 2; c := 3;
    Sub1();
    Writeln('c: ', c);
    Sub2();
    Writeln('c: ', c);
    Readln;
  end;


begin
  Proc();
end.

В C++ это можно сделать с помощью макросов

#include <iostream>

using namespace std;

int main()
{
    int a = 1, b = 2, c = 3;
    #define macro_1   \
            c -= b; \
            c++;
    #define macro_2 c -= a
    macro_1;
    cout << "c: " << c << endl;
    macro_2;
    cout << "c: " << c << endl;
    return 0;
}

Но если в Делфи можно поставить точку останова и наблюдать изменения во время отладки, то в C++ отладчик фрагменты в макросах просто не увидит. Как решить данную проблему в C++, чтобы отладчик видел эти фрагменты, как в Делфи?

[Пепел Феникса]

1)макросы зло, есть шаблоны. + макросы совсем не тоже самое что локальные функции в Делфи.
2)используйте обычные функции, не локальные.(хотя можно через лямбды извратится...)

[cyberdev]

Сообщение от Пепел Феникса

1)макросы зло, есть шаблоны. + макросы совсем не тоже самое что локальные функции в Делфи.

Макрос просто копирует свой текст в указанное место, на сколько я помню. А то что, при этом доступ отладчика закрыт к этому тексту, это действительно зло.

Какие шаблоны?

Сообщение от Пепел Феникса

2)используйте обычные функции, не локальные.(хотя можно через лямбды извратится...)

Не локальные функции не видят локальных переменных, а через параметры передавать их довольно муторно.

В результате, остаются только макросы, которые, к сожалению, не видит отладчик.

[Avazart]

Сообщение от cyberdev

локальные подпрограммы.

В С++ есть std::function и лямбды.

Сообщение от cyberdev

Какие шаблоны?

В С++ - шаблоны.
В Delphi - дженерики.

Сообщение от cyberdev

Не локальные функции не видят локальных переменных, а через параметры передавать их довольно муторно.

И это скорее всего - хорошо, чем плохо.

[New man]

Если тебе сложно передавать необходимые данные в виде аргументов, значит, код попахивает.

Передавай их в структурах/классах. ООП не зря придумали же.

[cyberdev]

Сообщение от New man

Если тебе сложно передавать необходимые данные в виде аргументов, значит, код попахивает.

Что делает код? :-)

Сообщение от New man

Передавай их в структурах/классах. ООП не зря придумали же.

Засунуть все переменные в класс ради кусков кода, а потом обращаться к объекту ради получения доступа к обычной перемеренной... Я уже думал об этом, но в результате получится еще сложнее чем, передать переменные в функции через параметры. Но и этот вариант получится очень громоздким. На Делфи я давно бы уже всё написал. Не раз на нем делал подобное. Но нельзя, ЯП строго С++.

Сообщение от Avazart

В С++ - шаблоны

Мне не приходилось работать с шаблонами в С++. Ну вот, допустим, я объявил шаблон.

template <typename subprogram>

Как мне написать теперь локальную функцио для работы с локальными переменными и вызвать её.

[Alex11223]

Какой еще subprogram? Там имя типа (например T) для использования в этой функции или классе, вместо которого при вызове функции или создании экземпляра класса указывается настоящий тип (для функций бывает автоматически).

Например

std::vector<int> myNumbers;

[New man]

Попахивает г*вном.

Суть в том, что для чистого кода характерна модульность и сокрытие того, что происходит "под капотом".
Модули должны быть слабо связанными, то есть, количество связей между ними должно быть как можно меньше.

Функцию тоже можно рассматривать как модуль. В таком случае, то, что ты не можешь передать в модуль достаточное количество аргументов, говорит о том, что она у тебя сильно связана с остальным кодом.

Поясню тебе за интерфейсы.

int do_smthng(int argument)
{
   argument += 5;
   return argument;
}

В этом коде `int do_smthng(int argument)` — интерфейс. Это то, что вызывающему коду должно быть достаточно, чтобы обращаться к этой функции.
А вот это: реализация:

{
   argument += 5;
   return argument;
}

И интерфейс с реализацией должны быть разделены, то есть, изменение реализации не должно заставлять изменять интерфейс (и вызовы) везде. То есть, вызывающий код зависит только от интерфейса, что сильно всё упрощает.

Таким образом, отсутствие возможности создания локальных функций связана именно с тем, что для локальной функции как раз характерно то, что вызывающий код вынужден зависеть от реализации этой функции, ведь она имеет возможность менять контекст.

Повторяю, твою проблему можно решить с помощью ООП.
Суть ООП в том, что объекты инкапсулируют в себе данные и методы их обработки.
То есть, тебе надо создать класс, который имеет следующий формат:

class SomeClass{
// данные, которые ты хочешь менять в виде полей
// методы класса, которые заменяют те локальные функции, изменяя данные в полях.
}

Далее в своей большой функции:

SomeClass my_data;
my_data.method1();
my_data.method2();

Это был первый способ.
Второй способ выноса локальных функций работает только для C++.
У тебя есть .h файл с описанием всех функций.
Ты можешь создать более одного cpp файла для него!
Хоть по одной на функцию.

И в cpp файле делаешь такой код:

struct Context{
 // Тут делаешь описания всех полей, которые тебе надо внутри большой функции
};

// локальные для cpp файла функции пишешь в таком формате
static int do_smth(Context& context, /*прочие аргументы*/)
{
// твой код
}

// Это та функция, которую ты описывал в h файле
void h_function(args)
{
   Context context; 
   // Тут инициализируешь поля
  // дальше можешь вызывать свои "локальные функции"
}

Тут важно слово "static" перед do_smth. Это слово означает, что функция существует только для этого cpp файла и не может быть вызвана снаружи.

Но этот метод достаточно плохой, плюс, он, по сути, является недоООП.

Ну, и последний, самый дрянной метод, который сломает мозги тому, кто будет поддерживать твой код, из-за чего этот псих найдёт тебя и зарубит топором.
Использование лямбда выражений!
Просто пишешь внутри метода:

  auto my_local_func = [&](int a, float b)
  {
       // Тут твой код
  };
  // ...
  my_local_func(6,8979.0);

По сути, это работает именно как локальные функции (пусть и с созданием объекта-функции).
Важная вещь — квадратные скобки.
[a, b, &c] — К обычным аргументам лямбда ещё примет копии a,b и ссылку на c, и сможет это использовать.
[=] — функция получит копию всего, что есть в верхней функции.
[&] — функция получит ссылку на все переменные, что есть в верхней. Это именно то, что в Delphi, python и т. п.

Надеюсь, я тебе прояснил твои возможности.

[cyberdev]

Сообщение от Alex11223

Какой еще subprogram?

Я же говорю, никогда не работал с шаблонами в С++.

Работаю в данный момент со скриптовым языком, аналог С++. Лямбд там нет, std тоже. Работают только шаблоны. Но как их использовать в качестве локальных подпрограмм, понятия не имею и в интернете никакой информации по этому не нашел.

Сообщение от New man

Попахивает г*вном

Снова вы про него? Ну что за мода, делать такие выводы не зная цели для которой решается задача? Хватит! А то неприятно, аж сюда подванивает.

[New man]

В таком случае у тебя остаётся только два варианта:
1) стиснуть зубы и отрефакторить код так, чтобы он нормально декомпозировался на меньшие функции;
2) писать как есть.

Сообщение от cyberdev

А то неприятно, аж сюда подванивает.

Конечно, это же Вы читаете свой код