如何实现 universal switch/case，它也适用于一般的 C++ 类型并且在语法上相似？
How to implement universal switch/case, which can work for general C++ types as well and syntactically similar?
在C/C++中，switch/case只比较整数类型和编译时常量。不可能使用它们来比较 user/library 定义的类型，如 std::string 和 运行 时间值。 Why the switch statement cannot be applied on strings?
我们能否实现看起来像 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; }
};
简而言之，如果为类型 X 定义了 operator==，那么应该能够 运行 这个 switch/case。即：
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: Fun with switch statements.
中演示的一种方式
实施：
#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
}}
备注：
{{ }} 的目的 -- 是为了修复一个场景，其中出现 case_ 下的 2 个或更多语句而没有包含用户提供的 {}。这可能导致某些语句始终执行，无论 case_ 是否为真。-
default_ 位置越高，运行时性能越好。当没有有效案例时，将它放低可能会进行更多比较。
- 将编译重复的案例，但只会执行第一个案例。如果准备好多次检查每个案例，则可以通过生成运行时
abort() 来 fixed/checked 解决此重复案例问题。
- 如果准备好放弃冒号
: 的语法糖，即 case(X) 而不是 case(X):，则不需要 CONCATE 宏。保留冒号通常会给编译器警告未使用的标签 (-Wunused-label)
- 此实用程序可以扩展用于其他比较，例如
<、>=、!= 或任何此类运算符；为此，我们必须向 switch_ 宏添加额外的参数；例如OP 并且必须作为 VAR_ OP X 放在 case_ 宏中
- 为了与 C++03 兼容，在声明
struct UNIQUE(Type) { enum { ... }; }; 后，在 for 循环中使用 make_pair
- 数组和字符串指针可以与以下实用程序进行比较：
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)) {{ }}.
Demo
您无法回避 switch case 必须是 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 != '[=10=]') {
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"));
}
在C/C++中，switch/case只比较整数类型和编译时常量。不可能使用它们来比较 user/library 定义的类型，如 std::string 和 运行 时间值。 Why the switch statement cannot be applied on strings?
我们能否实现看起来像 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; }
};
简而言之，如果为类型 X 定义了 operator==，那么应该能够 运行 这个 switch/case。即：
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: Fun with switch statements.
实施：
#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
}}
备注：
{{ }}的目的 -- 是为了修复一个场景，其中出现case_下的 2 个或更多语句而没有包含用户提供的{}。这可能导致某些语句始终执行，无论case_是否为真。-
default_位置越高，运行时性能越好。当没有有效案例时，将它放低可能会进行更多比较。 - 将编译重复的案例，但只会执行第一个案例。如果准备好多次检查每个案例，则可以通过生成运行时
abort()来 fixed/checked 解决此重复案例问题。 - 如果准备好放弃冒号
:的语法糖，即case(X)而不是case(X):，则不需要CONCATE宏。保留冒号通常会给编译器警告未使用的标签 (-Wunused-label) - 此实用程序可以扩展用于其他比较，例如
<、>=、!=或任何此类运算符；为此，我们必须向switch_宏添加额外的参数；例如OP并且必须作为VAR_ OP X 放在 - 为了与 C++03 兼容，在声明
struct UNIQUE(Type) { enum { ... }; }; 后，在 - 数组和字符串指针可以与以下实用程序进行比较：
case_ 宏中
for 循环中使用 make_pair
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)) {{ }}.
Demo
您无法回避 switch case 必须是 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 != '[=10=]') {
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"));
}