```cpp
#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;
}
```

```cpp
#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;
}
```


```cpp
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);
```