我有一堆测试向量，以十六进制字符串形式表示：
MSG: 6BC1BEE22E409F96E93D7E117393172A
MAC: 070A16B46B4D4144F79BDD9DD04A287C
MSG: 6BC1BEE22E409F96E93D7E117393172AAE2D8A57
MAC: 7D85449EA6EA19C823A7BF78837DFADE
等我需要以某种方式将它们放入C ++程序，而无需进行过多的编辑。有多种选择：
0x6B,0xC1,0xBE,...形式但是我最终使用的是：
因为很有趣。我定义了一个辅助类HexByteArray和一个用户定义的文字运算符HexByteArray operator "" _$ (const char* s)，该运算符解析格式为"0xXX...XX"的字符串，其中XX...XX是偶数个十六进制数字。 HexByteArray包括const uint8_t*和std::vector<uint8_t>的转换运算符。所以现在我可以写例如
struct {
std::vector<uint8_t> MSG ;
uint8_t* MAC ;
} Test1 = {
0x6BC1BEE22E409F96E93D7E117393172A_$,
0x070A16B46B4D4144F79BDD9DD04A287C_$
} ;
哪个效果很好。但是现在这是我的问题：我也可以对数组执行此操作吗？例如：
uint8_t MAC[16] = 0x070A16B46B4D4144F79BDD9DD04A287C_$ ;
甚至
uint8_t MAC[] = 0x070A16B46B4D4144F79BDD9DD04A287C_$ ;
我看不到如何进行这项工作。要初始化数组，我似乎需要一个std::initializer_list。但据我所知，只有编译器才能实例化此类内容。有什么想法吗？
这是我的代码：
HexByteArray.h
#include <cstdint>
#include <vector>
class HexByteArray
{
public:
HexByteArray (const char* s) ;
~HexByteArray() { delete[] a ; }
operator const uint8_t*() && { const uint8_t* t = a ; a = 0 ; return t ; }
operator std::vector<uint8_t>() &&
{
std::vector<uint8_t> v ( a, a + len ) ;
a = 0 ;
return v ;
}
class ErrorInvalidPrefix { } ;
class ErrorHexDigit { } ;
class ErrorOddLength { } ;
private:
const uint8_t* a = 0 ;
size_t len ;
} ;
inline HexByteArray operator "" _$ (const char* s)
{
return HexByteArray (s) ;
}
HexByteArray.cpp
#include "HexByteArray.h"
#include <cctype>
#include <cstring>
HexByteArray::HexByteArray (const char* s)
{
if (s[0] != '0' || toupper (s[1]) != 'X') throw ErrorInvalidPrefix() ;
s += 2 ;
// Special case: 0x0_$ is an empty array (because 0x_$ is invalid C++ syntax)
if (!strcmp (s, "0"))
{
a = nullptr ; len = 0 ;
}
else
{
for (len = 0 ; s[len] ; len++) if (!isxdigit (s[len])) throw ErrorHexDigit() ;
if (len & 1) throw ErrorOddLength() ;
len /= 2 ;
uint8_t* t = new uint8_t[len] ;
for (size_t i = 0 ; i < len ; i++, s += 2)
sscanf (s, "%2hhx", &t[i]) ;
a = t ;
}
}
答案 0 :(得分：5)
使用带有签名的numeric literal operator template
template <char...>
result_type operator "" _x();
此外，由于数据是在编译时已知的，因此我们最好将所有内容constexpr制作成。请注意，我们使用std::array而不是C样式的数组：
#include <cstdint>
#include <array>
#include <vector>
// Constexpr hex parsing algorithm follows:
struct InvalidHexDigit {};
struct InvalidPrefix {};
struct OddLength {};
constexpr std::uint8_t hex_value(char c)
{
if ('0' <= c && c <= '9') return c - '0';
// This assumes ASCII:
if ('A' <= c && c <= 'F') return c - 'A' + 10;
if ('a' <= c && c <= 'f') return c - 'a' + 10;
// In constexpr-land, this is a compile-time error if execution reaches it:
// The weird `if (c == c)` is to work around gcc 8.2 erroring out here even though
// execution doesn't reach it.
if (c == c) throw InvalidHexDigit{};
}
constexpr std::uint8_t parse_single(char a, char b)
{
return (hex_value(a) << 4) | hex_value(b);
}
template <typename Iter, typename Out>
constexpr auto parse_hex(Iter begin, Iter end, Out out)
{
if (end - begin <= 2) throw InvalidPrefix{};
if (begin[0] != '0' || begin[1] != 'x') throw InvalidPrefix{};
if ((end - begin) % 2 != 0) throw OddLength{};
begin += 2;
while (begin != end)
{
*out = parse_single(*begin, *(begin + 1));
begin += 2;
++out;
}
return out;
}
// Make this a template to defer evaluation until later
template <char... cs>
struct HexByteArray {
static constexpr auto to_array()
{
constexpr std::array<char, sizeof...(cs)> data{cs...};
std::array<std::uint8_t, (sizeof...(cs) / 2 - 1)> result{};
parse_hex(data.begin(), data.end(), result.begin());
return result;
}
constexpr operator std::array<std::uint8_t, (sizeof...(cs) / 2)>() const
{
return to_array();
}
operator std::vector<std::uint8_t>() const
{
constexpr auto tmp = to_array();
return std::vector<std::uint8_t>{tmp.begin(), tmp.end()};
}
};
template <char... cs>
constexpr auto operator"" _$()
{
static_assert(sizeof...(cs) % 2 == 0, "Must be an even number of chars");
return HexByteArray<cs...>{};
}
用法示例：
auto data_array = 0x6BC1BEE22E409F96E93D7E117393172A_$ .to_array();
std::vector<std::uint8_t> data_vector = 0x6BC1BEE22E409F96E93D7E117393172A_$;
请注意，identifier中的$实际上是gcc扩展，因此它是非标准的C ++。考虑使用_$以外的UDL。
答案 1 :(得分：5)
这会做到
namespace detail{
template <std::size_t C> constexpr std::integral_constant<std::size_t, C> int_c{ };
template <char c>
class hex_decimal_t
{
constexpr static std::uint8_t get_value() {
constexpr std::uint8_t k = c - '0';
if constexpr (k >= 0 && k <= 9) { return k; }
else if constexpr (k >= 17 && k <= 22) { return k - 7; }
else if constexpr (k >= 49 && k <= 54) { return k - 39; }
else { return std::uint8_t(-1); }
}
public:
static constexpr std::uint8_t value = get_value();
constexpr operator auto() const{
return value;
}
};
template <char C> constexpr hex_decimal_t<C> hex_decimal{ };
template <bool B> using bool_type = std::integral_constant<bool, B>;
template <char... cs> struct is_valid_hex : std::false_type { };
template <char... cs> struct is_valid_hex<'0', 'x', cs...> : bool_type<((hex_decimal<cs> != std::uint8_t(-1)) && ...)>{};
template <char... cs> struct is_valid_hex<'0', 'X', cs...> : bool_type<((hex_decimal<cs> != std::uint8_t(-1)) && ...)>{};
template <std::size_t... Is>
constexpr auto expand_over(std::index_sequence<0, Is...>)
{
return [](auto&& f) -> decltype(auto) {
return decltype(f)(f)(int_c<Is>...);
};
}
template <class T,class... F>
constexpr auto select(T, F&&... f) {
return std::get<T{}>(std::forward_as_tuple(std::forward<F>(f)...));
}
}
template <char... ds>
constexpr auto operator "" _H()
{
static_assert(detail::is_valid_hex<ds...>{} || sizeof...(ds) < 3, "Not a valid hex number");
static_assert(!(sizeof...(ds) > 3 && sizeof...(ds) & 0x1), "Hex string must have even length");
constexpr int Sz = sizeof...(ds);
constexpr auto expand = detail::select(detail::int_c<(Sz > 3)>,
[] { return detail::expand_over(std::make_index_sequence<2>{}); },
[] { return detail::expand_over(std::make_index_sequence<Sz/2>{}); }
)();
if constexpr (Sz <= 3) {
return expand([](auto... Is) {
constexpr std::array digs{ds...};
return std::array { (detail::hex_decimal<digs[2 * Is]>)... };
});
} else {
return expand([](auto... Is) {
constexpr std::array digs{ds...};
return std::array { ((detail::hex_decimal<digs[2 * Is]> << 4) | detail::hex_decimal<digs[2 * Is + 1]>)... };
});
}
}
constexpr auto arr = 0x070A16B46B4D4144F79BDD9DD04A287C_H;
static_assert(arr.size() == 16);
static_assert(std::get<0>(arr) == 0x7);
static_assert(std::get<arr.size() - 1>(arr) == 0x7C);
答案 2 :(得分：0)
基于@Justin 回答的完全编译时 static_assert 版本。
udl 运算符直接返回 std::array。您可以使用 std::tuple<std::integral_constant<char, c>...> 实现类简单地定义其他返回 vector 甚至 HexArrayBuilder 的 udl 运算符。
这是c++11版本。检查字符有效性的 static_assert 可以像注释行一样用 c++17 方式编写。
#include <array>
#include <type_traits>
#include <tuple>
struct HexArrayHelper {
static constexpr bool valid(char c) { return ('0' <= c && c <= '9') || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f'); }
static constexpr char hex_value(char c) {
return ('0' <= c && c <= '9') ? c - '0'
: ('A' <= c && c <= 'F') ? c - 'A' + 10
: c - 'a' + 10;
}
static constexpr char build(char a, char b) {
return (hex_value(a) << 4) + hex_value(b);
};
};
template <char... cs>
struct HexArray {
static constexpr std::array<char, sizeof...(cs)> to_array() { return {cs...}; }
static constexpr std::tuple<std::integral_constant<char, cs>...> to_tuple() { return {}; }
};
template <typename T, char... cs>
struct HexArrayBuilder : T {};
template <char... built, char a, char b, char... cs>
struct HexArrayBuilder<HexArray<built...>, a, b, cs...> : HexArrayBuilder<HexArray<built..., HexArrayHelper::build(a, b)>, cs...> {
static_assert(HexArrayHelper::valid(a) && HexArrayHelper::valid(b), "Invalid hex character");
};
template <char zero, char x, char... cs>
struct HexByteArray : HexArrayBuilder<HexArray<>, cs...> {
static_assert(zero == '0' && (x == 'x' || x == 'X'), "Invalid prefix");
// static_assert(std::conjunction<std::bool_constant<HexArrayHelper::valid(cs)>...>::value, "Invalid hex character");
};
template <char... cs>
constexpr auto operator"" _hexarr() -> std::array<char, sizeof...(cs) / 2 - 1> {
static_assert(sizeof...(cs) % 2 == 0 && sizeof...(cs) >= 2, "Must be an even number of chars");
return HexByteArray<cs...>::to_array();
}
auto x = 0X1102030405060708abcdef_hexarr;