long double operator""_deg_to_rad(long double deg)
{
    long double radians = deg * std::numbers::pi_v<long double> / 180;
    return radians;
}
// ... 
// value is now 90 degree in radiants -> 1.5707...
double value = 90.0_deg_to_rad;

Combining Collections with Zip in C++23 for Efficient Data Processing

#include <format>
#include <iostream>
#include <ranges>
#include <vector>

int main() {
    std::vector a { 10, 20, 30, 40, 50 };
    std::vector<std::string> b { "one", "two", "three", "four" };
        
    for (const auto& [num, name] : std::views::zip(a, b))
        std::cout << std::format("{} -> {}\n", num, name);
}

zip介绍的文章，c++23可用

Iterating and inverting a const views::filter

constexpr auto isPrint = [](auto c) { return std::isprint(c); };
constexpr auto isXDigit = [](auto c) { return std::isxdigit(c); };
constexpr auto hexdigital = std::views::filter(isXDigit);
constexpr auto printable = std::views::filter(isPrint);

constexpr auto digits = std::views::iota('\0')
                      | std::views::take(256)
                      | hexdigital;

for (char c : digits) ~~~             // Error
for (char c : digits | printable) ~~~ // Error

报错真么办，本质上，digits这里的遍历不是const，只能decay，c++23用auto解决

for (char c : auto(digits)) ~~~             // OK
for (char c : auto(digits) | printable) ~~~ // OK

另外，反转，直接贴代码

constexpr auto rest = [](auto fv) {
    return fv.base() | std::views::filter(std::not_fn(fv.pred()));
};

for (char c : rest(digits)) ~~~             // OK
for (char c : rest(digits) | printable) ~~~ // OK

Runtime asserts are not free

大概慢几倍。当然发现bug最重要

Trimming spaces from strings faster with SVE on an Amazon Graviton 3 processor

写了个针对arm sve指令的trim优化

原版

size_t trimspaces(const char *s, size_t len, char *out) {
  char * init_out{out};
  for(size_t i = 0; i < len; i++) {
    *out = s[i];
    out += (s[i] != ' ');
  }
  return out - init_out;
}

改进

size_t sve_trimspaces(const char *s, size_t len, char *out) {
  uint8_t *out8 = reinterpret_cast<uint8_t *>(out);
  size_t i = 0;
  for (; i + svcntw() <= len; i += svcntw()) {
   svuint32_t input = svld1sb_u32(svptrue_b32(), (const int8_t *)s + i);
   svbool_t matches = svcmpne_n_u32(svptrue_b32(), input, 32);
   svuint32_t compressed = svcompact_u32(matches, input);
   svst1b_u32(svptrue_b32(), out8, compressed);
   out8 += svcntp_b32(svptrue_b32(), matches);
  }
  if (i < len) {
   svbool_t read_mask = svwhilelt_b32(i, len);
   svuint32_t input = svld1sb_u32(read_mask, (const int8_t *)s + i);
   svbool_t matches = svcmpne_n_u32(read_mask, input, 32);
   svuint32_t compressed = svcompact_u32(matches, input);
   svst1b_u32(read_mask, out8, compressed);
   out8 += svcntp_b32(read_mask, matches);
  }
  return out8 - reinterpret_cast<uint8_t *>(out);
}

快个几倍大概

Did you know that C++23 added support for formatting ranges?

int main() {
  std::cout << std::format("{}",   std::vector{1, 2, 3}); // [1, 2, 3]
  std::cout << std::format("{:n}", std::vector{1, 2, 3}); // 1, 2, 3
  std::cout << std::format("{}",   std::tuple{'1', 2., 3}); // ('1', 2, 3)
  std::cout << std::format("{}",   std::vector{std::pair{'a',1}, std::pair{'b',2}}); // [(a, 1), (b, 2)]
  std::cout << std::format("{:m}", std::vector{std::pair{'a',1}, std::pair{'b',2}}); // {(a, 1), (b, 2)}
}

不多说