Обработка ошибок короткого замыкания в C

Я видел использование GOTO в C именно для этой цели.

Поскольку в C нет конструкции «finally», требовался метод для освобождения всей вашей памяти, даже если вы выходили из функции раньше.

По сути, это выглядит следующим образом (может ли кто-нибудь исправить мой синтаксис C, если я ошибаюсь, я немного заржавел)

int foo()
{
    /* Do Stuff */
    if(!DoSomething())
        GOTO Failure;

    if(!DoSomething2())
        GOTO Failure;

    if(!DoSomething3())
        GOTO Failure;

    /* return success */
    return true; 

    Failure:
    /* release allocated resources */
    /* print to log if necessary */
    return false;
}

Важное примечание. Не используйте GOTO для выполнения. Их следует использовать только при ошибке и только для перехода к концу текущей функции. Если вы используете их для чего-то еще, вы создаете спагетти-код, который может разрушить ткань реальности. Просто не делай этого.

ИЗМЕНИТЬ

Как отмечалось на одном из плакатов, использование Exit (x) приведет к уничтожению всей вашей программы, что оставляет это решение зарезервированным для фатальных ошибок. Однако ваше исходное предложенное решение (DS () && DS2 () && DS3 ()) все в одной строке создает проблему для обработки ошибок.

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

int result1 = 0;
int result2 = 0;
int result3 = 0;

result1 = DoSomething();

if(result1)
    result2 = DoSomething2();

if(result2)
    result3 = DoSomething3();

return result1 && result2 && result3;

Потому что этот метод не исключает обработки ошибок.

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

return doSomething()
    && doSomething2()
    && doSomething3()
    && ... ;

Второй случай я пишу так:

if (!(value = doSomething()))  return NULL;
if (!(value = doSomething2())) return NULL;
: : : : :
return value;

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

Как насчет этого?

int result;

result = doSomething();

result = result && doSomething2();

result = result && doSomething3();

return result;

Он использует короткое замыкание аналогично вашему первому примеру, но позволяет разбить его на несколько строк и добавить комментарии и т. Д.

Я рекомендую против предложенной вами техники. Сначала exit в C завершает процесс; он не просто возвращается. Таким образом, это ограничено лишь несколькими случаями фатальных ошибок.

Первое решение, которого вы пытаетесь избежать, с моей точки зрения является наиболее простым и понятным.

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

Другими словами, у вас второй подход.

В качестве примера можно написать функцию для копирования строки следующим образом:

int copy_string(char *source, char *target, size_t max)
{
    if (source == NULL)
        return -1;
    if (target == NULL)
        return -1;
    source_len = strlen(source);
    if (source_len + 1 > max)   // +1 for NUL
        return -1;
    memcpy(target, source, source_len + 1);
    return 0;
}

(Мне нравится соглашение о системных вызовах Unix, согласно которому в случае ошибок возвращается -1, но это спорный вопрос стиля и не имеет отношения к этому вопросу.)

Я видел это раньше:

int Function (void)
{
    int Result = DoSomething();

    if (Result) Result = DoSomething2();
    if (Result) Result = DoSomething3();
    if (Result) Result = DoSeomthing4();

    return Result;
}

Смотрится достаточно аккуратно, легко выравнивается. Он не выйдет сразу, но больше ничего не выполнит. Это, конечно, предполагает, что в случае успеха функции возвращают ненулевое значение. В противном случае вы можете просто использовать if (!Result), если функции возвращают ненулевое значение при ошибке.