Функция C вызывается только один раз и цикломатическая сложность

Я думаю, что этот вопрос больше о стиле: у меня есть алгоритм с очень высоким CC (и большим количеством строк!). Я хочу уменьшить его, и это легко, поскольку есть фрагменты кода, которые можно сгруппировать. Проблема в том, что, поступая таким образом, у меня была бы «большая» функция, вызывающая «маленькие» функции, которые вызываются только один раз.

На мой взгляд, разбиение большой функции на мелкие части лучше для разборчивости кода (в данном случае), несмотря на то, что функции вызываются один раз.

Что ты думаешь? Как вы поступаете в подобных случаях?


c function cyclomatic-complexity
person Schopenhauer    schedule 21.05.2010    source источник

Ответы (4)


arrow_upward
7
arrow_downward

Отличная идея - разбить большую функцию на более мелкие, в основном отдельные куски. Это делает код более читаемым, а поток управления - более понятным.

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

person Thomas    schedule 21.05.2010
comment
Если подумать, даже если не статические, функции все же могут быть встроены, конечно, за счет некоторого дублирования кода. И даже если этого не произойдет, генерация кода во время компоновки все равно может выполнять встраивание. - person Thomas; 21.05.2010

arrow_upward
3
arrow_downward

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

person Arkaitz Jimenez    schedule 21.05.2010

arrow_upward
2
arrow_downward

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

Допустим, у нас есть такая структура:

typedef struct foo {
     char *foo;
     int bar;
     double foobar;
} foo_t;

И мы пишем что-то для его инициализации / распределения:

foo_t *foome(void)
{
    foo_t *ret;

    ret = (foo_t *) malloc(sizeof(struct foo));

    ...
    ...
}

Но почему мы прошли через все эти проблемы, когда foome() вызывается только один раз, в main()? Потому что мы хотим, чтобы следующий человек, который должен иметь дело с нашей программой, мог взглянуть на main() и сразу понять, чего мы пытаемся достичь.

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

Это сохраняет здравомыслие и помогает окружающей среде, потому что теперь мне не нужно распечатывать все 60 страниц вашего алгоритма и размещать их на столе, чтобы я мог его прочитать :)

person Tim Post♦    schedule 21.05.2010

arrow_upward
0
arrow_downward

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

person Patrick Schlüter    schedule 21.05.2010