C ++ enum <-> string? Fácil

Aqui está um dos exemplos mais populares. Podemos dizer clássico. Os dados são serializados em, digamos, json. A estrutura possui um campo enum que você deseja salvar na forma de texto (não como um número). Tudo. Pare. Não existe uma maneira fácil de resolver esse problema elementar em C ++. (c)

... Mas eu realmente quero.

Durante o ano passado, vi como, em quase todos os projetos, um desenvolvedor propôs sua própria visão desse problema. E em todos os lugares havia duplicação de código, em todos os lugares havia algum tipo de muletas e "sutilezas". O que realmente está lá, eu mesmo tenho que voltar a esse tópico de vez em quando. O suficiente. Decidi encerrar o assunto de uma vez por todas, pelo menos para mim.

O código está longe de ser perfeito (espero que o anônimo o corrija), mas faz seu trabalho. Talvez alguém seja útil:

Implementação
// enum_string.h
#pragma once

#define DECLARE_ENUM(T, values...)                                    \
  enum class T { values, MAX };                                       \
  char enum_##T##_base[sizeof(#values)] = #values;                    \
  const char* T##_tokens[static_cast<__underlying_type(T)>(T::MAX)];  \
  const char* const* T##_tmp_ptr = tokenize_enum_string(              \
      const_cast<char*>(enum_##T##_base), sizeof(#values), T##_tokens,\
      static_cast<__underlying_type(T)>(T::MAX));

#define enum_to_string(T, value) \
  (T##_tokens[static_cast<__underlying_type(T)>(value)])

static const char* const* tokenize_enum_string(char* base,
                                               int length,
                                               const char* tokens[],
                                               int size) {
  int count = 0;
  tokens[count++] = base;
  for (int i = 1; i < length; ++i) {
    if (base[i] == ',') {
      base[i] = '\0';

      if (count == size) {
        return tokens;
      }

      do {
        if (++i == length) {
          return tokens;
        }

      } while (' ' == base[i]);

      tokens[count++] = base + i;
    }
  }

  return tokens;
}

static bool string_equals(const char* a, const char* b) {
  int i = 0;
  for (; a[i] && b[i]; ++i) {
    if (a[i] != b[i]) {
      return false;
    }
  }

  return (a[i] == b[i]);
}

static int string_to_enum_int(const char* const tokens[], int max,
                              const char* value) {
  for (int i = 0; i < max; ++i) {
    if (string_equals(tokens[i], value)) {
      return i;
    }
  }

  return max;
}
#define string_to_enum(T, value)     \
  static_cast<T>(string_to_enum_int( \
      T##_tokens, static_cast<__underlying_type(T)>(T::MAX), value))

Você pode facilmente substituir o trabalho com strings por suas bibliotecas favoritas, a maior parte do código aqui é apenas análise de string (eu realmente queria fazer sem STL).

A ideia principal era garantir o conjunto de bijetividade de enum e seu equivalente string, e fazer a implementação do universal no número de elementos ( adeus, vyrviglazny hardkodny macro _NARG ). Bem, para que o uso seja o mais fofo possível.

exemplo de uso
// main.cpp
#include <iostream>

#include "enum_string.h"

DECLARE_ENUM(LogLevel,  // enum class LogLevel
             Alert,     // LogLevel::Alert
             Critical,  // LogLevel::Critical
             Error,     // LogLevel::Error
             Warning,   // LogLevel::Warning
             Notice,    // LogLevel::Notice
             Info,      // LogLevel::Info
             Debug      // LogLevel::Debug
             );

int main() {
  // serialize
  LogLevel a = LogLevel::Critical;
  std::cout << enum_to_string(LogLevel, a) << std::endl;

  // deserialize
  switch (string_to_enum(LogLevel, "Notice")) {
    case LogLevel::Alert: {
      std::cout << "ALERT" << std::endl;
    } break;
    case LogLevel::Critical: {
      std::cout << "CRITICAL" << std::endl;
    } break;
    case LogLevel::Error: {
      std::cout << "ERROR" << std::endl;
    } break;
    case LogLevel::Warning: {
      std::cout << "WARN" << std::endl;
    } break;
    case LogLevel::Notice: {
      std::cout << "NOTICE" << std::endl;
    } break;
    case LogLevel::Info: {
      std::cout << "INFO" << std::endl;
    } break;
    case LogLevel::Debug: {
      std::cout << "DEBUG" << std::endl;
    } break;
    case LogLevel::MAX: {
      std::cout << "Incorrect value" << std::endl;
    } break;
  }

  return 0;
}

Quanto a mim, não precisa de explicação adicional.

Além disso, carregado para o github .

Os críticos são gentilmente convidados a avaliar.




All Articles