diff --git a/table/cuckoo/cuckoo_table_reader.cc b/table/cuckoo/cuckoo_table_reader.cc
index a4479ab60c..54ae6266ef 100644
--- a/table/cuckoo/cuckoo_table_reader.cc
+++ b/table/cuckoo/cuckoo_table_reader.cc
@@ -43,7 +43,7 @@ CuckooTableReader::CuckooTableReader(
       identity_as_first_hash_(false),
       use_module_hash_(false),
       num_hash_func_(0),
-      unused_key_(""),
+
       key_length_(0),
       user_key_length_(0),
       value_length_(0),
@@ -182,7 +182,9 @@ Status CuckooTableReader::Get(const ReadOptions& /*readOptions*/,
           ParsedInternalKey found_ikey;
           Status s = ParseInternalKey(full_key, &found_ikey,
                                       false /* log_err_key */);  // TODO
-          if (!s.ok()) return s;
+          if (!s.ok()) {
+            return s;
+          }
           bool dont_care __attribute__((__unused__));
           get_context->SaveValue(found_ikey, value, &dont_care);
         }
@@ -213,7 +215,7 @@ class CuckooTableIterator : public InternalIterator {
   // No copying allowed
   CuckooTableIterator(const CuckooTableIterator&) = delete;
   void operator=(const Iterator&) = delete;
-  ~CuckooTableIterator() override {}
+  ~CuckooTableIterator() override = default;
   bool Valid() const override;
   void SeekToFirst() override;
   void SeekToLast() override;
diff --git a/table/cuckoo/cuckoo_table_reader_test.cc b/table/cuckoo/cuckoo_table_reader_test.cc
index e83baa1077..d829b36304 100644
--- a/table/cuckoo/cuckoo_table_reader_test.cc
+++ b/table/cuckoo/cuckoo_table_reader_test.cc
@@ -249,7 +249,7 @@ TEST_F(CuckooReaderTest, WhenKeyExistsWithUint64Comparator) {
   fname = test::PerThreadDBPath("CuckooReaderUint64_WhenKeyExists");
   for (uint64_t i = 0; i < num_items; i++) {
     user_keys[i].resize(8);
-    memcpy(&user_keys[i][0], static_cast<void*>(&i), 8);
+    memcpy(user_keys[i].data(), static_cast<void*>(&i), 8);
     ParsedInternalKey ikey(user_keys[i], i + 1000, kTypeValue);
     AppendInternalKey(&keys[i], ikey);
     values[i] = "value" + NumToStr(i);
@@ -296,7 +296,7 @@ TEST_F(CuckooReaderTest, CheckIteratorUint64) {
   fname = test::PerThreadDBPath("CuckooReader_CheckIterator");
   for (uint64_t i = 0; i < num_items; i++) {
     user_keys[i].resize(8);
-    memcpy(&user_keys[i][0], static_cast<void*>(&i), 8);
+    memcpy(user_keys[i].data(), static_cast<void*>(&i), 8);
     ParsedInternalKey ikey(user_keys[i], 1000, kTypeValue);
     AppendInternalKey(&keys[i], ikey);
     values[i] = "value" + NumToStr(i);
@@ -425,7 +425,7 @@ void WriteFile(const std::vector<std::string>& keys, const uint64_t num,
   ASSERT_OK(builder.status());
   for (uint64_t key_idx = 0; key_idx < num; ++key_idx) {
     // Value is just a part of key.
-    builder.Add(Slice(keys[key_idx]), Slice(&keys[key_idx][0], 4));
+    builder.Add(Slice(keys[key_idx]), Slice(keys[key_idx].data(), 4));
     ASSERT_EQ(builder.NumEntries(), key_idx + 1);
     ASSERT_OK(builder.status());
   }
@@ -454,7 +454,7 @@ void WriteFile(const std::vector<std::string>& keys, const uint64_t num,
     value.Reset();
     value.clear();
     ASSERT_OK(reader.Get(r_options, Slice(keys[i]), &get_context, nullptr));
-    ASSERT_TRUE(Slice(keys[i]) == Slice(&keys[i][0], 4));
+    ASSERT_TRUE(Slice(keys[i]) == Slice(keys[i].data(), 4));
   }
 }
 
diff --git a/table/format.cc b/table/format.cc
index 27ecce5472..939b7dcd6b 100644
--- a/table/format.cc
+++ b/table/format.cc
@@ -390,7 +390,7 @@ Status Footer::DecodeFrom(Slice input, uint64_t input_offset,
     if (checksum_type_ != kNoChecksum && format_version_ >= 6) {
       std::array<char, kNewVersionsEncodedLength> copy_without_checksum;
       std::copy_n(input.data(), kNewVersionsEncodedLength,
-                  &copy_without_checksum[0]);
+                  copy_without_checksum.data());
       EncodeFixed32(&copy_without_checksum[5], 0);  // Clear embedded checksum
       computed_checksum =
           ComputeBuiltinChecksum(checksum_type(), copy_without_checksum.data(),
@@ -518,9 +518,11 @@ Status ReadFooterFromFile(const IOOptions& opts, RandomAccessFileReader* file,
     } else {
       footer_buf.reserve(Footer::kMaxEncodedLength);
       s = file->Read(opts, read_offset, Footer::kMaxEncodedLength,
-                     &footer_input, &footer_buf[0], nullptr);
+                     &footer_input, footer_buf.data(), nullptr);
+    }
+    if (!s.ok()) {
+      return s;
     }
-    if (!s.ok()) return s;
   }
 
   // Check that we actually read the whole footer from the file. It may be
diff --git a/table/merger_test.cc b/table/merger_test.cc
index 71dc798e57..29e433c28e 100644
--- a/table/merger_test.cc
+++ b/table/merger_test.cc
@@ -107,7 +107,7 @@ class MergerTest : public testing::Test {
     }
 
     merging_iterator_.reset(
-        NewMergingIterator(&icomp_, &small_iterators[0],
+        NewMergingIterator(&icomp_, small_iterators.data(),
                            static_cast<int>(small_iterators.size())));
     single_iterator_.reset(new VectorIterator(all_keys_, all_keys_, &icomp_));
   }
diff --git a/table/mock_table.cc b/table/mock_table.cc
index 1823758e44..1971c00fc5 100644
--- a/table/mock_table.cc
+++ b/table/mock_table.cc
@@ -59,7 +59,7 @@ class MockTableReader : public TableReader {
 
   std::shared_ptr<const TableProperties> GetTableProperties() const override;
 
-  ~MockTableReader() {}
+  ~MockTableReader() = default;
 
  private:
   const KVVector& table_;
@@ -134,7 +134,7 @@ class MockTableBuilder : public TableBuilder {
   }
 
   // REQUIRES: Either Finish() or Abandon() has been called.
-  ~MockTableBuilder() {}
+  ~MockTableBuilder() = default;
 
   // Add key,value to the table being constructed.
   // REQUIRES: key is after any previously added key according to comparator.
diff --git a/table/plain/plain_table_builder.cc b/table/plain/plain_table_builder.cc
index 24dd0f97ae..784ef14716 100644
--- a/table/plain/plain_table_builder.cc
+++ b/table/plain/plain_table_builder.cc
@@ -5,8 +5,7 @@
 
 #include "table/plain/plain_table_builder.h"
 
-#include <assert.h>
-
+#include <cassert>
 #include <limits>
 #include <map>
 #include <string>
diff --git a/table/plain/plain_table_factory.cc b/table/plain/plain_table_factory.cc
index 80aa9cb8e8..730aec028f 100644
--- a/table/plain/plain_table_factory.cc
+++ b/table/plain/plain_table_factory.cc
@@ -5,8 +5,7 @@
 
 #include "table/plain/plain_table_factory.h"
 
-#include <stdint.h>
-
+#include <cstdint>
 #include <memory>
 
 #include "db/dbformat.h"
@@ -157,7 +156,7 @@ static int RegisterBuiltinMemTableRepFactory(ObjectLibrary& library,
       AsPattern(VectorRepFactory::kClassName(), VectorRepFactory::kNickName()),
       [](const std::string& uri, std::unique_ptr<MemTableRepFactory>* guard,
          std::string* /*errmsg*/) {
-        auto colon = uri.find(":");
+        auto colon = uri.find(':');
         if (colon != std::string::npos) {
           size_t count = ParseSizeT(uri.substr(colon + 1));
           guard->reset(new VectorRepFactory(count));
@@ -170,7 +169,7 @@ static int RegisterBuiltinMemTableRepFactory(ObjectLibrary& library,
       AsPattern(SkipListFactory::kClassName(), SkipListFactory::kNickName()),
       [](const std::string& uri, std::unique_ptr<MemTableRepFactory>* guard,
          std::string* /*errmsg*/) {
-        auto colon = uri.find(":");
+        auto colon = uri.find(':');
         if (colon != std::string::npos) {
           size_t lookahead = ParseSizeT(uri.substr(colon + 1));
           guard->reset(new SkipListFactory(lookahead));
@@ -184,7 +183,7 @@ static int RegisterBuiltinMemTableRepFactory(ObjectLibrary& library,
       [](const std::string& uri, std::unique_ptr<MemTableRepFactory>* guard,
          std::string* /*errmsg*/) {
         // Expecting format: hash_linkedlist:<hash_bucket_count>
-        auto colon = uri.find(":");
+        auto colon = uri.find(':');
         if (colon != std::string::npos) {
           size_t hash_bucket_count = ParseSizeT(uri.substr(colon + 1));
           guard->reset(NewHashLinkListRepFactory(hash_bucket_count));
@@ -198,7 +197,7 @@ static int RegisterBuiltinMemTableRepFactory(ObjectLibrary& library,
       [](const std::string& uri, std::unique_ptr<MemTableRepFactory>* guard,
          std::string* /*errmsg*/) {
         // Expecting format: prefix_hash:<hash_bucket_count>
-        auto colon = uri.find(":");
+        auto colon = uri.find(':');
         if (colon != std::string::npos) {
           size_t hash_bucket_count = ParseSizeT(uri.substr(colon + 1));
           guard->reset(NewHashSkipListRepFactory(hash_bucket_count));
diff --git a/table/plain/plain_table_reader.cc b/table/plain/plain_table_reader.cc
index a74da1f895..b917fce342 100644
--- a/table/plain/plain_table_reader.cc
+++ b/table/plain/plain_table_reader.cc
@@ -454,7 +454,9 @@ Status PlainTableReader::GetOffset(PlainTableKeyDecoder* decoder,
   ParsedInternalKey parsed_target;
   Status s = ParseInternalKey(target, &parsed_target,
                               false /* log_err_key */);  // TODO
-  if (!s.ok()) return s;
+  if (!s.ok()) {
+    return s;
+  }
 
   // The key is between [low, high). Do a binary search between it.
   while (high - low > 1) {
@@ -591,7 +593,9 @@ Status PlainTableReader::Get(const ReadOptions& /*ro*/, const Slice& target,
   ParsedInternalKey parsed_target;
   s = ParseInternalKey(target, &parsed_target,
                        false /* log_err_key */);  // TODO
-  if (!s.ok()) return s;
+  if (!s.ok()) {
+    return s;
+  }
 
   Slice found_value;
   while (offset < file_info_.data_end_offset) {
@@ -642,7 +646,7 @@ PlainTableIterator::PlainTableIterator(PlainTableReader* table,
   next_offset_ = offset_ = table_->file_info_.data_end_offset;
 }
 
-PlainTableIterator::~PlainTableIterator() {}
+PlainTableIterator::~PlainTableIterator() = default;
 
 bool PlainTableIterator::Valid() const {
   return offset_ < table_->file_info_.data_end_offset &&
diff --git a/table/sst_file_dumper.cc b/table/sst_file_dumper.cc
index d44056defe..821fff5b30 100644
--- a/table/sst_file_dumper.cc
+++ b/table/sst_file_dumper.cc
@@ -495,7 +495,9 @@ Status SstFileDumper::ReadSequential(bool print_kv, uint64_t read_num,
     Slice key = iter->key();
     Slice value = iter->value();
     ++i;
-    if (read_num > 0 && i > read_num) break;
+    if (read_num > 0 && i > read_num) {
+      break;
+    }
 
     ParsedInternalKey ikey;
     Status pik_status = ParseInternalKey(key, &ikey, true /* log_err_key */);
diff --git a/table/sst_file_reader.cc b/table/sst_file_reader.cc
index 533b7cd6ac..d23c58deb8 100644
--- a/table/sst_file_reader.cc
+++ b/table/sst_file_reader.cc
@@ -36,7 +36,7 @@ struct SstFileReader::Rep {
 
 SstFileReader::SstFileReader(const Options& options) : rep_(new Rep(options)) {}
 
-SstFileReader::~SstFileReader() {}
+SstFileReader::~SstFileReader() = default;
 
 Status SstFileReader::Open(const std::string& file_path) {
   auto r = rep_.get();
diff --git a/table/table_test.cc b/table/table_test.cc
index e6f95243e1..c3981289e6 100644
--- a/table/table_test.cc
+++ b/table/table_test.cc
@@ -10,10 +10,10 @@
 #include "rocksdb/table.h"
 
 #include <gtest/gtest.h>
-#include <stddef.h>
-#include <stdio.h>
 
 #include <algorithm>
+#include <cstddef>
+#include <cstdio>
 #include <iostream>
 #include <map>
 #include <memory>
@@ -186,7 +186,7 @@ class Constructor {
  public:
   explicit Constructor(const Comparator* cmp)
       : data_(stl_wrappers::LessOfComparator(cmp)) {}
-  virtual ~Constructor() {}
+  virtual ~Constructor() = default;
 
   void Add(const std::string& key, const Slice& value) {
     data_[key] = value.ToString();
@@ -295,8 +295,8 @@ class KeyConvertingIterator : public InternalIterator {
   bool arena_mode_;
 
   // No copying allowed
-  KeyConvertingIterator(const KeyConvertingIterator&);
-  void operator=(const KeyConvertingIterator&);
+  KeyConvertingIterator(const KeyConvertingIterator&) = delete;
+  void operator=(const KeyConvertingIterator&) = delete;
 };
 
 // `BlockConstructor` APIs always accept/return user keys.
@@ -345,7 +345,7 @@ class BlockConstructor : public Constructor {
   std::string data_;
   Block* block_;
 
-  BlockConstructor();
+  BlockConstructor() = delete;
 };
 
 class TableConstructor : public Constructor {
@@ -487,7 +487,7 @@ class TableConstructor : public Constructor {
   bool convert_to_internal_key_;
   int level_;
 
-  TableConstructor();
+  TableConstructor() = delete;
 
   static uint64_t cur_file_num_;
   EnvOptions soptions;
@@ -930,13 +930,17 @@ class HarnessTest : public testing::Test {
     InternalIterator* iter = constructor_->NewIterator();
     ASSERT_TRUE(!iter->Valid());
     stl_wrappers::KVMap::const_iterator model_iter = data.begin();
-    if (kVerbose) fprintf(stderr, "---\n");
+    if (kVerbose) {
+      fprintf(stderr, "---\n");
+    }
     for (int i = 0; i < 200; i++) {
       const int toss = rnd->Uniform(support_prev_ ? 5 : 3);
       switch (toss) {
         case 0: {
           if (iter->Valid()) {
-            if (kVerbose) fprintf(stderr, "Next\n");
+            if (kVerbose) {
+              fprintf(stderr, "Next\n");
+            }
             iter->Next();
             ASSERT_OK(iter->status());
             ++model_iter;
@@ -946,7 +950,9 @@ class HarnessTest : public testing::Test {
         }
 
         case 1: {
-          if (kVerbose) fprintf(stderr, "SeekToFirst\n");
+          if (kVerbose) {
+            fprintf(stderr, "SeekToFirst\n");
+          }
           iter->SeekToFirst();
           ASSERT_OK(iter->status());
           model_iter = data.begin();
@@ -957,8 +963,9 @@ class HarnessTest : public testing::Test {
         case 2: {
           std::string key = PickRandomKey(rnd, keys);
           model_iter = data.lower_bound(key);
-          if (kVerbose)
+          if (kVerbose) {
             fprintf(stderr, "Seek '%s'\n", EscapeString(key).c_str());
+          }
           iter->Seek(Slice(key));
           ASSERT_OK(iter->status());
           ASSERT_EQ(ToString(data, model_iter), ToString(iter));
@@ -967,7 +974,9 @@ class HarnessTest : public testing::Test {
 
         case 3: {
           if (iter->Valid()) {
-            if (kVerbose) fprintf(stderr, "Prev\n");
+            if (kVerbose) {
+              fprintf(stderr, "Prev\n");
+            }
             iter->Prev();
             ASSERT_OK(iter->status());
             if (model_iter == data.begin()) {
@@ -981,7 +990,9 @@ class HarnessTest : public testing::Test {
         }
 
         case 4: {
-          if (kVerbose) fprintf(stderr, "SeekToLast\n");
+          if (kVerbose) {
+            fprintf(stderr, "SeekToLast\n");
+          }
           iter->SeekToLast();
           ASSERT_OK(iter->status());
           if (keys.empty()) {
@@ -1253,7 +1264,7 @@ class FileChecksumTestHelper {
  public:
   FileChecksumTestHelper(bool convert_to_internal_key = false)
       : convert_to_internal_key_(convert_to_internal_key) {}
-  ~FileChecksumTestHelper() {}
+  ~FileChecksumTestHelper() = default;
 
   void CreateWritableFile() {
     sink_ = new test::StringSink();
@@ -1437,7 +1448,7 @@ TestIds GetUniqueId(TableProperties* tp, std::unordered_set<uint64_t>* seen,
     std::string euid;
     EXPECT_OK(GetExtendedUniqueIdFromTableProperties(*tp, &euid));
     EXPECT_EQ(euid.size(), 24U);
-    t.external_id[0] = DecodeFixed64(&euid[0]);
+    t.external_id[0] = DecodeFixed64(euid.data());
     t.external_id[1] = DecodeFixed64(&euid[8]);
     t.external_id[2] = DecodeFixed64(&euid[16]);
 
@@ -1445,7 +1456,7 @@ TestIds GetUniqueId(TableProperties* tp, std::unordered_set<uint64_t>* seen,
     EXPECT_OK(GetUniqueIdFromTableProperties(*tp, &uid));
     EXPECT_EQ(uid.size(), 16U);
     EXPECT_EQ(uid, euid.substr(0, 16));
-    EXPECT_EQ(t.external_id[0], DecodeFixed64(&uid[0]));
+    EXPECT_EQ(t.external_id[0], DecodeFixed64(uid.data()));
     EXPECT_EQ(t.external_id[1], DecodeFixed64(&uid[8]));
   }
   // All these should be effectively random
@@ -1930,19 +1941,19 @@ void AssertKeysInCache(BlockBasedTable* table_reader,
                        const std::vector<std::string>& keys_not_in_cache,
                        bool convert = false) {
   if (convert) {
-    for (auto key : keys_in_cache) {
+    for (const auto& key : keys_in_cache) {
       InternalKey ikey(key, kMaxSequenceNumber, kTypeValue);
       ASSERT_TRUE(table_reader->TEST_KeyInCache(ReadOptions(), ikey.Encode()));
     }
-    for (auto key : keys_not_in_cache) {
+    for (const auto& key : keys_not_in_cache) {
       InternalKey ikey(key, kMaxSequenceNumber, kTypeValue);
       ASSERT_TRUE(!table_reader->TEST_KeyInCache(ReadOptions(), ikey.Encode()));
     }
   } else {
-    for (auto key : keys_in_cache) {
+    for (const auto& key : keys_in_cache) {
       ASSERT_TRUE(table_reader->TEST_KeyInCache(ReadOptions(), key));
     }
-    for (auto key : keys_not_in_cache) {
+    for (const auto& key : keys_not_in_cache) {
       ASSERT_TRUE(!table_reader->TEST_KeyInCache(ReadOptions(), key));
     }
   }
@@ -3246,8 +3257,8 @@ TEST_P(BlockBasedTableTest, TracingMultiGetTest) {
     std::vector<GetContext> get_contexts;
     get_contexts.emplace_back(
         options.comparator, nullptr, nullptr, nullptr, GetContext::kNotFound,
-        ukeys[0], &values[0], nullptr, nullptr, nullptr, true, nullptr, nullptr,
-        nullptr, nullptr, nullptr, nullptr, get_id_offset);
+        ukeys[0], values.data(), nullptr, nullptr, nullptr, true, nullptr,
+        nullptr, nullptr, nullptr, nullptr, nullptr, get_id_offset);
     get_contexts.emplace_back(
         options.comparator, nullptr, nullptr, nullptr, GetContext::kNotFound,
         ukeys[1], &values[1], nullptr, nullptr, nullptr, true, nullptr, nullptr,
@@ -3258,12 +3269,12 @@ TEST_P(BlockBasedTableTest, TracingMultiGetTest) {
     std::array<Status, 2> statuses;
     autovector<KeyContext, MultiGetContext::MAX_BATCH_SIZE> key_context;
     key_context.emplace_back(/*ColumnFamilyHandle omitted*/ nullptr, ukeys[0],
-                             &values[0],
+                             values.data(),
                              /*PinnableWideColumns omitted*/ nullptr,
-                             /*timestamp omitted*/ nullptr, &statuses[0]);
+                             /*timestamp omitted*/ nullptr, statuses.data());
     key_context[0].ukey_without_ts = ukeys[0];
     key_context[0].ikey = encoded_keys[0];
-    key_context[0].get_context = &get_contexts[0];
+    key_context[0].get_context = get_contexts.data();
     key_context.emplace_back(/*ColumnFamilyHandle omitted*/ nullptr, ukeys[1],
                              &values[1],
                              /*PinnableWideColumns omitted*/ nullptr,
@@ -4660,14 +4671,15 @@ TEST_P(IndexBlockRestartIntervalTest, IndexBlockRestartInterval) {
 class PrefixTest : public testing::Test {
  public:
   PrefixTest() : testing::Test() {}
-  ~PrefixTest() override {}
+  ~PrefixTest() override = default;
 };
 
 namespace {
 // A simple PrefixExtractor that only works for test PrefixAndWholeKeyTest
 class TestPrefixExtractor : public ROCKSDB_NAMESPACE::SliceTransform {
  public:
-  ~TestPrefixExtractor() override{};
+  ~TestPrefixExtractor() override = default;
+  ;
   const char* Name() const override { return "TestPrefixExtractor"; }
 
   ROCKSDB_NAMESPACE::Slice Transform(
diff --git a/table/two_level_iterator.cc b/table/two_level_iterator.cc
index 4b6634e5cf..c66a94fb54 100644
--- a/table/two_level_iterator.cc
+++ b/table/two_level_iterator.cc
@@ -70,7 +70,9 @@ class TwoLevelIndexIterator : public InternalIteratorBase<IndexValue> {
 
  private:
   void SaveError(const Status& s) {
-    if (status_.ok() && !s.ok()) status_ = s;
+    if (status_.ok() && !s.ok()) {
+      status_ = s;
+    }
   }
   void SkipEmptyDataBlocksForward();
   void SkipEmptyDataBlocksBackward();
diff --git a/table/unique_id.cc b/table/unique_id.cc
index fcdd756504..8bfa8bcfd3 100644
--- a/table/unique_id.cc
+++ b/table/unique_id.cc
@@ -14,7 +14,7 @@ namespace ROCKSDB_NAMESPACE {
 
 std::string EncodeSessionId(uint64_t upper, uint64_t lower) {
   std::string db_session_id(20U, '\0');
-  char *buf = &db_session_id[0];
+  char *buf = db_session_id.data();
   // Preserving `lower` is slightly tricky. 36^12 is slightly more than
   // 62 bits, so we use 12 chars plus the bottom two bits of one more.
   // (A tiny fraction of 20 digit strings go unused.)
@@ -152,7 +152,7 @@ void ExternalUniqueIdToInternal(UniqueIdPtr in_out) {
 
 std::string EncodeUniqueIdBytes(UniqueIdPtr in) {
   std::string ret(in.extended ? 24U : 16U, '\0');
-  EncodeFixed64(&ret[0], in.ptr[0]);
+  EncodeFixed64(ret.data(), in.ptr[0]);
   EncodeFixed64(&ret[8], in.ptr[1]);
   if (in.extended) {
     EncodeFixed64(&ret[16], in.ptr[2]);
diff --git a/test_util/testutil.cc b/test_util/testutil.cc
index 1e771f4fd1..ce221e79bc 100644
--- a/test_util/testutil.cc
+++ b/test_util/testutil.cc
@@ -94,7 +94,9 @@ bool ShouldPersistUDT(const UserDefinedTimestampTestMode& test_mode) {
 extern Slice CompressibleString(Random* rnd, double compressed_fraction,
                                 int len, std::string* dst) {
   int raw = static_cast<int>(len * compressed_fraction);
-  if (raw < 1) raw = 1;
+  if (raw < 1) {
+    raw = 1;
+  }
   std::string raw_data = rnd->RandomBinaryString(raw);
 
   // Duplicate the random data until we have filled "len" bytes
@@ -109,7 +111,7 @@ extern Slice CompressibleString(Random* rnd, double compressed_fraction,
 namespace {
 class Uint64ComparatorImpl : public Comparator {
  public:
-  Uint64ComparatorImpl() {}
+  Uint64ComparatorImpl() = default;
 
   const char* Name() const override { return "rocksdb.Uint64Comparator"; }
 
@@ -131,11 +133,9 @@ class Uint64ComparatorImpl : public Comparator {
   }
 
   void FindShortestSeparator(std::string* /*start*/,
-                             const Slice& /*limit*/) const override {
-    return;
-  }
+                             const Slice& /*limit*/) const override {}
 
-  void FindShortSuccessor(std::string* /*key*/) const override { return; }
+  void FindShortSuccessor(std::string* /*key*/) const override {}
 };
 }  // namespace
 
@@ -632,7 +632,7 @@ class SpecialMemTableRep : public MemTableRep {
     return memtable_->GetIterator(arena);
   }
 
-  virtual ~SpecialMemTableRep() override {}
+  virtual ~SpecialMemTableRep() override = default;
 
  private:
   std::unique_ptr<MemTableRep> memtable_;
@@ -647,7 +647,7 @@ class SpecialSkipListFactory : public MemTableRepFactory {
             .AddNumber(":"),
         [](const std::string& uri, std::unique_ptr<MemTableRepFactory>* guard,
            std::string* /* errmsg */) {
-          auto colon = uri.find(":");
+          auto colon = uri.find(':');
           if (colon != std::string::npos) {
             auto count = ParseInt(uri.substr(colon + 1));
             guard->reset(new SpecialSkipListFactory(count));
diff --git a/tools/block_cache_analyzer/block_cache_trace_analyzer.cc b/tools/block_cache_analyzer/block_cache_trace_analyzer.cc
index f2d4f05bea..e6473191df 100644
--- a/tools/block_cache_analyzer/block_cache_trace_analyzer.cc
+++ b/tools/block_cache_analyzer/block_cache_trace_analyzer.cc
@@ -577,7 +577,7 @@ void BlockCacheTraceAnalyzer::WriteSkewness(
   std::map<std::string, std::map<uint64_t, uint64_t>> label_bucket_naccesses;
   std::vector<std::pair<std::string, uint64_t>> pairs;
   for (auto const& itr : label_naccesses) {
-    pairs.push_back(itr);
+    pairs.emplace_back(itr);
   }
   // Sort in descending order.
   sort(pairs.begin(), pairs.end(),
diff --git a/tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc b/tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc
index 174565641f..77a6d1b2bb 100644
--- a/tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc
+++ b/tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc
@@ -492,7 +492,7 @@ TEST_F(BlockCacheTracerTest, BlockCacheAnalyzer) {
       ASSERT_EQ(20, ParseDouble(percent));
     }
     ASSERT_EQ(expected_callers.size(), callers.size());
-    for (auto caller : callers) {
+    for (const auto& caller : callers) {
       ASSERT_TRUE(expected_callers.find(caller) != expected_callers.end());
     }
     ASSERT_OK(env_->DeleteFile(percent_access_summary_file));
@@ -504,7 +504,7 @@ TEST_F(BlockCacheTracerTest, BlockCacheAnalyzer) {
       std::string caller;
       ASSERT_TRUE(getline(analyzing_callers, caller, ','));
       std::vector<std::string> breakdowns{"level", "bt"};
-      for (auto breakdown : breakdowns) {
+      for (const auto& breakdown : breakdowns) {
         const std::string file_name = test_path_ + "/" + caller + "_" +
                                       breakdown +
                                       "_percentage_of_accesses_summary";
@@ -554,7 +554,7 @@ TEST_F(BlockCacheTracerTest, BlockCacheAnalyzer) {
   }
   for (auto const& access_type : access_types) {
     std::vector<std::string> block_types{"Index", "Data", "Filter"};
-    for (auto block_type : block_types) {
+    for (const auto& block_type : block_types) {
       // Validate reuse block timeline.
       const std::string reuse_blocks_timeline = test_path_ + "/" + block_type +
                                                 "_" + access_type +
diff --git a/tools/db_bench_tool.cc b/tools/db_bench_tool.cc
index dc595781d7..e177934b09 100644
--- a/tools/db_bench_tool.cc
+++ b/tools/db_bench_tool.cc
@@ -15,9 +15,10 @@
 #include <unistd.h>
 #endif
 #include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <sys/types.h>
+
+#include <cstdio>
+#include <cstdlib>
 #ifdef __APPLE__
 #include <mach/host_info.h>
 #include <mach/mach_host.h>
@@ -1258,23 +1259,23 @@ static enum ROCKSDB_NAMESPACE::CompressionType StringToCompressionType(
     const char* ctype) {
   assert(ctype);
 
-  if (!strcasecmp(ctype, "none"))
+  if (!strcasecmp(ctype, "none")) {
     return ROCKSDB_NAMESPACE::kNoCompression;
-  else if (!strcasecmp(ctype, "snappy"))
+  } else if (!strcasecmp(ctype, "snappy")) {
     return ROCKSDB_NAMESPACE::kSnappyCompression;
-  else if (!strcasecmp(ctype, "zlib"))
+  } else if (!strcasecmp(ctype, "zlib")) {
     return ROCKSDB_NAMESPACE::kZlibCompression;
-  else if (!strcasecmp(ctype, "bzip2"))
+  } else if (!strcasecmp(ctype, "bzip2")) {
     return ROCKSDB_NAMESPACE::kBZip2Compression;
-  else if (!strcasecmp(ctype, "lz4"))
+  } else if (!strcasecmp(ctype, "lz4")) {
     return ROCKSDB_NAMESPACE::kLZ4Compression;
-  else if (!strcasecmp(ctype, "lz4hc"))
+  } else if (!strcasecmp(ctype, "lz4hc")) {
     return ROCKSDB_NAMESPACE::kLZ4HCCompression;
-  else if (!strcasecmp(ctype, "xpress"))
+  } else if (!strcasecmp(ctype, "xpress")) {
     return ROCKSDB_NAMESPACE::kXpressCompression;
-  else if (!strcasecmp(ctype, "zstd"))
+  } else if (!strcasecmp(ctype, "zstd")) {
     return ROCKSDB_NAMESPACE::kZSTD;
-  else {
+  } else {
     fprintf(stderr, "Cannot parse compression type '%s'\n", ctype);
     exit(1);
   }
@@ -1284,15 +1285,15 @@ static enum ROCKSDB_NAMESPACE::TieredAdmissionPolicy StringToAdmissionPolicy(
     const char* policy) {
   assert(policy);
 
-  if (!strcasecmp(policy, "auto"))
+  if (!strcasecmp(policy, "auto")) {
     return ROCKSDB_NAMESPACE::kAdmPolicyAuto;
-  else if (!strcasecmp(policy, "placeholder"))
+  } else if (!strcasecmp(policy, "placeholder")) {
     return ROCKSDB_NAMESPACE::kAdmPolicyPlaceholder;
-  else if (!strcasecmp(policy, "allow_cache_hits"))
+  } else if (!strcasecmp(policy, "allow_cache_hits")) {
     return ROCKSDB_NAMESPACE::kAdmPolicyAllowCacheHits;
-  else if (!strcasecmp(policy, "three_queue"))
+  } else if (!strcasecmp(policy, "three_queue")) {
     return ROCKSDB_NAMESPACE::kAdmPolicyThreeQueue;
-  else {
+  } else {
     fprintf(stderr, "Cannot parse admission policy %s\n", policy);
     exit(1);
   }
@@ -1806,12 +1807,13 @@ static enum DistributionType FLAGS_value_size_distribution_type_e = kFixed;
 static enum DistributionType StringToDistributionType(const char* ctype) {
   assert(ctype);
 
-  if (!strcasecmp(ctype, "fixed"))
+  if (!strcasecmp(ctype, "fixed")) {
     return kFixed;
-  else if (!strcasecmp(ctype, "uniform"))
+  } else if (!strcasecmp(ctype, "uniform")) {
     return kUniform;
-  else if (!strcasecmp(ctype, "normal"))
+  } else if (!strcasecmp(ctype, "normal")) {
     return kNormal;
+  }
 
   fprintf(stdout, "Cannot parse distribution type '%s'\n", ctype);
   exit(1);
@@ -1821,7 +1823,7 @@ class BaseDistribution {
  public:
   BaseDistribution(unsigned int _min, unsigned int _max)
       : min_value_size_(_min), max_value_size_(_max) {}
-  virtual ~BaseDistribution() {}
+  virtual ~BaseDistribution() = default;
 
   unsigned int Generate() {
     auto val = Get();
@@ -1938,7 +1940,9 @@ class RandomGenerator {
 };
 
 static void AppendWithSpace(std::string* str, Slice msg) {
-  if (msg.empty()) return;
+  if (msg.empty()) {
+    return;
+  }
   if (!str->empty()) {
     str->push_back(' ');
   }
@@ -2192,7 +2196,9 @@ class Stats {
   }
 
   void Merge(const Stats& other) {
-    if (other.exclude_from_merge_) return;
+    if (other.exclude_from_merge_) {
+      return;
+    }
 
     for (auto it = other.hist_.begin(); it != other.hist_.end(); ++it) {
       auto this_it = hist_.find(it->first);
@@ -2206,11 +2212,17 @@ class Stats {
     done_ += other.done_;
     bytes_ += other.bytes_;
     seconds_ += other.seconds_;
-    if (other.start_ < start_) start_ = other.start_;
-    if (other.finish_ > finish_) finish_ = other.finish_;
+    if (other.start_ < start_) {
+      start_ = other.start_;
+    }
+    if (other.finish_ > finish_) {
+      finish_ = other.finish_;
+    }
 
     // Just keep the messages from one thread.
-    if (message_.empty()) message_ = other.message_;
+    if (message_.empty()) {
+      message_ = other.message_;
+    }
   }
 
   void Stop() {
@@ -2289,20 +2301,21 @@ class Stats {
     done_ += num_ops;
     if (done_ >= next_report_ && FLAGS_progress_reports) {
       if (!FLAGS_stats_interval) {
-        if (next_report_ < 1000)
+        if (next_report_ < 1000) {
           next_report_ += 100;
-        else if (next_report_ < 5000)
+        } else if (next_report_ < 5000) {
           next_report_ += 500;
-        else if (next_report_ < 10000)
+        } else if (next_report_ < 10000) {
           next_report_ += 1000;
-        else if (next_report_ < 50000)
+        } else if (next_report_ < 50000) {
           next_report_ += 5000;
-        else if (next_report_ < 100000)
+        } else if (next_report_ < 100000) {
           next_report_ += 10000;
-        else if (next_report_ < 500000)
+        } else if (next_report_ < 500000) {
           next_report_ += 50000;
-        else
+        } else {
           next_report_ += 100000;
+        }
         fprintf(stderr, "... finished %" PRIu64 " ops%30s\r", done_, "");
       } else {
         uint64_t now = clock_->NowMicros();
@@ -2334,8 +2347,9 @@ class Stats {
             if (db_with_cfh && db_with_cfh->num_created.load()) {
               for (size_t i = 0; i < db_with_cfh->num_created.load(); ++i) {
                 if (db->GetProperty(db_with_cfh->cfh[i], "rocksdb.cfstats",
-                                    &stats))
+                                    &stats)) {
                   fprintf(stderr, "%s\n", stats.c_str());
+                }
                 if (FLAGS_show_table_properties) {
                   for (int level = 0; level < FLAGS_num_levels; ++level) {
                     if (db->GetProperty(
@@ -2393,7 +2407,9 @@ class Stats {
   void Report(const Slice& name) {
     // Pretend at least one op was done in case we are running a benchmark
     // that does not call FinishedOps().
-    if (done_ < 1) done_ = 1;
+    if (done_ < 1) {
+      done_ = 1;
+    }
 
     std::string extra;
     double elapsed = (finish_ - start_) * 1e-6;
@@ -2658,7 +2674,9 @@ class Duration {
   int64_t GetStage() { return std::min(ops_, max_ops_ - 1) / ops_per_stage_; }
 
   bool Done(int64_t increment) {
-    if (increment <= 0) increment = 1;  // avoid Done(0) and infinite loops
+    if (increment <= 0) {
+      increment = 1;  // avoid Done(0) and infinite loops
+    }
     ops_ += increment;
 
     if (max_seconds_) {
@@ -2725,7 +2743,7 @@ class Benchmark {
           no_auto_recovery_(false),
           recovery_complete_(false) {}
 
-    ~ErrorHandlerListener() override {}
+    ~ErrorHandlerListener() override = default;
 
     const char* Name() const override { return kClassName(); }
     static const char* kClassName() { return "ErrorHandlerListener"; }
@@ -4056,7 +4074,9 @@ class Benchmark {
       count++;
       thread->stats.FinishedOps(nullptr, nullptr, 1, kOthers);
     }
-    if (ptr == nullptr) exit(1);  // Disable unused variable warning.
+    if (ptr == nullptr) {
+      exit(1);  // Disable unused variable warning.
+    }
   }
 
   void Compress(ThreadState* thread) {
@@ -4836,8 +4856,8 @@ class Benchmark {
       }
       std::vector<ColumnFamilyDescriptor> column_families;
       for (size_t i = 0; i < num_hot; i++) {
-        column_families.push_back(ColumnFamilyDescriptor(
-            ColumnFamilyName(i), ColumnFamilyOptions(options)));
+        column_families.emplace_back(ColumnFamilyName(i),
+                                     ColumnFamilyOptions(options));
       }
       std::vector<int> cfh_idx_to_prob;
       if (!FLAGS_column_family_distribution.empty()) {
@@ -5660,7 +5680,7 @@ class Benchmark {
         auto total_size = meta.levels[0].size;
         if (total_size >=
             db->GetOptions().compaction_options_fifo.max_table_files_size) {
-          for (auto file_meta : meta.levels[0].files) {
+          for (const auto& file_meta : meta.levels[0].files) {
             file_names.emplace_back(file_meta.name);
           }
           break;
@@ -5711,7 +5731,7 @@ class Benchmark {
         SequenceNumber sorted_run_largest_seqno = 0;
         std::string sorted_run_smallest_key, sorted_run_largest_key;
         bool first_key = true;
-        for (auto fileMeta : sorted_runs[k][i]) {
+        for (const auto& fileMeta : sorted_runs[k][i]) {
           sorted_run_smallest_seqno =
               std::min(sorted_run_smallest_seqno, fileMeta.smallest_seqno);
           sorted_run_largest_seqno =
@@ -5732,7 +5752,7 @@ class Benchmark {
             (compaction_style == kCompactionStyleUniversal && level > 0)) {
           SequenceNumber level_smallest_seqno = kMaxSequenceNumber;
           SequenceNumber level_largest_seqno = 0;
-          for (auto fileMeta : meta.levels[level].files) {
+          for (const auto& fileMeta : meta.levels[level].files) {
             level_smallest_seqno =
                 std::min(level_smallest_seqno, fileMeta.smallest_seqno);
             level_largest_seqno =
@@ -6254,8 +6274,8 @@ class Benchmark {
         GenerateKeyFromInt(lkey, FLAGS_num, &lkeys[i]);
         GenerateKeyFromInt(rkey, FLAGS_num, &rkeys[i]);
       }
-      db->GetApproximateSizes(&ranges[0], static_cast<int>(entries_per_batch_),
-                              &sizes[0]);
+      db->GetApproximateSizes(
+          ranges.data(), static_cast<int>(entries_per_batch_), sizes.data());
       num_sizes += entries_per_batch_;
       for (int64_t size : sizes) {
         size_sum += size;
@@ -6308,8 +6328,8 @@ class Benchmark {
     std::vector<double> ratio_;
     int range_;
 
-    QueryDecider() {}
-    ~QueryDecider() {}
+    QueryDecider() = default;
+    ~QueryDecider() = default;
 
     Status Initiate(std::vector<double> ratio_input) {
       int range_max = 1000;
@@ -7652,7 +7672,9 @@ class Benchmark {
         thread->stats.FinishedOps(nullptr, db, 1, kMerge);
       } else {
         Status s = db->Get(read_options_, key, &value);
-        if (value.length() > max_length) max_length = value.length();
+        if (value.length() > max_length) {
+          max_length = value.length();
+        }
 
         if (!s.ok() && !s.IsNotFound()) {
           fprintf(stderr, "get error: %s\n", s.ToString().c_str());
@@ -7717,10 +7739,16 @@ class Benchmark {
   }
 
   bool binary_search(std::vector<int>& data, int start, int end, int key) {
-    if (data.empty()) return false;
-    if (start > end) return false;
+    if (data.empty()) {
+      return false;
+    }
+    if (start > end) {
+      return false;
+    }
     int mid = start + (end - start) / 2;
-    if (mid > static_cast<int>(data.size()) - 1) return false;
+    if (mid > static_cast<int>(data.size()) - 1) {
+      return false;
+    }
     if (data[mid] == key) {
       return true;
     } else if (data[mid] > key) {
@@ -7793,7 +7821,9 @@ class Benchmark {
       found =
           binary_search(data, 0, static_cast<int>(data.size() - 1), lookup_key);
       data.clear();
-      if (found) break;
+      if (found) {
+        break;
+      }
     }
     std::cout << "Found key? " << std::to_string(found) << "\n";
     sp = FLAGS_env->NowNanos();
@@ -7803,7 +7833,9 @@ class Benchmark {
     std::cout << "Sample data from GetMergeOperands API call: ";
     for (PinnableSlice& psl : a_slice) {
       std::cout << "List: " << to_print << " : " << *psl.GetSelf() << "\n";
-      if (to_print++ > 2) break;
+      if (to_print++ > 2) {
+        break;
+      }
     }
   }
 
@@ -8217,7 +8249,9 @@ class Benchmark {
       real_from_level = std::numeric_limits<int>::max();
 
       for (auto& f : files) {
-        if (f.level > 0 && f.level < real_from_level) real_from_level = f.level;
+        if (f.level > 0 && f.level < real_from_level) {
+          real_from_level = f.level;
+        }
       }
 
       if (real_from_level == std::numeric_limits<int>::max()) {
@@ -8233,10 +8267,11 @@ class Benchmark {
 
     std::vector<std::string> files_to_compact;
     for (auto& f : files) {
-      if (f.level == real_from_level)
+      if (f.level == real_from_level) {
         files_to_compact.push_back(f.name);
-      else if (f.level > real_from_level && f.level < next_level)
+      } else if (f.level > real_from_level && f.level < next_level) {
         next_level = f.level;
+      }
     }
 
     if (files_to_compact.empty()) {
@@ -8277,10 +8312,14 @@ class Benchmark {
 
   void CompactLevel(int from_level) {
     if (db_.db != nullptr) {
-      while (!CompactLevelHelper(db_, from_level)) WaitForCompaction();
+      while (!CompactLevelHelper(db_, from_level)) {
+        WaitForCompaction();
+      }
     }
     for (auto& db_with_cfh : multi_dbs_) {
-      while (!CompactLevelHelper(db_with_cfh, from_level)) WaitForCompaction();
+      while (!CompactLevelHelper(db_with_cfh, from_level)) {
+        WaitForCompaction();
+      }
     }
   }
 
@@ -8614,15 +8653,15 @@ int db_bench_tool(int argc, char** argv) {
     exit(1);
   }
 
-  if (!strcasecmp(FLAGS_compaction_fadvice.c_str(), "NONE"))
+  if (!strcasecmp(FLAGS_compaction_fadvice.c_str(), "NONE")) {
     FLAGS_compaction_fadvice_e = ROCKSDB_NAMESPACE::Options::NONE;
-  else if (!strcasecmp(FLAGS_compaction_fadvice.c_str(), "NORMAL"))
+  } else if (!strcasecmp(FLAGS_compaction_fadvice.c_str(), "NORMAL")) {
     FLAGS_compaction_fadvice_e = ROCKSDB_NAMESPACE::Options::NORMAL;
-  else if (!strcasecmp(FLAGS_compaction_fadvice.c_str(), "SEQUENTIAL"))
+  } else if (!strcasecmp(FLAGS_compaction_fadvice.c_str(), "SEQUENTIAL")) {
     FLAGS_compaction_fadvice_e = ROCKSDB_NAMESPACE::Options::SEQUENTIAL;
-  else if (!strcasecmp(FLAGS_compaction_fadvice.c_str(), "WILLNEED"))
+  } else if (!strcasecmp(FLAGS_compaction_fadvice.c_str(), "WILLNEED")) {
     FLAGS_compaction_fadvice_e = ROCKSDB_NAMESPACE::Options::WILLNEED;
-  else {
+  } else {
     fprintf(stdout, "Unknown compaction fadvice:%s\n",
             FLAGS_compaction_fadvice.c_str());
     exit(1);
diff --git a/tools/dump/db_dump_tool.cc b/tools/dump/db_dump_tool.cc
index 535e70c433..e234c9a733 100644
--- a/tools/dump/db_dump_tool.cc
+++ b/tools/dump/db_dump_tool.cc
@@ -195,16 +195,20 @@ bool DbUndumpTool::Run(const UndumpOptions& undump_options,
   std::unique_ptr<char[]> keyscratch(new char[last_keysize]);
   std::unique_ptr<char[]> valscratch(new char[last_valsize]);
 
-  while (1) {
+  while (true) {
     uint32_t keysize, valsize;
     ROCKSDB_NAMESPACE::Slice keyslice;
     ROCKSDB_NAMESPACE::Slice valslice;
 
     status = dumpfile->Read(4, &slice, scratch8);
-    if (!status.ok() || slice.size() != 4) break;
+    if (!status.ok() || slice.size() != 4) {
+      break;
+    }
     keysize = ROCKSDB_NAMESPACE::DecodeFixed32(slice.data());
     if (keysize > last_keysize) {
-      while (keysize > last_keysize) last_keysize *= 2;
+      while (keysize > last_keysize) {
+        last_keysize *= 2;
+      }
       keyscratch = std::unique_ptr<char[]>(new char[last_keysize]);
     }
 
@@ -225,7 +229,9 @@ bool DbUndumpTool::Run(const UndumpOptions& undump_options,
     }
     valsize = ROCKSDB_NAMESPACE::DecodeFixed32(slice.data());
     if (valsize > last_valsize) {
-      while (valsize > last_valsize) last_valsize *= 2;
+      while (valsize > last_valsize) {
+        last_valsize *= 2;
+      }
       valscratch = std::unique_ptr<char[]>(new char[last_valsize]);
     }
 
diff --git a/tools/ldb_cmd.cc b/tools/ldb_cmd.cc
index 0e983bd8a0..1e7feb712c 100644
--- a/tools/ldb_cmd.cc
+++ b/tools/ldb_cmd.cc
@@ -131,7 +131,7 @@ LDBCommand* LDBCommand::InitFromCmdLineArgs(
     const std::vector<ColumnFamilyDescriptor>* column_families) {
   std::vector<std::string> args;
   for (int i = 1; i < argc; i++) {
-    args.push_back(argv[i]);
+    args.emplace_back(argv[i]);
   }
   return InitFromCmdLineArgs(args, options, ldb_options, column_families,
                              SelectCommand);
@@ -984,7 +984,7 @@ void LDBCommand::PrepareOptions() {
     // existing DB.
     if (st.ok() && cf_list.size() > 1) {
       // Ignore single column family DB.
-      for (auto cf_name : cf_list) {
+      for (const auto& cf_name : cf_list) {
         column_families_.emplace_back(cf_name, options_);
       }
     }
@@ -1397,8 +1397,7 @@ ManifestDumpCommand::ManifestDumpCommand(
           options, flags, false,
           BuildCmdLineOptions({ARG_VERBOSE, ARG_PATH, ARG_HEX, ARG_JSON})),
       verbose_(false),
-      json_(false),
-      path_("") {
+      json_(false) {
   verbose_ = IsFlagPresent(flags, ARG_VERBOSE);
   json_ = IsFlagPresent(flags, ARG_JSON);
 
@@ -1544,8 +1543,7 @@ FileChecksumDumpCommand::FileChecksumDumpCommand(
     const std::map<std::string, std::string>& options,
     const std::vector<std::string>& flags)
     : LDBCommand(options, flags, false,
-                 BuildCmdLineOptions({ARG_PATH, ARG_HEX})),
-      path_("") {
+                 BuildCmdLineOptions({ARG_PATH, ARG_HEX})) {
   auto itr = options.find(ARG_PATH);
   if (itr != options.end()) {
     path_ = itr->second;
@@ -1671,7 +1669,7 @@ void ListColumnFamiliesCommand::DoCommand() {
   } else {
     fprintf(stdout, "Column families in %s: \n{", db_path_.c_str());
     bool first = true;
-    for (auto cf : column_families) {
+    for (const auto& cf : column_families) {
       if (!first) {
         fprintf(stdout, ", ");
       }
@@ -1904,11 +1902,16 @@ void InternalDumpCommand::DoCommand() {
       s1 = 0;
       row = ikey.Encode().ToString();
       val = key_version.value;
-      for (k = 0; row[k] != '\x01' && row[k] != '\0'; k++) s1++;
-      for (k = 0; val[k] != '\x01' && val[k] != '\0'; k++) s1++;
+      for (k = 0; row[k] != '\x01' && row[k] != '\0'; k++) {
+        s1++;
+      }
+      for (k = 0; val[k] != '\x01' && val[k] != '\0'; k++) {
+        s1++;
+      }
       for (int j = 0; row[j] != delim_[0] && row[j] != '\0' && row[j] != '\x01';
-           j++)
+           j++) {
         rtype1 += row[j];
+      }
       if (rtype2.compare("") && rtype2.compare(rtype1) != 0) {
         fprintf(stdout, "%s => count:%" PRIu64 "\tsize:%" PRIu64 "\n",
                 rtype2.c_str(), c, s2);
@@ -1954,7 +1957,9 @@ void InternalDumpCommand::DoCommand() {
     }
 
     // Terminate if maximum number of keys have been dumped
-    if (max_keys_ > 0 && count >= max_keys_) break;
+    if (max_keys_ > 0 && count >= max_keys_) {
+      break;
+    }
   }
   if (count_delim_) {
     fprintf(stdout, "%s => count:%" PRIu64 "\tsize:%" PRIu64 "\n",
@@ -2193,9 +2198,13 @@ void DBDumperCommand::DoDumpCommand() {
   for (; iter->Valid(); iter->Next()) {
     int rawtime = 0;
     // If end marker was specified, we stop before it
-    if (!null_to_ && (iter->key().ToString() >= to_)) break;
+    if (!null_to_ && (iter->key().ToString() >= to_)) {
+      break;
+    }
     // Terminate if maximum number of keys have been dumped
-    if (max_keys == 0) break;
+    if (max_keys == 0) {
+      break;
+    }
     if (is_db_ttl_) {
       TtlIterator* it_ttl = static_cast_with_check<TtlIterator>(iter);
       rawtime = it_ttl->ttl_timestamp();
@@ -2216,8 +2225,9 @@ void DBDumperCommand::DoDumpCommand() {
       row = iter->key().ToString();
       val = iter->value().ToString();
       s1 = row.size() + val.size();
-      for (int j = 0; row[j] != delim_[0] && row[j] != '\0'; j++)
+      for (int j = 0; row[j] != delim_[0] && row[j] != '\0'; j++) {
         rtype1 += row[j];
+      }
       if (rtype2.compare("") && rtype2.compare(rtype1) != 0) {
         fprintf(stdout, "%s => count:%" PRIu64 "\tsize:%" PRIu64 "\n",
                 rtype2.c_str(), c, s2);
@@ -2294,7 +2304,7 @@ ReduceDBLevelsCommand::ReduceDBLevelsCommand(
 std::vector<std::string> ReduceDBLevelsCommand::PrepareArgs(
     const std::string& db_path, int new_levels, bool print_old_level) {
   std::vector<std::string> ret;
-  ret.push_back("reduce_levels");
+  ret.emplace_back("reduce_levels");
   ret.push_back("--" + ARG_DB + "=" + db_path);
   ret.push_back("--" + ARG_NEW_LEVELS + "=" + std::to_string(new_levels));
   if (print_old_level) {
@@ -2663,7 +2673,7 @@ class InMemoryHandler : public WriteBatch::Handler {
     return Status::OK();
   }
 
-  ~InMemoryHandler() override {}
+  ~InMemoryHandler() override = default;
 
  protected:
   Handler::OptionState WriteAfterCommit() const override {
@@ -2702,8 +2712,9 @@ void DumpWalFile(Options options, std::string wal_file, bool print_header,
     // we need the log number, but ParseFilename expects dbname/NNN.log.
     std::string sanitized = wal_file;
     size_t lastslash = sanitized.rfind('/');
-    if (lastslash != std::string::npos)
+    if (lastslash != std::string::npos) {
       sanitized = sanitized.substr(lastslash + 1);
+    }
     if (!ParseFileName(sanitized, &log_number, &type)) {
       // bogus input, carry on as best we can
       log_number = 0;
@@ -2979,9 +2990,8 @@ BatchPutCommand::BatchPutCommand(
     for (size_t i = 0; i < params.size(); i += 2) {
       std::string key = params.at(i);
       std::string value = params.at(i + 1);
-      key_values_.push_back(std::pair<std::string, std::string>(
-          is_key_hex_ ? HexToString(key) : key,
-          is_value_hex_ ? HexToString(value) : value));
+      key_values_.emplace_back(is_key_hex_ ? HexToString(key) : key,
+                               is_value_hex_ ? HexToString(value) : value);
     }
   }
   create_if_missing_ = IsFlagPresent(flags_, ARG_CREATE_IF_MISSING);
diff --git a/tools/ldb_cmd_test.cc b/tools/ldb_cmd_test.cc
index 465d1eb317..8e43972d4b 100644
--- a/tools/ldb_cmd_test.cc
+++ b/tools/ldb_cmd_test.cc
@@ -185,7 +185,7 @@ class FileChecksumTestHelper {
  public:
   FileChecksumTestHelper(Options& options, DB* db, std::string db_name)
       : options_(options), db_(db), dbname_(db_name) {}
-  ~FileChecksumTestHelper() {}
+  ~FileChecksumTestHelper() = default;
 
   // Verify the checksum information in Manifest.
   Status VerifyChecksumInManifest(
@@ -233,8 +233,8 @@ class FileChecksumTestHelper {
       return Status::Corruption("The number of files does not match!");
     }
     for (size_t i = 0; i < live_files.size(); i++) {
-      std::string stored_checksum = "";
-      std::string stored_func_name = "";
+      std::string stored_checksum;
+      std::string stored_func_name;
       s = checksum_list->SearchOneFileChecksum(
           live_files[i].file_number, &stored_checksum, &stored_func_name);
       if (s.IsNotFound()) {
@@ -634,9 +634,9 @@ TEST_F(LdbCmdTest, OptionParsing) {
   opts.env = TryLoadCustomOrDefaultEnv();
   {
     std::vector<std::string> args;
-    args.push_back("scan");
-    args.push_back("--ttl");
-    args.push_back("--timestamp");
+    args.emplace_back("scan");
+    args.emplace_back("--ttl");
+    args.emplace_back("--timestamp");
     LDBCommand* command = ROCKSDB_NAMESPACE::LDBCommand::InitFromCmdLineArgs(
         args, opts, LDBOptions(), nullptr);
     const std::vector<std::string> flags = command->TEST_GetFlags();
@@ -648,9 +648,9 @@ TEST_F(LdbCmdTest, OptionParsing) {
   // test parsing options which contains equal sign in the option value
   {
     std::vector<std::string> args;
-    args.push_back("scan");
-    args.push_back("--db=/dev/shm/ldbtest/");
-    args.push_back(
+    args.emplace_back("scan");
+    args.emplace_back("--db=/dev/shm/ldbtest/");
+    args.emplace_back(
         "--from='abcd/efg/hijk/lmn/"
         "opq:__rst.uvw.xyz?a=3+4+bcd+efghi&jk=lm_no&pq=rst-0&uv=wx-8&yz=a&bcd_"
         "ef=gh.ijk'");
diff --git a/tools/ldb_tool.cc b/tools/ldb_tool.cc
index 20e9ebe2c5..a7aebc121d 100644
--- a/tools/ldb_tool.cc
+++ b/tools/ldb_tool.cc
@@ -10,7 +10,7 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-LDBOptions::LDBOptions() {}
+LDBOptions::LDBOptions() = default;
 
 void LDBCommandRunner::PrintHelp(const LDBOptions& ldb_options,
                                  const char* /*exec_name*/, bool to_stderr) {
diff --git a/tools/sst_dump_test.cc b/tools/sst_dump_test.cc
index f0b71bf8ea..07c42b6e74 100644
--- a/tools/sst_dump_test.cc
+++ b/tools/sst_dump_test.cc
@@ -7,7 +7,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
-#include <stdint.h>
+#include <cstdint>
 
 #include "db/wide/wide_column_serialization.h"
 #include "file/random_access_file_reader.h"
diff --git a/tools/sst_dump_tool.cc b/tools/sst_dump_tool.cc
index 1b269043ab..59df1af8db 100644
--- a/tools/sst_dump_tool.cc
+++ b/tools/sst_dump_tool.cc
@@ -400,7 +400,7 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
     // that whether it is a valid sst or not
     // (A directory "file" is not a valid sst)
     filenames.clear();
-    filenames.push_back(dir_or_file);
+    filenames.emplace_back(dir_or_file);
     dir = false;
   }
 
@@ -468,7 +468,7 @@ int SSTDumpTool::Run(int argc, char const* const* argv, Options options) {
         fprintf(stderr, "%s: %s\n", filename.c_str(), st.ToString().c_str());
         exit(1);
       } else {
-        fprintf(stdout, "raw dump written to file %s\n", &out_filename[0]);
+        fprintf(stdout, "raw dump written to file %s\n", out_filename.data());
       }
       continue;
     }
diff --git a/tools/trace_analyzer_test.cc b/tools/trace_analyzer_test.cc
index e7d090eb29..1d5c870540 100644
--- a/tools/trace_analyzer_test.cc
+++ b/tools/trace_analyzer_test.cc
@@ -56,7 +56,7 @@ class TraceAnalyzerTest : public testing::Test {
     dbname_ = test_path_ + "/db";
   }
 
-  ~TraceAnalyzerTest() override {}
+  ~TraceAnalyzerTest() override = default;
 
   void GenerateTrace(std::string trace_path) {
     Options options;
@@ -87,11 +87,11 @@ class TraceAnalyzerTest : public testing::Test {
     ASSERT_OK(batch.DeleteRange("e", "f"));
     ASSERT_OK(db_->Write(wo, &batch));
     std::vector<Slice> keys;
-    keys.push_back("a");
-    keys.push_back("b");
-    keys.push_back("df");
-    keys.push_back("gege");
-    keys.push_back("hjhjhj");
+    keys.emplace_back("a");
+    keys.emplace_back("b");
+    keys.emplace_back("df");
+    keys.emplace_back("gege");
+    keys.emplace_back("hjhjhj");
     std::vector<std::string> values;
     std::vector<Status> ss = db_->MultiGet(ro, keys, &values);
     ASSERT_GE(ss.size(), 0);
@@ -176,8 +176,6 @@ class TraceAnalyzerTest : public testing::Test {
         ASSERT_EQ(result[i][0], cnt[i][0]);
       }
     }
-
-    return;
   }
 
   void AnalyzeTrace(std::vector<std::string>& paras_diff,
diff --git a/tools/trace_analyzer_tool.cc b/tools/trace_analyzer_tool.cc
index 00a4da0461..a1e321dcd0 100644
--- a/tools/trace_analyzer_tool.cc
+++ b/tools/trace_analyzer_tool.cc
@@ -201,7 +201,7 @@ uint64_t MultiplyCheckOverflow(uint64_t op1, uint64_t op2) {
 AnalyzerOptions::AnalyzerOptions()
     : correlation_map(kTaTypeNum, std::vector<int>(kTaTypeNum, -1)) {}
 
-AnalyzerOptions::~AnalyzerOptions() {}
+AnalyzerOptions::~AnalyzerOptions() = default;
 
 void AnalyzerOptions::SparseCorrelationInput(const std::string& in_str) {
   std::string cur = in_str;
@@ -214,14 +214,14 @@ void AnalyzerOptions::SparseCorrelationInput(const std::string& in_str) {
       exit(1);
     }
     std::string opt1, opt2;
-    std::size_t split = cur.find_first_of(",");
+    std::size_t split = cur.find_first_of(',');
     if (split != std::string::npos) {
       opt1 = cur.substr(1, split - 1);
     } else {
       fprintf(stderr, "Invalid correlation input: %s\n", in_str.c_str());
       exit(1);
     }
-    std::size_t end = cur.find_first_of("]");
+    std::size_t end = cur.find_first_of(']');
     if (end != std::string::npos) {
       opt2 = cur.substr(split + 1, end - split - 1);
     } else {
@@ -232,8 +232,7 @@ void AnalyzerOptions::SparseCorrelationInput(const std::string& in_str) {
 
     if (taOptToIndex.find(opt1) != taOptToIndex.end() &&
         taOptToIndex.find(opt2) != taOptToIndex.end()) {
-      correlation_list.push_back(
-          std::make_pair(taOptToIndex[opt1], taOptToIndex[opt2]));
+      correlation_list.emplace_back(taOptToIndex[opt1], taOptToIndex[opt2]);
     } else {
       fprintf(stderr, "Invalid correlation input: %s\n", in_str.c_str());
       exit(1);
@@ -245,7 +244,6 @@ void AnalyzerOptions::SparseCorrelationInput(const std::string& in_str) {
     correlation_map[it.first][it.second] = sequence;
     sequence++;
   }
-  return;
 }
 
 // The trace statistic struct constructor
@@ -264,7 +262,7 @@ TraceStats::TraceStats() {
   a_ave_qps = 0.0;
 }
 
-TraceStats::~TraceStats() {}
+TraceStats::~TraceStats() = default;
 
 // The trace analyzer constructor
 TraceAnalyzer::TraceAnalyzer(std::string& trace_path, std::string& output_path,
@@ -354,7 +352,7 @@ TraceAnalyzer::TraceAnalyzer(std::string& trace_path, std::string& output_path,
   }
 }
 
-TraceAnalyzer::~TraceAnalyzer() {}
+TraceAnalyzer::~TraceAnalyzer() = default;
 
 // Prepare the processing
 // Initiate the global trace reader and writer here
diff --git a/trace_replay/trace_record.cc b/trace_replay/trace_record.cc
index 21df0275dd..a4a4eb9f83 100644
--- a/trace_replay/trace_record.cc
+++ b/trace_replay/trace_record.cc
@@ -97,7 +97,7 @@ IteratorQueryTraceRecord::IteratorQueryTraceRecord(
   upper_.PinSelf(upper_bound);
 }
 
-IteratorQueryTraceRecord::~IteratorQueryTraceRecord() {}
+IteratorQueryTraceRecord::~IteratorQueryTraceRecord() = default;
 
 Slice IteratorQueryTraceRecord::GetLowerBound() const { return Slice(lower_); }
 
diff --git a/trace_replay/trace_replay.cc b/trace_replay/trace_replay.cc
index 126a8e248d..6ade8e316c 100644
--- a/trace_replay/trace_replay.cc
+++ b/trace_replay/trace_replay.cc
@@ -58,8 +58,8 @@ Status TracerHelper::ParseTraceHeader(const Trace& header, int* trace_version,
   std::vector<std::string> s_vec;
   int begin = 0, end;
   for (int i = 0; i < 3; i++) {
-    assert(header.payload.find("\t", begin) != std::string::npos);
-    end = static_cast<int>(header.payload.find("\t", begin));
+    assert(header.payload.find('\t', begin) != std::string::npos);
+    end = static_cast<int>(header.payload.find('\t', begin));
     s_vec.push_back(header.payload.substr(begin, end - begin));
     begin = end + 1;
   }
diff --git a/util/comparator.cc b/util/comparator.cc
index 98ecef9d26..a5d7a7ca0b 100644
--- a/util/comparator.cc
+++ b/util/comparator.cc
@@ -9,9 +9,8 @@
 
 #include "rocksdb/comparator.h"
 
-#include <stdint.h>
-
 #include <algorithm>
+#include <cstdint>
 #include <memory>
 #include <mutex>
 #include <sstream>
@@ -30,7 +29,7 @@ namespace ROCKSDB_NAMESPACE {
 namespace {
 class BytewiseComparatorImpl : public Comparator {
  public:
-  BytewiseComparatorImpl() {}
+  BytewiseComparatorImpl() = default;
   static const char* kClassName() { return "leveldb.BytewiseComparator"; }
   const char* Name() const override { return kClassName(); }
 
@@ -112,7 +111,9 @@ class BytewiseComparatorImpl : public Comparator {
     }
     size_t diff_ind = s.difference_offset(t);
     // same slice
-    if (diff_ind >= s.size()) return false;
+    if (diff_ind >= s.size()) {
+      return false;
+    }
     uint8_t byte_s = static_cast<uint8_t>(s[diff_ind]);
     uint8_t byte_t = static_cast<uint8_t>(t[diff_ind]);
     // first different byte must be consecutive, and remaining bytes must be
@@ -148,7 +149,7 @@ class BytewiseComparatorImpl : public Comparator {
 
 class ReverseBytewiseComparatorImpl : public BytewiseComparatorImpl {
  public:
-  ReverseBytewiseComparatorImpl() {}
+  ReverseBytewiseComparatorImpl() = default;
 
   static const char* kClassName() {
     return "rocksdb.ReverseBytewiseComparator";
diff --git a/util/compression_context_cache.cc b/util/compression_context_cache.cc
index 52c3fac72a..789cc7b624 100644
--- a/util/compression_context_cache.cc
+++ b/util/compression_context_cache.cc
@@ -67,7 +67,7 @@ static_assert(sizeof(ZSTDCachedData) % CACHE_LINE_SIZE == 0,
 
 class CompressionContextCache::Rep {
  public:
-  Rep() {}
+  Rep() = default;
   ZSTDUncompressCachedData GetZSTDUncompressData() {
     auto p = per_core_uncompr_.AccessElementAndIndex();
     int64_t idx = static_cast<int64_t>(p.second);
diff --git a/util/crc32c.cc b/util/crc32c.cc
index 9e97045f44..38a69bb505 100644
--- a/util/crc32c.cc
+++ b/util/crc32c.cc
@@ -11,9 +11,8 @@
 // four bytes at a time.
 #include "util/crc32c.h"
 
-#include <stdint.h>
-
 #include <array>
+#include <cstdint>
 #include <utility>
 
 #include "port/lang.h"
diff --git a/util/dynamic_bloom_test.cc b/util/dynamic_bloom_test.cc
index 925c5479ab..949ab8f76b 100644
--- a/util/dynamic_bloom_test.cc
+++ b/util/dynamic_bloom_test.cc
@@ -164,10 +164,11 @@ TEST_F(DynamicBloomTest, VaryingLengths) {
               "%5.2f%% @ num = %6u, bloom_bits = %6u\n",
               nonseq ? "nonseq" : "seq", rate * 100.0, num, bloom_bits);
 
-      if (rate > 0.0125)
+      if (rate > 0.0125) {
         mediocre_filters++;  // Allowed, but not too often
-      else
+      } else {
         good_filters++;
+      }
     }
   }
 
diff --git a/util/file_checksum_helper.cc b/util/file_checksum_helper.cc
index b8c4099b80..59da96fa8d 100644
--- a/util/file_checksum_helper.cc
+++ b/util/file_checksum_helper.cc
@@ -31,7 +31,7 @@ Status FileChecksumListImpl::GetAllFileChecksums(
     return Status::InvalidArgument("Pointer has not been initiated");
   }
 
-  for (auto i : checksum_map_) {
+  for (const auto& i : checksum_map_) {
     file_numbers->push_back(i.first);
     checksums->push_back(i.second.first);
     checksum_func_names->push_back(i.second.second);
diff --git a/util/file_reader_writer_test.cc b/util/file_reader_writer_test.cc
index 68776612b9..036c030dc1 100644
--- a/util/file_reader_writer_test.cc
+++ b/util/file_reader_writer_test.cc
@@ -31,7 +31,7 @@ TEST_F(WritableFileWriterTest, RangeSync) {
   class FakeWF : public FSWritableFile {
    public:
     explicit FakeWF() : size_(0), last_synced_(0) {}
-    ~FakeWF() override {}
+    ~FakeWF() override = default;
 
     using FSWritableFile::Append;
     IOStatus Append(const Slice& data, const IOOptions& /*options*/,
@@ -134,7 +134,7 @@ TEST_F(WritableFileWriterTest, IncrementalBuffer) {
         : file_data_(_file_data),
           use_direct_io_(_use_direct_io),
           no_flush_(_no_flush) {}
-    ~FakeWF() override {}
+    ~FakeWF() override = default;
 
     using FSWritableFile::Append;
     IOStatus Append(const Slice& data, const IOOptions& /*options*/,
@@ -588,7 +588,7 @@ class ReadaheadSequentialFileTest : public testing::Test,
     scratch_.reset(new char[2 * readahead_size_]);
     ResetSourceStr();
   }
-  ReadaheadSequentialFileTest() {}
+  ReadaheadSequentialFileTest() = default;
   std::string Read(size_t n) {
     Slice result;
     Status s = test_read_holder_->Read(
@@ -919,7 +919,7 @@ class WritableFileWriterIOPriorityTest : public testing::Test {
   class FakeWF : public FSWritableFile {
    public:
     explicit FakeWF(Env::IOPriority io_priority) { SetIOPriority(io_priority); }
-    ~FakeWF() override {}
+    ~FakeWF() override = default;
 
     IOStatus Append(const Slice& /*data*/, const IOOptions& options,
                     IODebugContext* /*dbg*/) override {
diff --git a/util/filelock_test.cc b/util/filelock_test.cc
index 82021aec99..7a41449bf9 100644
--- a/util/filelock_test.cc
+++ b/util/filelock_test.cc
@@ -34,7 +34,7 @@ class LockTest : public testing::Test {
     current_ = this;
   }
 
-  ~LockTest() override {}
+  ~LockTest() override = default;
 
   Status LockFile(FileLock** db_lock) { return env_->LockFile(file_, db_lock); }
 
@@ -94,8 +94,9 @@ class LockTest : public testing::Test {
     } else if (pid > 0) {
       // parent process
       int status;
-      while (-1 == waitpid(pid, &status, 0))
+      while (-1 == waitpid(pid, &status, 0)) {
         ;
+      }
       if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
         // child process exited with non success status
         return false;
diff --git a/util/random.cc b/util/random.cc
index 7ac6ee19a1..17396d32ff 100644
--- a/util/random.cc
+++ b/util/random.cc
@@ -6,10 +6,9 @@
 
 #include "util/random.h"
 
-#include <limits.h>
-#include <stdint.h>
-#include <string.h>
-
+#include <climits>
+#include <cstdint>
+#include <cstring>
 #include <thread>
 #include <utility>