MBy>Пишу на Си. Например, некая ф-ия не смогла что-то выполнить и вернула ошибку. Продолжение выполнения программы стало безсмысленным. Как в таком случае правильнее всего обработать эту ошибку и выйти из программы? При том следует учесть, что необходимо закрыть n-ое количество файлов и вернуть в кучу выделиную память, то есть сделать не выброс а корректное завершение.

exit (1);

КР>Что это за лимиты?

оттуда же
Because computers are finite, C++ implementations are inevitably limited in the size of the programs they
can successfully process. Every implementation shall document those limitations where known. This documentation
may cite fixed limits where they exist, say how to compute variable limits as a function of
available resources, or say that fixed limits do not exist or are unknown.

MSDN: ms-help://MS.MSDNQTR.v80.en/MS.MSDN.v80/MS.VisualStudio.v80.en/dv_vclang/html/f1fa59c6-55b4-414b-80c5-3df72952160d.htm
The C++ standard recommends limits for various language constructs. The following is a list of constructs where the Visual C++ compiler does not implement the recommended limits. The first number is the recommended limit and the second number is the limit implemented by Visual C++:
— Nesting levels of compound statements, iteration control structures, and selection control structures [256] (64).
— Parameters in one macro definition [256] (127).
— Arguments in one macro invocation [256] (127).
— Characters in a character string literal or wide string literal (after concatenation) [65536] (65535).
— Levels of nested class, structure, or union definitions in a single struct-declaration-list [256] (16).
— Member initializers in a constructor definition [6144] (approximately 600, memory dependent, can increase with the /Zm compiler -option).
— Scope qualifications of one identifier [256] (127).
— Nested external specifications [1024] (10).
— Template arguments in a template declaration [1024] (64).

MBy>/* ... */
MBy>  SOME_HANDLE handle = NULL;
MBy>  char* str = NULL;

MBy>  if( some_constructor( &handle ) )
MBy>    goto the_end;

MBy>  str = calloc( 16, sizeof(char) );
MBy>  if( str == NULL )
MBy>    goto the_end;

MBy>  if( some_func( handle, str ) )
MBy>    goto the_end;

MBy>the_end:
MBy>  if( handle )
MBy>    some_destructor( handle );
MBy>  if( str )
MBy>    free( str );

MBy>  return;

MBy>/* ... */
MBy>

MBy>Или я не в ту сторону думаю?

/* ... */
SOME_HANDLE handle = NULL;
char* str = NULL;

do
{
    if( some_constructor( &handle ) )
        break;

    str = calloc( 16, sizeof(char) );
    if( str == NULL )
        break;

    if( some_func( handle, str ) )
        break;
        
} while(false);

if( handle )
    some_destructor( handle );
if( str )
    free( str );

return;

/* ... */

MBy>Пишу на Си. Например, некая ф-ия не смогла что-то выполнить и вернула ошибку. Продолжение выполнения программы стало безсмысленным. Как в таком случае правильнее всего обработать эту ошибку и выйти из программы? При том следует учесть, что необходимо закрыть n-ое количество файлов и вернуть в кучу выделиную память, то есть сделать не выброс а корректное завершение.

X x;
if(initX(&x))
{
    Y y;
    if(initY(&y))
    {
        ...
        closeY(&y);
    }
    closeX(&x);
}

X x;
if(!initX(&x))
{
    return 0;
}

Y y;
if(!initY(&y))
{
    closeX(&x);
    return 0;
}

...

closeY(&y);
closeX(&x);

MBy>Пишу на Си. Например, некая ф-ия не смогла что-то выполнить и вернула ошибку. Продолжение выполнения программы стало безсмысленным. Как в таком случае правильнее всего обработать эту ошибку и выйти из программы? При том следует учесть, что необходимо закрыть n-ое количество файлов и вернуть в кучу выделиную память, то есть сделать не выброс а корректное завершение.

Processes the specified function at exit.

int atexit( void ( __cdecl *func )( void ) );

MBy>>Пишу на Си. Например, некая ф-ия не смогла что-то выполнить и вернула ошибку. Продолжение выполнения программы стало безсмысленным. Как в таком случае правильнее всего обработать эту ошибку и выйти из программы? При том следует учесть, что необходимо закрыть n-ое количество файлов и вернуть в кучу выделиную память, то есть сделать не выброс а корректное завершение.

КР>Processes the specified function at exit.

КР>int atexit( void ( __cdecl *func )( void ) );
КР>

The limits may constrain quantities that include those described below or others. The bracketed number
following each quantity is recommended as the minimum for that quantity. However, these quantities are
only guidelines and do not determine compliance.
— Nesting levels of compound statements, iteration control structures, and selection control structures
[256].
— Nesting levels of conditional inclusion [256].
— Pointer, array, and function declarators (in any combination) modifying an arithmetic, structure, union,
or incomplete type in a declaration [256].
— Nesting levels of parenthesized expressions within a full expression [256].
— Number of characters in an internal identifier or macro name [1 024].
— Number of characters in an external identifier [1 024].
— External identifiers in one translation unit [65 536].
— Identifiers with block scope declared in one block [1 024].
— Macro identifiers simultaneously defined in one translation unit [65 536].
— Parameters in one function definition [256].
— Arguments in one function call [256].
— Parameters in one macro definition [256].
— Arguments in one macro invocation [256].
— Characters in one logical source line [65 536].
— Characters in a character string literal or wide string literal (after concatenation) [65 536].
— Size of an object [262 144].
— Nesting levels for #include files [256].
— Case labels for a switch statement (excluding those for any nested switch statements) [16 384].
— Data members in a single class, structure, or union [16 384].
— Enumeration constants in a single enumeration [4 096].
— Levels of nested class, structure, or union definitions in a single struct-declaration-list [256].
— Functions registered by atexit()[32].
— Direct and indirect base classes [16 384].
— Direct base classes for a single class [1 024].
— Members declared in a single class [4 096].
— Final overriding virtual functions in a class, accessible or not [16 384].
— Direct and indirect virtual bases of a class [1 024].
— Static members of a class [1 024].
— Friend declarations in a class [4 096].
— Access control declarations in a class [4 096].
— Member initializers in a constructor definition [6 144].
— Scope qualifications of one identifier [256].
— Nested external specifications [1 024].
— Template arguments in a template declaration [1 024].
— Recursively nested template instantiations [17].
— Handlers per try block [256].
— Throw specifications on a single function declaration [256].

SM>Если приложение потом совсем закрывается, то, действительно, виндовс все удалит сам. А если, например, во входных данных для какой-либо функции случилась ошибка, а память уже понавыделять успели, то я бы пользовался goto. Обсуждали как-то с друзьями подобную тему и пришли к этому мнению Много вложенных ифов сильно загромоздят код, а если метки использовать исключительно для корректного освобождения памяти, то почему бы их не использовать?.. Тем более, если приложение на чистом Си.

/* ... */
  SOME_HANDLE handle = NULL;
  char* str = NULL;

  if( some_constructor( &handle ) )
    goto the_end;

  str = calloc( 16, sizeof(char) );
  if( str == NULL )
    goto the_end;

  if( some_func( handle, str ) )
    goto the_end;

the_end:
  if( handle )
    some_destructor( handle );
  if( str )
    free( str );

  return;

/* ... */

#define FUNCTION_NUM (5)

int do_something1( void )
{
  ...

  if( all_ok )
    return 1;
  else {
    fprintf( stderr, "Error bla-bla-bla\n" );
    return 0;
  }
}

int do_something2( void )
{
  ...
}

...

int do_something5( void )

...

typedef int (*action)();

int main( void )
{
  int ret = 0;

  action handler[FUNCTION_NUM] = { do_something1, do_something2, ..., do_something5 };

  open_files();

  for( int i = 0; i < FUNCTION_NUM; ++i ) {
    if( ! handler[i]() ) {
      ret = 1;
      break;
    }
  }

  close_files();
  
  return ret;
}

MBy>/* ... */
MBy>  SOME_HANDLE handle = NULL;
MBy>  char* str = NULL;

MBy>  if( some_constructor( &handle ) )
MBy>    goto the_end;

MBy>  str = calloc( 16, sizeof(char) );
MBy>  if( str == NULL )
MBy>    goto the_end;

MBy>  if( some_func( handle, str ) )
MBy>    goto the_end;

MBy>the_end:
MBy>  if( handle )
MBy>    some_destructor( handle );
MBy>  if( str )
MBy>    free( str );

MBy>  return;

MBy>/* ... */
MBy>

  int err = 0;
  char* str = NULL;
  
  err = some_constructor(&handle);
  if (err)     
    goto out_construct_failed;

  str = calloc( 16, sizeof(char) );
  if (!str) {
    err = ENOMEM;
    goto out_mermory;
  }
  err = some_func(handle, str);
  if (err)
    goto out_some_func_failed;

  err = 0;

out_some_func_failed:
    free(str);
out_memory:
  some_destructor( handle )
out_construct_failed:
  return err;