Как реализовать универсальный переключатель / регистр, который может работать для общих типов C ++, а также синтаксически схожи?

Question

В C / C ++ switch/case сравнивает только целочисленный тип с константами времени компиляции. Их невозможно использовать для сравнения пользовательских / библиотечных типов, таких как std::string, со значениями времени выполнения. Почему оператор switch нельзя применять к строкам?

Можем ли мы реализовать look-a-like switch/case, который дает похожий синтаксический сахар и служит для избежанияобычные if/else сравнения.

---

struct X { 
  std::string s;
  bool operator== (const X& other) const { return s == other.s; }
  bool operator== (const std::string& other) const { return s == other; }
};

В двух словах, можно иметь возможность запустить этот switch/case, если для типа X определен operator==. т.е.:

X x1{"Hello"}, x2{"World"};
switch(x1)
{
  // compare literal or any different type for which `==` is defined
  case "Hello": std::cout << "Compared 'Hello'\n"; break;     
  // cases/default appear in between and also can fall-through without break
  default:      std::cout << "Compared 'Default'\n"; 
  // compare compiletime or runtime created objects
  case x2:    { std::cout << "Compared 'World'\n"; break; }
}

Я знаю, что выше невозможно, как это есть. Но все похожее выглядит хорошо.
Этот вопрос вдохновлен способом, продемонстрированным в этом blogspot: Удовольствие от выражений switch .

Answer 1

Имплентация:

#define CONCATE_(X,Y) X##Y
#define CONCATE(X,Y) CONCATE_(X,Y)
#define UNIQUE(NAME) CONCATE(NAME, __LINE__)

#define MSVC_BUG(MACRO, ARGS) MACRO ARGS
#define NUM_ARGS_2(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, TOTAL, ...) TOTAL
#define NUM_ARGS_1(...) MSVC_BUG(NUM_ARGS_2, (__VA_ARGS__))
#define NUM_ARGS(...) NUM_ARGS_1(__VA_ARGS__, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
#define VA_MACRO(MACRO, ...) MSVC_BUG(CONCATE, (MACRO, NUM_ARGS(__VA_ARGS__)))(__VA_ARGS__)

#define switch_(X) for(struct { static_assert(not std::is_pointer<decltype(X)>::value, "No Pointers!"); \
              const decltype(X)& VALUE_; enum { CASES, DEFAULT, COMPARED } IS_ = CASES; } VAR_{X}; \
                       VAR_.IS_ != VAR_.COMPARED; \
                       VAR_.IS_ == VAR_.DEFAULT or (VAR_.IS_ = VAR_.COMPARED))

#define default_ {}} if(VAR_.IS_ == VAR_.COMPARED or VAR_.IS_ == VAR_.DEFAULT or \
                        ((VAR_.IS_ = VAR_.DEFAULT) and false)) \
                     { VAR_.IS_ = VAR_.COMPARED; CONCATE(default,__LINE__)

#define case_(...) VA_MACRO(case_, __VA_ARGS__)
#define case_1(X)    {}} if(VAR_.IS_ == VAR_.COMPARED or VAR_.VALUE_ == X) \
                         { VAR_.IS_ = VAR_.COMPARED; CONCATE(case,__LINE__)
#define case_2(X,OP) {}} if(VAR_.IS_ == VAR_.COMPARED or VAR_.VALUE_ OP X) \
                         { VAR_.IS_ = VAR_.COMPARED; CONCATE(case,__LINE__)

Использование:

X x1{"Hello"}, x2{"World"};
switch_(x1)
{{ // <--- MUST
  case_("Hello"):   std::cout << "Compared 'Hello'\n"; break;
  default_:         std::cout << "Compared 'Default'\n";
  case_(x2):      { std::cout << "Compared 'World'\n"; break; }
  case_("World"): { std::cout << "Duplicate 'World' again!\n"; break; } // duplicate
}}

Примечания:

• Цель {{ }} - исправить сценарий, в котором2 или более операторов под case_ появляются без указания пользователя {}. Это могло бы привести к тому, что некоторые операторы всегда выполняются независимо от того, что case_ истинно.
• Чем выше помещено default_, тем выше производительность во время выполнения. Если вы укажете это значение, вы сможете сделать больше сравнений, если ни один из вариантов не является действительным.
• Дублированные случаи будут скомпилированы, но будет выполнен только 1-й случай. Эта повторяющаяся проблема с регистром может быть исправлена ​​/ проверена путем создания среды выполнения abort(), если каждый готов пройти каждый случай более одного раза.
• Если один из них готов, перед синтаксическим сахаром двоеточия :, т.е. case(X) вместо case(X):, тогда макрос CONCATE не нужен. Сохранение двоеточий обычно выдает компилятору предупреждение о неиспользуемых метках (-Wunused-label)
• Эта утилита может быть расширена для других сравнений, таких как <, >=, != или любого такого оператора;Для этого мы должны добавить дополнительный аргумент в switch_ macro;например, OP, и его нужно поместить в макрос case_ как VAR_ OP X
• Для совместимости с C ++ 03 используйте make_pair внутри цикла for после объявления struct UNIQUE(Type) { enum { ... }; };
• Массивы и указатель на строку можно сравнить с приведенной ниже утилитой:

---

template<typename T>
struct Compare
{
  const T& this_;
  template<typename T_, size_t SIZE>
  bool
  operator== (const T_ (&other)[SIZE]) const
  {
    static_assert(std::is_same<decltype(this_), decltype(other)>::value, "Array size different!");
    return ::memcmp(this_, other, SIZE);
  }
};
template<>
struct Compare<const char*>
{
  const char* const this_;
  bool operator== (const char other[]) const { return (0 == ::strcmp(this_, other)); }
};
#define COMPARE(X) Compare<decltype(X)>{X}

Использование : switch_(COMPARE(var)) {{ }}.

Демо

Answer 2

Нельзя обойти тот факт, что регистры переключателей должны быть constexpr интегралами, поэтому case x2: не будет работать. Это должно быть constexpr.

Одним из способов эмуляции включения строк constexpr может быть использование хэш-функции constexpr.

Пример:

#include <iostream>

// boilerplate - any constexpr hashing function would do
inline constexpr uint64_t ror64(uint64_t v, int r) {
    return (v >> r) | (v << (64 - r));
}

inline constexpr uint64_t rrmxmx2(uint64_t v) {
    v ^= ror64(v, 27) ^ ror64(v, 52);
    v *= 0x9fb21c651e98df25UL;
    v ^= ror64(v, 27) ^ ror64(v, 52);
    v *= 0xc20bf31a8f5694c9UL;
    return v ^ (v >> 28);
}

class Checksum {
    static constexpr uint64_t INC1 = 0x3C6EF372FE94F82BUL; // sqrt(5)
    static constexpr uint64_t INC2 = 0xA54FF53A5F1D36F1UL; // sqrt(7)

    uint64_t words = 0;
    uint64_t s[4] = {INC1, INC2, INC1, INC2};

public:
    constexpr Checksum(const uint64_t S[4], uint64_t Words) :
        words(Words), s{S[0], S[1], S[2], S[3]} {}
    constexpr Checksum() {}
    constexpr Checksum(const char* str) {
        while(*str != '\0') {
            update(*str);
            ++str;
        }
    }

    bool operator==(const Checksum& rhs) const {
        return words == rhs.words && s[0] == rhs.s[0] && s[1] == rhs.s[1] &&
               s[2] == rhs.s[2] && s[3] == rhs.s[3];
    }
    inline bool operator!=(const Checksum& rhs) const { return !(*this == rhs); }
    constexpr void update(uint64_t w) {
        uint64_t tmp = s[0] + rrmxmx2(s[1] + (s[2] ^ s[3]));
        s[0] = s[1];
        s[1] = s[2];
        s[2] = s[3] + ++words;
        s[3] = tmp + w;
    }
    constexpr size_t finalize() {
        for(int i = 0; i < 64; ++i) {
            uint64_t tmp = s[0] + rrmxmx2(s[1] + (s[2] ^ s[3]));
            s[0] = s[1];
            s[1] = s[2];
            s[2] = s[3] + i;
            s[3] = tmp;
        }
        return s[0];
    }
};

constexpr size_t checksum(const char* str) {
    return Checksum(str).finalize();
}
// end of boilerplate

int main() {
    std::string word;
    size_t hash;

    do {
        std::cout << "enter a word: ";
        std::cin >> word;

        hash = checksum(word.c_str());

        switch(hash) {
        case checksum("foo"):
            std::cout << "excellent\n";
            break;
        case checksum("bar"):
            std::cout << "very good\n";
            break;
        case checksum("baz"):
            std::cout << "well done\n";
            break;
        case checksum("secret"):
            std::cout << "extremely gifted\n";
            break;
        default:
            std::cout << "invalid word\n";
        }
    } while(hash != checksum("quit"));
}