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

#include <cstdint>#include <bit>#include <iostream> constexpr double f64v = 19880124.0;constexpr auto u64v = std::bit_cast<std::uint64_t>(f64v); constexpr std::uint64_t u64v2 = 0x3fe9000000000000ull;constexpr auto f64v2 = std::bit_cast<double>(u64v2); int main(){    std::cout        << std::fixed <<f64v << "f64.to_bits() == 0x"        << std::hex << u64v << "u64\n";     std::cout        << "f64::from_bits(0x" << std::hex << u64v2 << "u64) == "        << std::fixed << f64v2 << "f64\n";}

bench_input = 42;start_time = time();bench_output = run_bench(bench_input);result = time() - start_time;

bench_input = 42;start_time = time();DoNotOptimize(bench_input)bench_output = run_bench(bench_input);DoNotOptimize(bench_output)result = time() - start_time;

inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp& value) {    asm volatile("" : "+r,m"(value) : : "memory");}

asm asm-qualifiers ( AssemblerTemplate                 : OutputOperands                 [ : InputOperands                 [ : Clobbers ] ])

inline BENCHMARK_ALWAYS_INLINE void EnsureMaterialise(Tp& value) {    asm volatile("" : "+r,m"(value) : :); // Doesn't clobber memory.}

bench_input = 42;
// May have global side-effects.start_time = time();
// Also may have global side-effects.// Needs to observe any side-effects of `time()`, so can't be re-ordered before it.// Forces `bench_input` to be materialized, despite it being a constant.DoNotOptimize(bench_input)// Here the compiler must assume that `bench_input` has now been mutated.
// Is expected to observe the potentially mutated value of `bench_input`, therefore// cannot be reordered before `DoNotOptimize()`.bench_output = run_bench(bench_input);
// May have global side-effects.// Depends on `bench_output` so cannot be reordered above `run_bench()`.DoNotOptimize(bench_output)
// Also may have global side-effects.// Needs to observe any potential side effects of `DoNotOptimize(bench_output)`, so// cannot be reordered before it.result = time() - start_time;

void scale_down(vector<double>& v, const double& a) {  for(auto&i : v) i /= a;}std::vector<double> a1{2, 2, 2};scale_douw(a1,a1[0]);// 1 2 2

#include <vector>#include <iostream>#include <iterator>#include <string>#include <sstream>#include <cstdio>using namespace std;
void inline print_vector(const std::vector<int> & v){    ostringstream oss;    copy(v.begin(), v.end(), std::ostream_iterator<int>(oss, " "));    printf("%s\n", oss.str().c_str());}int main(){    vector<int> vec {1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6};    vec.erase(std::remove(        begin(vec), end(vec),                       *std::max_element(begin(vec), end(vec))),          end(vec));    print_vector(vec);  // 1 2 3 4 5 1 2 3 4 5 6 2 3 4 5 6 }

template <class T>  typename std::decay<T>::type    decay_copy (T&& t) {    return std::forward<T>(t);  }

void byRef(std::vector<double>& v, const double& coeff) {  for (auto& i : v) i *= std::sinh(coeff);}
void byVal(std::vector<double>& v, double coeff) {  for (auto& i : v) i *= std::sinh(coeff);}

class Greeter:  def __init__(self, name):    self.name = name    print(f"hello, {self.name}!")      def __enter__(self):    return self
  def __exit__(self, e_type, e_val, e_tb):    print(f"goodbye, {self.name}!")
    def main():  with Greeter(1):    print("we have a greeter")
main()

class DtorScope:  def __init__(self):    self.stack = []
  def __enter__(self):    return self    def __exit__(self, e_type, e_val, e_tb):    while self.stack:      self.stack.pop().__exit__(e_type, e_val, e_tb)        def push(self, cm):    self.stack.append(cm)

def cpp_function(f):  def _wrapper(*args, **kwargs):    with DtorScope():      return f(*args, **kwargs)    return _wrapper

main = cpp_function(main)main()

@cpp_functiondef main():  ...