C++ 动态新闻推送 第20期

/// libguarded
plain_guarded<int> data;
...
int getter() const {
  auto p = data.lock();
  return *p;
}
/// folly
class RequestHandler {
  ...
  Synchronized<RequestQueue> requestQueue_;
  Synchronized<std::map<std::string, Endpoint>> requestEndpoints_;
  Synchronized<HandlerState> workState_;
  ...
};

void RequestHandler::processRequest(const Request& request) {
  stop_watch<> watch;
  checkRequestValidity(request);
  requestQueue_.wlock()->push_back(request);
  stats_->addStatValue("requestEnqueueLatency", watch.elapsed());
  LOG(INFO) << "enqueued request ID " << request.getID();
}

template<class T> /*typename*/T::type return_type();   // okay
template<class T> void void_parameter(/*typename*/T::type); // error: variable or field 'parameter' declared void
template<class T> auto auto_parameter(/*typename*/T::type); // okay

template<class T>
struct traits {
  using type = /*typename*/ T::type; // okay
};

template<typename U>
 static inline char* align_for(char* ptr)
 {
     const std::size_t alignment = std::alignment_of<U>::value;
     return ptr + (alignment - (reinterpret_cast<std::uintptr_t>(ptr) % alignment)) % alignment;
 }

template<typename T>
 static inline T ceil_to_pow_2(T x)
 {
     static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "ceil_to_pow_2 is intended to be used only with unsigned integer types");

     // Adapted from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
     --x;
     x |= x >> 1;
     x |= x >> 2;
     x |= x >> 4;
     for (std::size_t i = 1; i < sizeof(T); i <<= 1) {
         x |= x >> (i << 3);
     }
     ++x;
     return x;
 }

int a[3];
int bits = ((a[0] < a[1]) << 2) + ((a[0] < a[2]) << 1) + (a[1] < a[2] 
const int smallest[8] =  [2, 1, 2, 1, 2, 2, 0, 0]
int smallest_v = a[smallest[bits]]
int bits = ((a[0] > a[1]) << 2) + ((a[0] > a[2]) << 1) + (a[1] > a[2] 
const int biggest[8] = [2, 1, 2, 1, 2, 2, 0, 0]
int biggest_v = a[biggest[bits]]

int a = 3728463;
int b = a/10;
int64_t c = 3435973837;
int d = static_cast<int32_t>((static_cast<int64_t>(a) * c)>>35)
assert( b == d)

uint32_t p1 = /*...*/;
int kappa = 10;
uint32_t div = 1000000000;
while (kappa > 0) {
 d = p1 / div; // 第一个除法
 if (d || *len)
     buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
 p1 %= div;
 kappa--;
 div /= 10;    // 第二个除法
 // ...
}

while (kappa > 0) {
 uint32_t d = 0;
 switch (kappa) {
     case  9: d = p1 /  100000000; p1 %=  100000000; break;
     case  8: d = p1 /   10000000; p1 %=   10000000; break;
     case  7: d = p1 /    1000000; p1 %=    1000000; break;
     case  6: d = p1 /     100000; p1 %=     100000; break;
     case  5: d = p1 /      10000; p1 %=      10000; break;
     case  4: d = p1 /       1000; p1 %=       1000; break;
     case  3: d = p1 /        100; p1 %=        100; break;
     case  2: d = p1 /         10; p1 %=         10; break;
     case  1: d = p1;              p1 =           0; break;
     default:;
 }
 if (d || *len)
     buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
 kappa--;
 // ...
}

     vector<uint32_t> utf8_to_uint(const string& text) const
     {
         unsigned char u, v, w, x, y, z;
         vector<uint32_t> utf8_result;
         int num_chars = 0;
         uint32_t num_bytes = text.length();
         long iii = 0;
         while (iii < num_bytes)
         {
             uint32_t cur_utf8_char = 0;
             z = text[iii];
             if (z <= 127)
             {
                 cur_utf8_char = z;
             }
             if (z >= 192 && z <= 223)
             {
                 iii++;
                 y = text[iii];
                 cur_utf8_char = (z - 192) * 64 + (y - 128);
             }
             if (z >= 224 && z <= 239)
             {
                 iii++; y = text[iii];
                 iii++; x = text[iii];
                 cur_utf8_char = (z - 224) * 4096 + (y - 128) * 64 + (x - 128);
             }
             if ((240 <= z)
             {
                 iii++; y = text[iii];
                 iii++; x = text[iii];
                 iii++; w = text[iii];
                 cur_utf8_char = (z - 240) * 262144 + (y - 128) * 4096 + (x - 128) * 64 + (w - 128);
             }
             utf8_result.push_back(cur_utf8_char);
             iii++;
         }
         return utf8_result;
     }

do {
 c = pStr[0]; if (globals::s_parse_flags[c] & 1)
     { ++pStr; break; }
 c = pStr[1]; if (globals::s_parse_flags[c] & 1)
     { pStr += 2; break; }
 c = pStr[2]; if (globals::s_parse_flags[c] & 1)
     { pStr += 3; break; }
 c = pStr[3];
 pStr += 4;
} while (!(globals::s_parse_flags[c] & 1));

template<typename InputStream>
void SkipWhitespace(InputStream& is) {
 internal::StreamLocalCopy<InputStream> copy(is);
 InputStream& s(copy.s);
while (s.Peek() == ' '  ||
        s.Peek() == '\n' ||
        s.Peek() == '\r' ||
        s.Peek() == '\t')
 {
     s.Take();
 }
}

inline const char *SkipWhitespace_SIMD(const char* p) {
 // ... 非对齐处理
static const char whitespace[16] = " \n\r\t";
 const __m128i w = _mm_load_si128((const __m128i *)&whitespace[0]);
for (;; p += 16) {
     const __m128i s = _mm_load_si128((const __m128i *)p);
     const unsigned r = _mm_cvtsi128_si32(_mm_cmpistrm(w, s, 
         _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY |
         _SIDD_BIT_MASK | _SIDD_NEGATIVE_POLARITY));
if (r != 0) {   // some of characters is non-whitespace
#ifdef _MSC_VER         // Find the index of first non-whitespace
         unsigned long offset;
         _BitScanForward(&offset, r);
         return p + offset;
#else
         return p + __builtin_ffs(r) - 1;
#endif
}

inline const char *SkipWhitespace_SIMD(const char* p) {
 // Fast return for single non-whitespace
 if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
     ++p;
 else
     return p;
// ...
}

array<array<uint64_t, 2>, 64> generate_delimit()
// 生成分隔数组
{
 array<array<uint64_t, 2>, 64> result = {};
 int _pre = 1;
 uint64_t temp_2 = 0;
 uint64_t temp_10 = 10;
 for (int i = 0; i < 64; i++)
 {
     temp_2 = (temp_2 << 1) + 1;
     uint64_t current_bit = ceil(log10(temp_2));
     if (current_bit <= _pre)
     {
         result[i][0] = temp_2;
         result[i][1] = _pre;
     }
     else
     {
         result[i][0] = temp_10 - 1;
         result[i][1] = _pre;
         _pre = current_bit;
         temp_10 = temp_10 * 10;
     }
 }

 return result;

};
uint32_t digits10(uint64_t v)
{
 const static array<array<uint64_t, 2>, 64> bit_table = generate_delimit();
 if (v == 0)
 {
     return 1;
 }
 auto cur_index = 63 - __lzcnt64(v);// 这行指令是msvc特有的 其他平台的名字不同
 return bit_table[cur_index][1] + (v > bit_table[cur_index][0]);

}

static bool isWineColour(const std::string& iWineCoulour) {
  static const std::array<std::string, 3> wineCoulours{ "white", "red", "rose" };
  return std::find(wineCoulours.begin(), wineCoulours.end(), iWineCoulour)
         != wineCoulours.end();
}

enum class log_level : char
{
   Info = 'I',
   Warning = 'W',
   Error = 'E'
};

auto as_local(std::chrono::system_clock::time_point const tp)
{
   return std::chrono::zoned_time{ std::chrono::current_zone(), tp };
}

std::string to_string(auto tp)
{
   return std::format("{:%F %T %Z}", tp);
}

std::string to_string(std::source_location const source)
{
   return std::format("{}:{}:{}", 
      std::filesystem::path(source.file_name()).filename().string(),
      source.function_name(),
      source.line());
}

void log(log_level const level, 
         std::string_view const message, 
         std::source_location const source = std::source_location::current())
{
   std::cout
      << std::format("[{}] {} | {} | {}", 
                     static_cast<char>(level), 
                     to_string(as_local(std::chrono::system_clock::now())), 
                     to_string(source), 
                     message)
      << '\n';
}

void execute(int, double)
{
   log(log_level::Error, "Error in execute!");
}
int main()
{
   log(log_level::Info, "Logging from main!");
   execute(0, 0);
}

     This site is open source. [Improve this page](https://github.com/wanghenshui/cppweeklynews/edit/dev/posts/020.md).