allsparks place

#include <cstring>
 
enum class T
{
    NONE,
    A,
    Bb,
    Ccc,
    Dddd,
    Eeeee,
    Ff,
    DEFAULT
};
 
struct TName {
    const char* name;
    T t;
};
 
TName tnames[] = {
    {"None", T::NONE},
    {"A", T::A},
    {"Bb", T::Bb},
    {"Ccc", T::Ccc},
    {"Dddd", T::Dddd},
    {"Eeeee", T::Eeeee},
    {"Ff", T::Ff},
    {"DEFAULT", T::DEFAULT},
    {nullptr, T::DEFAULT}
};
 
T GetTByName(const char* name)
{
    T r = T::DEFAULT;
    if (name)
    {
        for (int i = 0; tnames[i].name; ++i)
        {
            if (strcmp(name, tnames[i].name) == 0)
            {
                r = tnames[i].t;
                break;
            }
        }
    }
 
    return r;
}

#include <string_view>
#include <array>
#include <algorithm>
 
enum class T
{
    NONE,
    A,
    Bb,
    Ccc,
    Dddd,
    Eeeee,
    Ff,
    DEFAULT
};
 
struct TName2
{
    std::string_view name;
    T t;
 
    bool operator==(std::string_view n) const noexcept
    {
        return name == n;
    }
};
 
std::array<TName2, 8> tnames2 = {{
    {"None", T::NONE},
    {"A", T::A},
    {"Bb", T::Bb},
    {"Ccc", T::Ccc},
    {"Dddd", T::Dddd},
    {"Eeeee", T::Eeeee},
    {"Ff", T::Ff},
    {"DEFAULT", T::DEFAULT},
}};
 
T GetByName2(std::string_view name)
{
    if (name.empty())
    {
        return T::DEFAULT;
    }
 
    auto it = std::find(begin(tnames2), end(tnames2), name);
 
    return it != end(tnames2) ? it->t : T::DEFAULT;
}

static void Bench_Name(benchmark::State& state) {
  const char* f = "Eeeee";
 
  for (auto _ : state) {
    // Make sure the variable is not optimized away by compiler
    benchmark::DoNotOptimize(GetTByName(f));
  }
}
 
 
static void Bench_Name2(benchmark::State& state) {
  std::string_view f = "Eeeee";
 
  for (auto _ : state) {
    // Make sure the variable is not optimized away by compiler
    benchmark::DoNotOptimize(GetByName2(f));
  }
}
 
BENCHMARK(Bench_Name);
BENCHMARK(Bench_Name2);