switch case 字符串表达式支持

根据业务需求，在编码过程中，经常会遇到switch case表达式是字符串的场景，现支持如下。

【1】实现文件

支持实现的文件

 1 #pragma once
 2 
 3 #include <cstddef>
 4 #include <cstdint>
 5 #include <type_traits>
 6 
 7 namespace prefab
 8 {
 9     template<typename T>
10     struct fnv1a_constant;
11 
12     template<>
13     struct fnv1a_constant<std::uint32_t>
14     {
15         static constexpr std::uint32_t prime = 16777619;
16         static constexpr std::uint32_t offset = 2166136261;
17     };
18 
19     template<>
20     struct fnv1a_constant<std::uint64_t>
21     {
22         static constexpr std::uint64_t prime = 1099511628211ull;
23         static constexpr std::uint64_t offset = 14695981039346656037ull;
24     };
25 
26     template<typename T, typename TChar>
27     inline constexpr T fnv1a_hash(const TChar* const str, const T result = fnv1a_constant<T>::offset)
28     {
29         return (str[0] == '') ? result :
30             fnv1a_hash(str + 1, 
31             static_cast<T>(
32                 (result ^ *str)* 
33                 static_cast<unsigned long long>(fnv1a_constant<T>::prime)));
34     }
35 
36     template<typename T, typename TChar>
37     inline constexpr T fnv1a_hash(std::size_t n, const TChar* const str, const T result = fnv1a_constant<T>::offset)
38     {
39         return n > 0 ? fnv1a_hash(n - 1, str + 1, (result ^ *str) * fnv1a_constant<T>::prime) : result;
40     }
41 
42     template<typename T, typename TChar, std::size_t N>
43     inline constexpr T fnv1a_hash(const TChar(&str)[N])
44     {
45         return fnv1a_hash<T>(N - 1, &str[0]);
46     }
47 
48     template<typename TChar,std::size_t N>
49     inline constexpr auto hash(const TChar(&str)[N])
50     {
51         return fnv1a_hash<std::size_t, TChar, N>(str);
52     }
53 
54     template<typename T>
55     inline constexpr auto hash(T const& str)
56     {
57         return fnv1a_hash(str.size(), str.data(), fnv1a_constant<std::size_t>::offset);
58     }
59 }

【2】应用示例

 1 #include "hash.hpp"
 2 
 3 #include <string>
 4 #include <iostream>
 5 
 6 void print(int index, std::string value)
 7 {
 8     std::cout << index << " :: " << value << std::endl;
 9 }
10 
11 int main()
12 {
13     int index = 0;
14     for (std::string type : { "abc", "kaizen", "2805", "x64", "XIAN" })
15     {
16         switch (prefab::hash(type))
17         {
18         case prefab::hash("abc"):
19             print(index++, type);
20             break;
21         case prefab::hash("kaizen"):
22             print(index++, type);
23             break;
24         case prefab::hash("2805"):
25             print(index++, type);
26             break;
27         case prefab::hash("x64"):
28             print(index++, type);
29             break;
30         case prefab::hash("beijing"):
31             print(index++, type);
32             break;
33         default:
34             break;
35         }
36     }
37 
38     return 0;
39 }
40 
41 // result:
42 /*
43 0 :: abc
44 1 :: kaizen
45 2 :: 2805
46 3 :: x64
47 */

good good study, day day up.

顺序选择循环总结