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.