【问题标题】:Using a C++ user-defined literal to initialise an array使用 C++ 用户定义的文字来初始化数组
【发布时间】:2019-05-23 15:19:48
【问题描述】:

我有一堆测试向量,以十六进制字符串的形式呈现:

MSG: 6BC1BEE22E409F96E93D7E117393172A
MAC: 070A16B46B4D4144F79BDD9DD04A287C
MSG: 6BC1BEE22E409F96E93D7E117393172AAE2D8A57
MAC: 7D85449EA6EA19C823A7BF78837DFADE

等等。我需要以某种方式将它们放入 C++ 程序中,而不需要太多的编辑。有多种选择:

  • 手动将测试向量编辑成0x6B,0xC1,0xBE,...的形式
  • 手动将测试向量编辑为“6BC1BEE22E409F96E93D7E117393172A”形式,并编写一个函数在运行时将其转换为字节数组。
  • 编写程序来解析测试向量并输出 C++ 代码。

但我最终使用的是:

  • 用户定义的文字,

因为好玩。我定义了一个辅助类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 ;
    }
  }

【问题讨论】:

  • 为什么不std::array?您甚至可以让您的文字直接返回所需的数组,如auto MAC = 0x070A16B46B4D4144F79BDD9DD04A287C_$ ;
  • @YSC 这个问题和正则表达式完全没有关系。即使是这样,为什么这意味着投反对票?
  • @YSC 没有人强迫你这样做????季节的问候!
  • 这正是问题所在????
  • @YSC 不要因为你碰巧不喜欢 OPs 方法就投反对票。发表评论或发表建议不同方法的答案并解释原因。投票按钮不是关于你对这个问题的看法,而是关于问题是否被很好地提出、清晰并显示了研究工作。

标签: c++ initializer-list user-defined-literals


【解决方案1】:

使用带有签名的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...>{};
}

Demo

示例用法:

auto data_array = 0x6BC1BEE22E409F96E93D7E117393172A_$ .to_array();
std::vector<std::uint8_t> data_vector = 0x6BC1BEE22E409F96E93D7E117393172A_$;

附带说明,identifier 中的$ 实际上是 gcc 扩展,因此它是非标准 C++。考虑使用 _$ 以外的 UDL。

【讨论】:

  • 这正是我想要的。谢谢!我现在坚持使用 gcc 5.3 版,它无法处理所有这些 constexpr 函数。但我确信我可以让它工作。关于$:是的,你是对的,虽然我觉得奇怪的是GLAGOLITIC CAPITAL LETTER AZU 允许在标识符中,但$ 不允许。但我会保留它,因为它反映了我的 Basic 编译器的语法 Public S$ = &amp;H12AB34CD56$
  • @TonyK 使用 gcc 5.3,我相信如果您简单地删除所有 constexprs,它应该可以工作。可能想要做一些思考以确保没有太多副本
【解决方案2】:

这样就可以了

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

Live demo

【讨论】:

  • 谢谢!不幸的是我只能接受一个答案,否则我也会接受。
【解决方案3】:

基于@Justin 的回答的完全编译时 static_assert 版本。

udl 运算符直接返回std::array。您可以使用HexArrayBuilder 实现类简单地定义返回std::tuple&lt;std::integral_constant&lt;char, c&gt;...&gt; 甚至vector 的其他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;

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 2020-11-02
    • 2017-11-18
    • 1970-01-01
    • 1970-01-01
    • 2012-11-29
    • 1970-01-01
    • 1970-01-01
    • 2015-07-03
    相关资源
    最近更新 更多