Есть ли лучший способ преобразовать коды ошибок в строку?

Таблица поиска строк может быть одним из очевидных способов сделать это.

typedef enum
{
  ERR_NONE,
  ERR_SERVERS_ON_FIRE,
  ERR_LIVE_BEAVERS,

  ERR_N // total number of supported errors
} err_t;

static const char* err_str[] = 
{
  [ERR_NONE]             = "No error",
  [ERR_SERVERS_ON_FIRE]  = "The servers are on fire",
  [ERR_LIVE_BEAVERS]     = "Live beavers in the server room",
};

static_assert(sizeof(err_str)/sizeof(*err_str) == ERR_N, 
              "err_t and err_str are not consistent with each other");

...

void InternalLogError(..., err_t code)
{
  puts(err_str[code]);
}

Или, если необходимо избегать хранения значений в отдельных местах, версия X-макроса:

#define ERR_LIST(X)                                        \
/*  code                 str                           */  \
  X(ERR_NONE,            "No error")                       \
  X(ERR_SERVERS_ON_FIRE, "The servers are on fire")        \
  X(ERR_LIVE_BEAVERS,    "Live beavers in the server room")

typedef enum
{
  #define ERR_T_ENUM(code, str) code,
  ERR_LIST(ERR_T_ENUM)
  
  ERR_N // total number of supported errors
} err_t;

static const char* err_str[] = 
{
  #define ERR_STR_LUT(code, str) [code] = str,
  ERR_LIST(ERR_STR_LUT)
};

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

#include <errorgen.h>
int some_library_function() {
     return ERROR_GEN(ERROR_SOME_ERROR, "This is error description")
}

Перед компиляцией сценарий CMake или Python просматривал все файлы. Для каждого файла, содержащего ERROR_GEN, было создано два файла — errorgen_list.h и errorgen_str.h. errorgen_list.h содержал все перечисления, собранные из ERROR_GEN функций. errorgen_str.h содержал "This is error description", таблицу для преобразования кода ошибки в строку. Скрипт выглядит примерно так:

def get_all_errors_from_sources():
    rereplace = re.compile(
        r'ERROR_GEN\s*\(\s*(.*)\s*,\s*(".*")\s*\)\s*;',
        flags=re.MULTILINE,
    )
    dir = os.path.dirname(__file__)
    errors: List[Err] = []
    for path in Path(dir).glob("**/*.c"):
        for line in open(path).read():
            res = rereplace.findall(line)
            if res:
                errors += [Err(*res)]
    return errors

def prepare_sources(errors):
    enumout = "/* @file */\n"
    for k, v in errors:
        enumout += "\t" + k + ",  /// " + v + "\n"
    msgout = "/* @file */\n"
    for k, v in errors:
        msgout += "\t" + v + ",  // " + k + "\n"
    return (enumout, msgout)

errors = get_all_errors_from_sources()
enumout, msgout = prepare_sources(errors)
with Path("errorgen_list.h", "w") as f:
    f.write(enumout)
with Path("errorgen_str.h", "w") as f:
    f.write(msgout )

Затем со следующим errorgen.h:

 enum errorgen_errors_e {
    ERRORGEN_OK = 0,
    ERRORGEN_START = -1000,
 #include "errorgen_list.h"
    ERRORGEN_STOP,
 };

 #define ERROR_GEN(a, b)  a

 const char *error_to_str(int);

И следующее errorgen.c:

 static const char *const errorsgen_str[] = {
 #include "errorgen_str.h"
 };

 const char *error_to_str(int err) {
     // error handling...
    return errorsgen_str[err - ERRORGEN_START - 1];
 }
  

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

Чтобы увидеть альтернативу, вот вариант очень хорошего ответа @Lundin.
Это инвертирует использование макросов для достижения аналогичного результата.

// errors.tbl - NB: no header guards!

#ifdef ERR_AS_STR
const char *errStrs[];
static const char *errToStr( int code ) { return errStrs[code]; }
static const char *errStrs[] = {
#   define X(e,s) s
#else
enum {
#   define X(e,s) e
#endif

    X( ERR_NONE,            "No error" ),
    X( ERR_SERVERS_ON_FIRE, "The servers are on fire" ),
    X( ERR_LIVE_BEAVERS,    "Live beavers in the server room" ),
    X( ERR_N, NULL )
#   undef X
};

и

// main.c

#include <stdio.h>

#include "errors.tbl" // once as enums
#define ERR_AS_STR
#include "errors.tbl" // and now as array of strings (and getter)
#undef ERR_AS_STR

int main( void ) {
    for( int i = ERR_NONE; i < ERR_N; i++ ) puts( errToStr( i ) );
    return 0;
}

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