C++ Move Semantics Considered Harmful (Rust Is Better)(thecodedmessage.com)

    // given
    void foo(std::string &&s);

    auto s = std::string("Hello");
    foo(std::move(s));
    std::count << s << std::endl; // U.B.. But the compiler won’t complain!

  some_vector.emplace_back(std::move(foo));
  foo.whatever();  // <-- clang-tidy will warn about this

  struct CounterData {
    // Threads call this method very frequently, say thousands of times per second
    void AddCounter(std::string_view key, int val) {
      absl::MutexLock lk(&mut);  // ALMOST NEVER CONTENDED
      counters[key] += val;
    }
  
    absl::flat_hash_map<std::string, int> counters;
    absl::Mutex mut;
  };
  
  // Thread-local instance of counter_data
  static thread_local CounterData counter_data;
  
  // Main thread calls this infrequently, say once a second
  absl::flat_hash_map<std::string, int> AggregateCounters() {
    std::vector<absl::flat_hash_map<std::string, int>> all_counters;
    // Assume it's possible to enumerate threads and iterate over thread local counters,
    // this is not a difficult abstraction to build.
    all_counters.reserve(num_threads);
    for (CounterData &data : all_thread_local_counters) {
      absl::MutexLock lk(&data.mut);
      all_counters.emplace_back(std::move(data.counters));
    }
    absl::flat_hash_map<std::string, int> aggregate;
    for (const auto &map : all_counters) {
      for (const auto &[k, v] : map) {
        aggregate[k] += v;
      }
    }
    return aggregate;
  }