Merge pull request #1463 from m-holger/modernize

Modernize code

Merge pull request #1463 from m-holger/modernize
Modernize code
m-holger · GitHub
2 parents eda40d87 54afdecb
Showing 128 changed files with 1403 additions and 1439 deletions
TODO.md
compare-for-test/qpdf-test-compare.cc
examples/pdf-attach-file.cc
examples/pdf-bookmarks.cc
examples/pdf-count-strings.cc
examples/pdf-create.cc
examples/pdf-custom-filter.cc
examples/pdf-double-page-size.cc
examples/pdf-filter-tokens.cc
examples/pdf-invert-images.cc
examples/pdf-mod-info.cc
examples/pdf-name-number-tree.cc
examples/pdf-npages.cc
examples/pdf-overlay-page.cc
examples/pdf-parse-content.cc
examples/pdf-set-form-values.cc
examples/pdf-split-pages.cc
examples/qpdf-job.cc
examples/qpdfjob-save-attachment.cc
fuzz/ascii85_fuzzer.cc
@@ -45,7 +45,6 @@ with modern equivalent. Key updates are:
 Next steps are:
  
 * review function signatures in the public API
-* replace code that uses QUtil::make_shared_cstr etc
  
 Except for the above, prefer to make modernization changes as part of other updates.
  
@@ -13,18 +13,14 @@ static char const* whoami = nullptr;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " actual expected" << std::endl
-              << R"(Where "actual" is the actual output and "expected" is the expected)"
-              << std::endl
-              << "output of a test, compare the two PDF files. The files are considered"
-              << std::endl
-              << "to match if all their objects are identical except that, if a stream is"
-              << std::endl
-              << "compressed with FlateDecode, the uncompressed data must match." << std::endl
-              << std::endl
-              << "If the files match, the output is the expected file. Otherwise, it is"
-              << std::endl
-              << "the actual file. Read comments in the code for rationale." << std::endl;
+    std::cerr << "Usage: " << whoami << " actual expected" << '\n'
+              << R"(Where "actual" is the actual output and "expected" is the expected)" << '\n'
+              << "output of a test, compare the two PDF files. The files are considered" << '\n'
+              << "to match if all their objects are identical except that, if a stream is" << '\n'
+              << "compressed with FlateDecode, the uncompressed data must match." << '\n'
+              << '\n'
+              << "If the files match, the output is the expected file. Otherwise, it is" << '\n'
+              << "the actual file. Read comments in the code for rationale." << '\n';
     exit(2);
 }
  
@@ -187,7 +183,7 @@ main(int argc, char* argv[])
     }
  
     if ((argc == 2) && (strcmp(argv[1], "--version") == 0)) {
-        std::cout << whoami << " from qpdf version " << QPDF::QPDFVersion() << std::endl;
+        std::cout << whoami << " from qpdf version " << QPDF::QPDFVersion() << '\n';
         exit(0);
     }
  
@@ -211,7 +207,7 @@ main(int argc, char* argv[])
             to_output = expected;
         } else {
             if (show_why) {
-                std::cerr << difference << std::endl;
+                std::cerr << difference << '\n';
                 exit(2);
             }
             // The files differ; write the actual file. If it is determined that the actual file
@@ -237,7 +233,7 @@ main(int argc, char* argv[])
             exit(2);
         }
     } catch (std::exception& e) {
-        std::cerr << whoami << ": " << e.what() << std::endl;
+        std::cerr << whoami << ": " << e.what() << '\n';
         exit(2);
     }
     return 0;
@@ -19,15 +19,15 @@ static char const* whoami = nullptr;
 static void
 usage(std::string const& msg)
 {
-    std::cerr << msg << std::endl
-              << std::endl
-              << "Usage: " << whoami << " options" << std::endl
-              << "Options:" << std::endl
-              << " --infile infile.pdf" << std::endl
-              << " --outfile outfile.pdf" << std::endl
-              << " --attachment attachment" << std::endl
-              << " [--password infile-password]" << std::endl
-              << " [--mimetype attachment mime type]" << std::endl;
+    std::cerr << msg << '\n'
+              << '\n'
+              << "Usage: " << whoami << " options\n"
+              << "Options:\n"
+              << " --infile infile.pdf\n"
+              << " --outfile outfile.pdf\n"
+              << " --attachment attachment\n"
+              << " [--password infile-password]\n"
+              << " [--mimetype attachment mime type]\n";
     exit(2);
 }
  
@@ -69,7 +69,7 @@ process(
  
     // Create a file spec.
     std::string key = QUtil::path_basename(attachment);
-    std::cout << whoami << ": attaching " << attachment << " as " << key << std::endl;
+    std::cout << whoami << ": attaching " << attachment << " as " << key << '\n';
     auto fs = QPDFFileSpecObjectHelper::createFileSpec(q, key, attachment);
  
     if (mimetype) {
@@ -208,7 +208,7 @@ main(int argc, char* argv[])
     try {
         process(infilename, password, attachment, mimetype, outfilename);
     } catch (std::exception& e) {
-        std::cerr << whoami << " exception: " << e.what() << std::endl;
+        std::cerr << whoami << " exception: " << e.what() << '\n';
         exit(2);
     }
  
@@ -23,12 +23,12 @@ static std::map&lt;QPDFObjGen, int&gt; page_map;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " [options] file.pdf [password]" << std::endl
-              << "Options:" << std::endl
-              << "  --numbers        give bookmarks outline-style numbers" << std::endl
-              << "  --lines          draw lines to show bookmark hierarchy" << std::endl
-              << "  --show-open      indicate whether a bookmark is initially open" << std::endl
-              << "  --show-targets   show target if possible" << std::endl;
+    std::cerr << "Usage: " << whoami << " [options] file.pdf [password]\n"
+              << "Options:\n"
+              << "  --numbers        give bookmarks outline-style numbers\n"
+              << "  --lines          draw lines to show bookmark hierarchy\n"
+              << "  --show-open      indicate whether a bookmark is initially open\n"
+              << "  --show-targets   show target if possible\n";
     exit(2);
 }
  
@@ -74,7 +74,7 @@ show_bookmark_details(QPDFOutlineObjectHelper outline, std::vector&lt;int&gt; numbers)
     case st_lines:
         QTC::TC("examples", "pdf-bookmarks lines");
         print_lines(numbers);
-        std::cout << "|" << std::endl;
+        std::cout << "|\n";
         print_lines(numbers);
         std::cout << "+-+ ";
         break;
@@ -104,7 +104,7 @@ show_bookmark_details(QPDFOutlineObjectHelper outline, std::vector&lt;int&gt; numbers)
         QPDFObjectHandle dest_page = outline.getDestPage();
         if (!dest_page.isNull()) {
             QTC::TC("examples", "pdf-bookmarks dest");
-            if (page_map.count(dest_page)) {
+            if (page_map.contains(dest_page)) {
                 target = std::to_string(page_map[dest_page]);
             }
         }
@@ -136,7 +136,7 @@ main(int argc, char* argv[])
     whoami = QUtil::getWhoami(argv[0]);
  
     if ((argc == 2) && (strcmp(argv[1], "--version") == 0)) {
-        std::cout << whoami << " version 1.5" << std::endl;
+        std::cout << whoami << " version 1.5\n";
         exit(0);
     }
  
@@ -185,10 +185,10 @@ main(int argc, char* argv[])
             }
             extract_bookmarks(odh.getTopLevelOutlines(), numbers);
         } else {
-            std::cout << filename << " has no bookmarks" << std::endl;
+            std::cout << filename << " has no bookmarks\n";
         }
     } catch (std::exception& e) {
-        std::cerr << whoami << " processing file " << filename << ": " << e.what() << std::endl;
+        std::cerr << whoami << " processing file " << filename << ": " << e.what() << '\n';
         exit(2);
     }
  
@@ -18,8 +18,8 @@ static char const* whoami = nullptr;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " infile" << std::endl
-              << "Applies token filters to infile" << std::endl;
+    std::cerr << "Usage: " << whoami << " infile\n"
+              << "Applies token filters to infile\n";
     exit(2);
 }
  
@@ -88,14 +88,14 @@ main(int argc, char* argv[])
             } else {
                 // Write output to stdout for even pages.
                 Pl_StdioFile out("stdout", stdout);
-                std::cout << "% Contents of page " << pageno << std::endl;
+                std::cout << "% Contents of page " << pageno << '\n';
                 page.filterContents(&counter, &out);
-                std::cout << "\n% end " << pageno << std::endl;
+                std::cout << "\n% end " << pageno << '\n';
             }
-            std::cout << "Page " << pageno << ": strings = " << counter.getCount() << std::endl;
+            std::cout << "Page " << pageno << ": strings = " << counter.getCount() << '\n';
         }
     } catch (std::exception& e) {
-        std::cerr << whoami << ": " << e.what() << std::endl;
+        std::cerr << whoami << ": " << e.what() << '\n';
         exit(2);
     }
  
@@ -117,8 +117,8 @@ ImageProvider::provideStreamData(QPDFObjGen const&amp;, Pipeline* pipeline)
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " filename" << std::endl
-              << "Creates a simple PDF and writes it to filename" << std::endl;
+    std::cerr << "Usage: " << whoami << " filename\n"
+              << "Creates a simple PDF and writes it to filename\n";
     exit(2);
 }
  
@@ -257,12 +257,12 @@ check(
         if (!filter.isNameAndEquals(desired_filter)) {
             this_errors = errors = true;
             std::cout << "page " << pageno << ": expected filter " << desired_filter
-                      << "; actual filter = " << filter.unparse() << std::endl;
+                      << "; actual filter = " << filter.unparse() << '\n';
         }
         if (!color_space.isNameAndEquals(desired_color_space)) {
             this_errors = errors = true;
             std::cout << "page " << pageno << ": expected color space " << desired_color_space
-                      << "; actual color space = " << color_space.unparse() << std::endl;
+                      << "; actual color space = " << color_space.unparse() << '\n';
         }
  
         if (!this_errors) {
@@ -275,7 +275,7 @@ check(
             std::shared_ptr<Buffer> desired_data(b_p.getBuffer());
  
             if (desired_data->getSize() != actual_data->getSize()) {
-                std::cout << "page " << pageno << ": image data length mismatch" << std::endl;
+                std::cout << "page " << pageno << ": image data length mismatch\n";
                 this_errors = errors = true;
             } else {
                 // Compare bytes. For JPEG, allow a certain number of the bytes to be off desired by
@@ -297,7 +297,7 @@ check(
                 if (mismatches > threshold) {
                     std::cout << "page " << pageno << ": " << desired_color_space << ", "
                               << desired_filter << ": mismatches: " << mismatches << " of " << len
-                              << std::endl;
+                              << '\n';
                     this_errors = errors = true;
                 }
             }
@@ -308,7 +308,7 @@ check(
     if (errors) {
         throw std::logic_error("errors found");
     } else {
-        std::cout << "all checks passed" << std::endl;
+        std::cout << "all checks passed\n";
     }
 }
  
@@ -366,7 +366,7 @@ main(int argc, char* argv[])
     try {
         create_pdf(filename);
     } catch (std::exception& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
         exit(2);
     }
  
@@ -116,7 +116,7 @@ SF_XORDecode::setDecodeParms(QPDFObjectHandle decode_parms)
         this->key = buf->getBuffer()[0];
         return true;
     } catch (std::exception& e) {
-        std::cerr << "Error extracting key for /XORDecode: " << e.what() << std::endl;
+        std::cerr << "Error extracting key for /XORDecode: " << e.what() << '\n';
     }
     return false;
 }
@@ -276,7 +276,7 @@ StreamReplacer::registerStream(
     // We don't need to process a stream more than once. In this example, we are just iterating
     // through objects, but if we were doing something like iterating through images on pages, we
     // might realistically encounter the same stream more than once.
-    if (this->copied_streams.count(og) > 0) {
+    if (this->copied_streams.contains(og)) {
         return;
     }
     // Store something in copied_streams so that we don't double-process even in the negative case.
@@ -361,15 +361,13 @@ process(char const* infilename, char const* outfilename, bool decode_specialized
     // For the test suite, use static IDs.
     w.setStaticID(true); // for testing only
     w.write();
-    std::cout << whoami << ": new file written to " << outfilename << std::endl;
+    std::cout << whoami << ": new file written to " << outfilename << '\n';
 }
  
 static void
 usage()
 {
-    std::cerr << "\n"
-              << "Usage: " << whoami << " [--decode-specialized] infile outfile\n"
-              << std::endl;
+    std::cerr << '\n' << "Usage: " << whoami << " [--decode-specialized] infile outfile\n" << '\n';
     exit(2);
 }
  
@@ -404,7 +402,7 @@ main(int argc, char* argv[])
         // Do the actual processing.
         process(infilename, outfilename, decode_specialized);
     } catch (std::exception& e) {
-        std::cerr << whoami << ": exception: " << e.what() << std::endl;
+        std::cerr << whoami << ": exception: " << e.what() << '\n';
         exit(2);
     }
  
@@ -13,8 +13,8 @@ static char const* whoami = nullptr;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " infile.pdf outfile.pdf [in-password]" << std::endl
-              << "Double size of all pages in infile.pdf; write output to outfile.pdf" << std::endl;
+    std::cerr << "Usage: " << whoami << " infile.pdf outfile.pdf [in-password]\n"
+              << "Double size of all pages in infile.pdf; write output to outfile.pdf\n";
     exit(2);
 }
  
@@ -87,9 +87,9 @@ main(int argc, char* argv[])
             w.setStreamDataMode(qpdf_s_uncompress);
         }
         w.write();
-        std::cout << whoami << ": new file written to " << outfilename << std::endl;
+        std::cout << whoami << ": new file written to " << outfilename << '\n';
     } catch (std::exception& e) {
-        std::cerr << whoami << " processing file " << infilename << ": " << e.what() << std::endl;
+        std::cerr << whoami << " processing file " << infilename << ": " << e.what() << '\n';
         exit(2);
     }
  
@@ -20,8 +20,8 @@ static char const* whoami = nullptr;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " infile outfile" << std::endl
-              << "Applies token filters to infile and writes outfile" << std::endl;
+    std::cerr << "Usage: " << whoami << " infile outfile\n"
+              << "Applies token filters to infile and writes outfile\n";
     exit(2);
 }
  
@@ -184,7 +184,7 @@ main(int argc, char* argv[])
         w.setQDFMode(true);
         w.write();
     } catch (std::exception& e) {
-        std::cerr << whoami << ": " << e.what() << std::endl;
+        std::cerr << whoami << ": " << e.what() << '\n';
         exit(2);
     }
  
@@ -14,8 +14,8 @@ static char const* whoami = nullptr;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " infile.pdf outfile.pdf [in-password]" << std::endl
-              << "Invert some images in infile.pdf; write output to outfile.pdf" << std::endl;
+    std::cerr << "Usage: " << whoami << " infile.pdf outfile.pdf [in-password]\n"
+              << "Invert some images in infile.pdf; write output to outfile.pdf\n";
     exit(2);
 }
  
@@ -52,7 +52,7 @@ ImageInverter::registerImage(
     // Store information about the images based on the object and generation number. Recall that a
     // single image object may be used more than once, so no need to update the same stream multiple
     // times.
-    if (this->copied_images.count(og) > 0) {
+    if (copied_images.contains(og)) {
         return;
     }
     this->copied_images[og] = image.copyStream();
@@ -137,9 +137,9 @@ main(int argc, char* argv[])
             w.setStaticID(true); // for testing only
         }
         w.write();
-        std::cout << whoami << ": new file written to " << outfilename << std::endl;
+        std::cout << whoami << ": new file written to " << outfilename << '\n';
     } catch (std::exception& e) {
-        std::cerr << whoami << " processing file " << infilename << ": " << e.what() << std::endl;
+        std::cerr << whoami << " processing file " << infilename << ": " << e.what() << '\n';
         exit(2);
     }
  
@@ -39,7 +39,7 @@ dumpInfoDict(QPDF&amp; pdf, std::ostream&amp; os = std::cout, std::string const&amp; sep = &quot;
             {
                 val = it.second.unparseResolved();
             }
-            os << it.first.substr(1) << sep << val << std::endl; // skip '/'
+            os << it.first.substr(1) << sep << val << '\n'; // skip '/'
         }
     }
 }
@@ -52,7 +52,7 @@ pdfDumpInfoDict(char const* fname)
         pdf.processFile(fname);
         dumpInfoDict(pdf);
     } catch (std::exception& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
         exit(2);
     }
 }
@@ -66,7 +66,7 @@ main(int argc, char* argv[])
     whoami = QUtil::getWhoami(argv[0]);
  
     if ((argc == 2) && (!strcmp(argv[1], "--version"))) {
-        std::cout << whoami << " version " << version << std::endl;
+        std::cout << whoami << " version " << version << '\n';
         exit(0);
     }
     if ((argc == 3) && (!strcmp(argv[1], "--dump"))) {
@@ -90,11 +90,11 @@ main(int argc, char* argv[])
         } else if ((!strcmp(argv[i], "--key")) && (++i < argc)) {
             QTC::TC("examples", "pdf-mod-info -key");
             cur_key = argv[i];
-            if (!((cur_key.length() > 0) && (cur_key.at(0) == '/'))) {
+            if (cur_key.empty() || cur_key.at(0) != '/') {
                 cur_key = "/" + cur_key;
             }
             Keys[cur_key] = "";
-        } else if ((!strcmp(argv[i], "--val")) && (++i < argc)) {
+        } else if (!strcmp(argv[i], "--val") && ++i < argc) {
             if (cur_key.empty()) {
                 QTC::TC("examples", "pdf-mod-info usage wrong val");
                 usage();
@@ -115,7 +115,7 @@ main(int argc, char* argv[])
         QTC::TC("examples", "pdf-mod-info in-place");
         fl_out = fl_in;
     }
-    if (Keys.size() == 0) {
+    if (Keys.empty()) {
         QTC::TC("examples", "pdf-mod-info no keys");
         usage();
     }
@@ -141,7 +141,7 @@ main(int argc, char* argv[])
                     filetrailer.replaceKey("/Info", fileinfo);
                 }
             }
-            if (it.second == "") {
+            if (it.second.empty()) {
                 fileinfo.removeKey(it.first);
             } else {
                 QPDFObjectHandle elt = fileinfo.newString(it.second);
@@ -155,7 +155,7 @@ main(int argc, char* argv[])
         w.setStaticID(static_id); // for testing only
         w.write();
     } catch (std::exception& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
         exit(2);
     }
  
@@ -164,7 +164,7 @@ main(int argc, char* argv[])
         QUtil::os_wrapper(
             "rename " + fl_tmp + " " + std::string(fl_out), rename(fl_tmp.c_str(), fl_out));
     } catch (std::exception& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
         exit(2);
     }
  
@@ -10,8 +10,8 @@ static char const* whoami = nullptr;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " outfile.pdf" << std::endl
-              << "Create some name/number trees and write to a file" << std::endl;
+    std::cerr << "Usage: " << whoami << " outfile.pdf" << '\n'
+              << "Create some name/number trees and write to a file\n";
     exit(2);
 }
  
@@ -57,64 +57,63 @@ main(int argc, char* argv[])
     name_tree.insert("N", QPDFObjectHandle::newUnicodeString("knight"));
     auto iter = name_tree.insert("P", QPDFObjectHandle::newUnicodeString("pawn"));
     // Look at the iterator
-    std::cout << "just inserted " << iter->first << " -> " << iter->second.unparse() << std::endl;
+    std::cout << "just inserted " << iter->first << " -> " << iter->second.unparse() << '\n';
     --iter;
-    std::cout << "predecessor: " << iter->first << " -> " << iter->second.unparse() << std::endl;
+    std::cout << "predecessor: " << iter->first << " -> " << iter->second.unparse() << '\n';
     ++iter;
     ++iter;
-    std::cout << "successor: " << iter->first << " -> " << iter->second.unparse() << std::endl;
+    std::cout << "successor: " << iter->first << " -> " << iter->second.unparse() << '\n';
  
     // Use range-for iteration
-    std::cout << "Name tree items:" << std::endl;
+    std::cout << "Name tree items:\n";
     for (auto i: name_tree) {
-        std::cout << "  " << i.first << " -> " << i.second.unparse() << std::endl;
+        std::cout << "  " << i.first << " -> " << i.second.unparse() << '\n';
     }
  
     // This is a small tree, so everything will be at the root. We can look at it using dictionary
     // and array iterators.
-    std::cout << "Keys in name tree object:" << std::endl;
+    std::cout << "Keys in name tree object:\n";
     QPDFObjectHandle names;
     for (auto const& i: name_tree_oh.ditems()) {
-        std::cout << i.first << std::endl;
+        std::cout << i.first << '\n';
         if (i.first == "/Names") {
             names = i.second;
         }
     }
     // Values in names array:
-    std::cout << "Values in names:" << std::endl;
+    std::cout << "Values in names:\n";
     for (auto& i: names.aitems()) {
-        std::cout << "  " << i.unparse() << std::endl;
+        std::cout << "  " << i.unparse() << '\n';
     }
  
     // pre 10.2 API
-    std::cout << "Has Q?: " << name_tree.hasName("Q") << std::endl;
-    std::cout << "Has W?: " << name_tree.hasName("W") << std::endl;
+    std::cout << "Has Q?: " << name_tree.hasName("Q") << '\n';
+    std::cout << "Has W?: " << name_tree.hasName("W") << '\n';
     QPDFObjectHandle obj;
-    std::cout << "Found W?: " << name_tree.findObject("W", obj) << std::endl;
-    std::cout << "Found Q?: " << name_tree.findObject("Q", obj) << std::endl;
-    std::cout << "Q: " << obj.unparse() << std::endl;
+    std::cout << "Found W?: " << name_tree.findObject("W", obj) << '\n';
+    std::cout << "Found Q?: " << name_tree.findObject("Q", obj) << '\n';
+    std::cout << "Q: " << obj.unparse() << '\n';
  
     // 10.2 API
     iter = name_tree.find("Q");
-    std::cout << "Q: " << iter->first << " -> " << iter->second.unparse() << std::endl;
+    std::cout << "Q: " << iter->first << " -> " << iter->second.unparse() << '\n';
     iter = name_tree.find("W");
-    std::cout << "W found: " << (iter != name_tree.end()) << std::endl;
+    std::cout << "W found: " << (iter != name_tree.end()) << '\n';
     // Allow find to return predecessor
     iter = name_tree.find("W", true);
-    std::cout << "W's predecessor: " << iter->first << " -> " << iter->second.unparse()
-              << std::endl;
+    std::cout << "W's predecessor: " << iter->first << " -> " << iter->second.unparse() << '\n';
  
     // We can also remove items
-    std::cout << "Remove P: " << name_tree.remove("P", &obj) << std::endl;
-    std::cout << "Value removed: " << obj.unparse() << std::endl;
-    std::cout << "Has P?: " << name_tree.hasName("P") << std::endl;
+    std::cout << "Remove P: " << name_tree.remove("P", &obj) << '\n';
+    std::cout << "Value removed: " << obj.unparse() << '\n';
+    std::cout << "Has P?: " << name_tree.hasName("P") << '\n';
     // Or we can remove using an iterator
     iter = name_tree.find("K");
-    std::cout << "Find K: " << iter->second.unparse() << std::endl;
+    std::cout << "Find K: " << iter->second.unparse() << '\n';
     iter.remove();
     std::cout << "Iter after removing K: " << iter->first << " -> " << iter->second.unparse()
-              << std::endl;
-    std::cout << "Has K?: " << name_tree.hasName("K") << std::endl;
+              << '\n';
+    std::cout << "Has K?: " << name_tree.hasName("K") << '\n';
  
     // Illustrate some more advanced usage using number trees. These calls work for name trees too.
  
@@ -129,14 +128,14 @@ main(int argc, char* argv[])
     for (int i = 7; i <= 350; i += 7) {
         iter2.insertAfter(i, QPDFObjectHandle::newString("-" + std::to_string(i) + "-"));
     }
-    std::cout << "Numbers:" << std::endl;
+    std::cout << "Numbers:\n";
     int n = 1;
     for (auto& i: number_tree) {
         std::cout << i.first << " -> " << i.second.getUTF8Value();
         if (n % 5) {
             std::cout << ", ";
         } else {
-            std::cout << std::endl;
+            std::cout << '\n';
         }
         ++n;
     }
@@ -151,14 +150,14 @@ main(int argc, char* argv[])
             ++iter2;
         }
     }
-    std::cout << "Numbers after filtering:" << std::endl;
+    std::cout << "Numbers after filtering:\n";
     n = 1;
     for (auto& i: number_tree) {
         std::cout << i.first << " -> " << i.second.getUTF8Value();
         if (n % 5) {
             std::cout << ", ";
         } else {
-            std::cout << std::endl;
+            std::cout << '\n';
         }
         ++n;
     }
@@ -10,8 +10,8 @@ static char const* whoami = nullptr;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " filename" << std::endl
-              << "Prints the number of pages in filename" << std::endl;
+    std::cerr << "Usage: " << whoami << " filename\n"
+              << "Prints the number of pages in filename\n";
     exit(2);
 }
  
@@ -21,7 +21,7 @@ main(int argc, char* argv[])
     whoami = QUtil::getWhoami(argv[0]);
  
     if ((argc == 2) && (strcmp(argv[1], "--version") == 0)) {
-        std::cout << whoami << " version 1.3" << std::endl;
+        std::cout << whoami << " version 1.3\n";
         exit(0);
     }
  
@@ -36,9 +36,9 @@ main(int argc, char* argv[])
         QPDFObjectHandle root = pdf.getRoot();
         QPDFObjectHandle pages = root.getKey("/Pages");
         QPDFObjectHandle count = pages.getKey("/Count");
-        std::cout << count.getIntValue() << std::endl;
+        std::cout << count.getIntValue() << '\n';
     } catch (std::exception& e) {
-        std::cerr << whoami << ": " << e.what() << std::endl;
+        std::cerr << whoami << ": " << e.what() << '\n';
         exit(2);
     }
  
@@ -15,9 +15,8 @@ static char const* whoami = nullptr;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " infile pagefile outfile" << std::endl
-              << "Stamp page 1 of pagefile on every page of infile, writing to outfile"
-              << std::endl;
+    std::cerr << "Usage: " << whoami << " infile pagefile outfile\n"
+              << "Stamp page 1 of pagefile on every page of infile, writing to outfile\n";
     exit(2);
 }
  
@@ -81,7 +80,7 @@ main(int argc, char* argv[])
     try {
         stamp_page(infile, stampfile, outfile);
     } catch (std::exception& e) {
-        std::cerr << whoami << ": " << e.what() << std::endl;
+        std::cerr << whoami << ": " << e.what() << '\n';
         exit(2);
     }
     return 0;
@@ -12,10 +12,10 @@ static char const* whoami = nullptr;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " filename page-number" << std::endl
-              << "Prints a dump of the objects in the content streams of the given page."
-              << std::endl
-              << "Pages are numbered from 1." << std::endl;
+    std::cerr << "Usage: " << whoami << " filename page-number\n"
+              << "Prints a dump of the objects in the content streams of the given page.\n"
+              << '\n'
+              << "Pages are numbered from 1.\n";
     exit(2);
 }
  
@@ -31,7 +31,7 @@ class ParserCallbacks: public QPDFObjectHandle::ParserCallbacks
 void
 ParserCallbacks::contentSize(size_t size)
 {
-    std::cout << "content size: " << size << std::endl;
+    std::cout << "content size: " << size << '\n';
 }
  
 void
@@ -39,16 +39,16 @@ ParserCallbacks::handleObject(QPDFObjectHandle obj, size_t offset, size_t length
 {
     std::cout << obj.getTypeName() << ", offset=" << offset << ", length=" << length << ": ";
     if (obj.isInlineImage()) {
-        std::cout << QUtil::hex_encode(obj.getInlineImageValue()) << std::endl;
+        std::cout << QUtil::hex_encode(obj.getInlineImageValue()) << '\n';
     } else {
-        std::cout << obj.unparse() << std::endl;
+        std::cout << obj.unparse() << '\n';
     }
 }
  
 void
 ParserCallbacks::handleEOF()
 {
-    std::cout << "-EOF-" << std::endl;
+    std::cout << "-EOF-\n";
 }
  
 int
@@ -74,7 +74,7 @@ main(int argc, char* argv[])
         ParserCallbacks cb;
         page.parseContents(&cb);
     } catch (std::exception& e) {
-        std::cerr << whoami << ": " << e.what() << std::endl;
+        std::cerr << whoami << ": " << e.what() << '\n';
         exit(2);
     }
  
@@ -11,8 +11,8 @@ static char const* whoami = nullptr;
 void
 usage()
 {
-    std::cerr << "Usage: " << whoami << " infile.pdf outfile.pdf value" << std::endl
-              << "Set the value of all text fields to a specified value" << std::endl;
+    std::cerr << "Usage: " << whoami << " infile.pdf outfile.pdf value\n"
+              << "Set the value of all text fields to a specified value\n";
     exit(2);
 }
  
@@ -68,7 +68,7 @@ main(int argc, char* argv[])
         w.setStaticID(true); // for testing only
         w.write();
     } catch (std::exception& e) {
-        std::cerr << whoami << " processing file " << infilename << ": " << e.what() << std::endl;
+        std::cerr << whoami << " processing file " << infilename << ": " << e.what() << '\n';
         exit(2);
     }
  
@@ -42,7 +42,7 @@ process(char const* whoami, char const* infile, std::string outprefix)
 void
 usage(char const* whoami)
 {
-    std::cerr << "Usage: " << whoami << " infile outprefix" << std::endl;
+    std::cerr << "Usage: " << whoami << " infile outprefix\n";
     exit(2);
 }
  
@@ -64,7 +64,7 @@ main(int argc, char* argv[])
     try {
         process(whoami, argv[1], argv[2]);
     } catch (std::exception const& e) {
-        std::cerr << whoami << ": exception: " << e.what() << std::endl;
+        std::cerr << whoami << ": exception: " << e.what() << '\n';
         return 2;
     }
     return 0;
@@ -10,11 +10,10 @@ static char const* whoami = nullptr;
 static void
 usage()
 {
-    std::cerr << "Usage: " << whoami << std::endl
+    std::cerr << "Usage: " << whoami << '\n'
               << "This program linearizes the first page of in.pdf to out1.pdf, out2.pdf, and"
-              << std::endl
-              << " out3.pdf, each demonstrating a different way to use the QPDFJob API"
-              << std::endl;
+              << '\n'
+              << " out3.pdf, each demonstrating a different way to use the QPDFJob API" << '\n';
     exit(2);
 }
  
@@ -49,9 +48,9 @@ main(int argc, char* argv[])
             ->compressStreams("n") // avoid dependency on zlib output
             ->checkConfiguration();
         j.run();
-        std::cout << "out1 status: " << j.getExitCode() << std::endl;
+        std::cout << "out1 status: " << j.getExitCode() << '\n';
     } catch (std::exception& e) {
-        std::cerr << "exception: " << e.what() << std::endl;
+        std::cerr << "exception: " << e.what() << '\n';
         return 2;
     }
  
@@ -71,9 +70,9 @@ main(int argc, char* argv[])
         QPDFJob j;
         j.initializeFromArgv(new_argv);
         j.run();
-        std::cout << "out2 status: " << j.getExitCode() << std::endl;
+        std::cout << "out2 status: " << j.getExitCode() << '\n';
     } catch (std::exception& e) {
-        std::cerr << "exception: " << e.what() << std::endl;
+        std::cerr << "exception: " << e.what() << '\n';
         return 2;
     }
  
@@ -95,9 +94,9 @@ main(int argc, char* argv[])
 }
 )");
         j.run();
-        std::cout << "out3 status: " << j.getExitCode() << std::endl;
+        std::cout << "out3 status: " << j.getExitCode() << '\n';
     } catch (std::exception& e) {
-        std::cerr << "exception: " << e.what() << std::endl;
+        std::cerr << "exception: " << e.what() << '\n';
         return 2;
     }
  
@@ -13,7 +13,7 @@ main(int argc, char* argv[])
     auto whoami = QUtil::getWhoami(argv[0]);
  
     if (argc != 4) {
-        std::cerr << "Usage: " << whoami << " file attachment-key outfile" << std::endl;
+        std::cerr << "Usage: " << whoami << " file attachment-key outfile" << '\n';
         exit(2);
     }
  
@@ -40,10 +40,10 @@ main(int argc, char* argv[])
         j.initializeFromArgv(j_argv);
         j.run();
     } catch (std::exception& e) {
-        std::cerr << whoami << ": " << e.what() << std::endl;
+        std::cerr << whoami << ": " << e.what() << '\n';
         exit(2);
     }
  
-    std::cout << whoami << ": wrote attachment to " << outfilename << std::endl;
+    std::cout << whoami << ": wrote attachment to " << outfilename << '\n';
     return 0;
 }
@@ -37,7 +37,7 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -49,7 +49,7 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -37,7 +37,7 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -37,7 +37,7 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -30,7 +30,7 @@ FuzzHelper::doChecks()
     try {
         JSON::parse(std::string(reinterpret_cast<char const*>(data), size));
     } catch (std::runtime_error& e) {
-        std::cerr << "runtime_error parsing json: " << e.what() << std::endl;
+        std::cerr << "runtime_error parsing json: " << e.what() << '\n';
     }
     QPDF q;
     q.setMaxWarnings(1000);
@@ -45,7 +45,7 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -37,7 +37,7 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -37,7 +37,7 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -76,9 +76,9 @@ FuzzHelper::doWrite(std::shared_ptr&lt;QPDFWriter&gt; w)
     try {
         w->write();
     } catch (QPDFExc const& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
     } catch (std::runtime_error const& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
     }
 }
  
@@ -135,9 +135,9 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (QPDFExc const& e) {
-        std::cerr << "QPDFExc: " << e.what() << std::endl;
+        std::cerr << "QPDFExc: " << e.what() << '\n';
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -75,9 +75,9 @@ FuzzHelper::doWrite(std::shared_ptr&lt;QPDFWriter&gt; w)
     try {
         w->write();
     } catch (QPDFExc const& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
     } catch (std::runtime_error const& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
     }
 }
  
@@ -135,9 +135,9 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (QPDFExc const& e) {
-        std::cerr << "QPDFExc: " << e.what() << std::endl;
+        std::cerr << "QPDFExc: " << e.what() << '\n';
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -75,9 +75,9 @@ FuzzHelper::doWrite(std::shared_ptr&lt;QPDFWriter&gt; w)
     try {
         w->write();
     } catch (QPDFExc const& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
     } catch (std::runtime_error const& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
     }
 }
  
@@ -133,9 +133,9 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (QPDFExc const& e) {
-        std::cerr << "QPDFExc: " << e.what() << std::endl;
+        std::cerr << "QPDFExc: " << e.what() << '\n';
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -75,9 +75,9 @@ FuzzHelper::doWrite(std::shared_ptr&lt;QPDFWriter&gt; w)
     try {
         w->write();
     } catch (QPDFExc const& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
     } catch (std::runtime_error const& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
     }
 }
  
@@ -134,9 +134,9 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (QPDFExc const& e) {
-        std::cerr << "QPDFExc: " << e.what() << std::endl;
+        std::cerr << "QPDFExc: " << e.what() << '\n';
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -111,9 +111,9 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (QPDFExc const& e) {
-        std::cerr << "QPDFExc: " << e.what() << std::endl;
+        std::cerr << "QPDFExc: " << e.what() << '\n';
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -132,9 +132,9 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (QPDFExc const& e) {
-        std::cerr << "QPDFExc: " << e.what() << std::endl;
+        std::cerr << "QPDFExc: " << e.what() << '\n';
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -38,7 +38,7 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -12,7 +12,7 @@ main(int argc, char** argv)
         size_t size = 0;
         QUtil::read_file_into_memory(argv[i], file_buf, size);
         LLVMFuzzerTestOneInput(reinterpret_cast<unsigned char*>(file_buf.get()), size);
-        std::cout << argv[i] << " successful" << std::endl;
+        std::cout << argv[i] << " successful" << '\n';
     }
     return 0;
 }
@@ -41,7 +41,7 @@ FuzzHelper::run()
     try {
         doChecks();
     } catch (std::runtime_error const& e) {
-        std::cerr << "runtime_error: " << e.what() << std::endl;
+        std::cerr << "runtime_error: " << e.what() << '\n';
     }
 }
  
@@ -69,9 +69,9 @@ class QPDF_DLL_CLASS ClosedFileInputSource: public InputSource
     void after();
  
     std::string filename;
-    qpdf_offset_t offset;
+    qpdf_offset_t offset{0};
     std::shared_ptr<FileInputSource> fis;
-    bool stay_open;
+    bool stay_open{false};
 };
  
 #endif // QPDF_CLOSEDFILEINPUTSOURCE_HH
@@ -234,10 +234,10 @@ class QPDFAcroFormDocumentHelper: public QPDFDocumentHelper
         ~Members() = default;
  
       private:
-        Members();
+        Members() = default;
         Members(Members const&) = delete;
  
-        bool cache_valid;
+        bool cache_valid{false};
         std::map<QPDFObjGen, std::vector<QPDFAnnotationObjectHelper>> field_to_annotations;
         std::map<QPDFObjGen, QPDFFormFieldObjectHelper> annotation_to_field;
         std::map<QPDFObjGen, std::string> field_to_name;
@@ -158,10 +158,11 @@ class QPDFJob
  
     struct PageSpec
     {
-        PageSpec(std::string const& filename, char const* password, std::string const& range);
+        PageSpec(
+            std::string const& filename, std::string const& password, std::string const& range);
  
         std::string filename;
-        std::shared_ptr<char> password;
+        std::string password;
         std::string range;
     };
  
@@ -450,7 +451,7 @@ class QPDFJob
  
         std::string which;
         std::string filename;
-        std::shared_ptr<char> password;
+        std::string password;
         std::string to_nr;
         std::string from_nr;
         std::string repeat_nr;
@@ -591,7 +592,7 @@ class QPDFJob
         bool warnings{false};
         unsigned long encryption_status{0};
         bool verbose{false};
-        std::shared_ptr<char> password;
+        std::string password;
         bool linearize{false};
         bool decrypt{false};
         bool remove_restrictions{false};
@@ -602,7 +603,7 @@ class QPDFJob
         bool warnings_exit_zero{false};
         bool copy_encryption{false};
         std::string encryption_file;
-        std::shared_ptr<char> encryption_file_password;
+        std::string encryption_file_password;
         bool encrypt{false};
         bool password_is_hex_key{false};
         bool suppress_password_recovery{false};
@@ -711,8 +712,9 @@ class QPDFJob
         bool replace_input{false};
         bool check_is_encrypted{false};
         bool check_requires_password{false};
-        std::shared_ptr<char> infilename;
-        std::shared_ptr<char> outfilename;
+        std::string infilename;
+        bool empty_input{false};
+        std::string outfilename;
         bool json_input{false};
         bool json_output{false};
         std::string update_from_json;
@@ -110,7 +110,7 @@ class QPDFObjGen
         add(QPDFObjGen og)
         {
             if (og.isIndirect()) {
-                if (count(og) > 0) {
+                if (count(og)) {
                     return false;
                 }
                 emplace(og);
@@ -17,8 +17,7 @@ AES_PDF_native::AES_PDF_native(
     unsigned char* cbc_block) :
     encrypt(encrypt),
     cbc_mode(cbc_mode),
-    cbc_block(cbc_block),
-    nrounds(0)
+    cbc_block(cbc_block)
 {
     size_t keybits = 8 * key_bytes;
     this->key = std::make_unique<unsigned char[]>(key_bytes);
@@ -5,9 +5,7 @@
 #include <qpdf/bits_functions.hh>
  
 BitWriter::BitWriter(Pipeline* pl) :
-    pl(pl),
-    ch(0),
-    bit_offset(7)
+    pl(pl)
 {
 }
  
@@ -3,9 +3,7 @@
 #include <qpdf/FileInputSource.hh>
  
 ClosedFileInputSource::ClosedFileInputSource(char const* filename) :
-    filename(filename),
-    offset(0),
-    stay_open(false)
+    filename(filename)
 {
 }
  
@@ -5,12 +5,6 @@
  
 using namespace qpdf;
  
-ContentNormalizer::ContentNormalizer() :
-    any_bad_tokens(false),
-    last_token_was_bad(false)
-{
-}
-
 void
 ContentNormalizer::handleToken(QPDFTokenizer::Token const& token)
 {
@@ -4,11 +4,6 @@
 #include <qpdf/qpdf-config.h>
 #include <cstdlib>
  
-InsecureRandomDataProvider::InsecureRandomDataProvider() :
-    seeded_random(false)
-{
-}
-
 void
 InsecureRandomDataProvider::provideRandomData(unsigned char* data, size_t len)
 {
@@ -490,24 +490,18 @@ JSON::checkSchemaInternal(
         }
     }
  
-    if (sch_dict && (!pattern_key.empty())) {
+    if (sch_dict && !pattern_key.empty()) {
         auto pattern_schema = sch_dict->members[pattern_key].m->value.get();
-        for (auto const& iter: this_dict->members) {
-            std::string const& key = iter.first;
+        for (auto const& [key, val]: this_dict->members) {
             checkSchemaInternal(
-                this_dict->members[key].m->value.get(),
-                pattern_schema,
-                flags,
-                errors,
-                prefix + "." + key);
+                val.m->value.get(), pattern_schema, flags, errors, prefix + "." + key);
         }
     } else if (sch_dict) {
-        for (auto& iter: sch_dict->members) {
-            std::string const& key = iter.first;
-            if (this_dict->members.count(key)) {
+        for (auto& [key, val]: sch_dict->members) {
+            if (this_dict->members.contains(key)) {
                 checkSchemaInternal(
                     this_dict->members[key].m->value.get(),
-                    iter.second.m->value.get(),
+                    val.m->value.get(),
                     flags,
                     errors,
                     prefix + "." + key);
@@ -516,18 +510,17 @@ JSON::checkSchemaInternal(
                     QTC::TC("libtests", "JSON optional key");
                 } else {
                     QTC::TC("libtests", "JSON key missing in object");
-                    errors.push_back(
+                    errors.emplace_back(
                         err_prefix + ": key \"" + key +
                         "\" is present in schema but missing in object");
                 }
             }
         }
-        for (auto const& iter: this_dict->members) {
-            std::string const& key = iter.first;
-            if (sch_dict->members.count(key) == 0) {
+        for (auto const& item: this_dict->members) {
+            if (!sch_dict->members.contains(item.first)) {
                 QTC::TC("libtests", "JSON key extra in object");
-                errors.push_back(
-                    err_prefix + ": key \"" + key +
+                errors.emplace_back(
+                    err_prefix + ": key \"" + item.first +
                     "\" is not present in schema but appears in object");
             }
         }
@@ -554,9 +547,9 @@ JSON::checkSchemaInternal(
                 checkSchemaInternal(
                     this_v, sch_arr->elements.at(0).m->value.get(), flags, errors, prefix);
             }
-        } else if (!this_arr || (this_arr->elements.size() != n_elements)) {
+        } else if (!this_arr || this_arr->elements.size() != n_elements) {
             QTC::TC("libtests", "JSON schema array length mismatch");
-            errors.push_back(
+            errors.emplace_back(
                 err_prefix + " is supposed to be an array of length " + std::to_string(n_elements));
             return false;
         } else {
@@ -576,7 +569,7 @@ JSON::checkSchemaInternal(
         }
     } else if (!sch_str) {
         QTC::TC("libtests", "JSON schema other type");
-        errors.push_back(err_prefix + " schema value is not dictionary, array, or string");
+        errors.emplace_back(err_prefix + " schema value is not dictionary, array, or string");
         return false;
     }
  
@@ -28,8 +28,7 @@ error(QPDF&amp; qpdf, QPDFObjectHandle&amp; node, std::string const&amp; msg)
 }
  
 NNTreeIterator::NNTreeIterator(NNTreeImpl& impl) :
-    impl(impl),
-    item_number(-1)
+    impl(impl)
 {
 }
  
@@ -666,7 +665,6 @@ NNTreeImpl::NNTreeImpl(
     NNTreeDetails const& details, QPDF& qpdf, QPDFObjectHandle& oh, bool auto_repair) :
     details(details),
     qpdf(qpdf),
-    split_threshold(32),
     oh(oh),
     auto_repair(auto_repair)
 {
@@ -29,7 +29,7 @@ Pl_Flate::Members::Members(size_t out_bufsize, action_e action) :
     // Indirect through zdata to reach the z_stream so we don't have to include zlib.h in
     // Pl_Flate.hh.  This means people using shared library versions of qpdf don't have to have zlib
     // development files available, which particularly helps in a Windows environment.
-    this->zdata = new z_stream;
+    zdata = new z_stream;
  
     if (out_bufsize > UINT_MAX) {
         throw std::runtime_error(
@@ -52,8 +52,8 @@ Pl_Flate::Members::Members(size_t out_bufsize, action_e action) :
  
 Pl_Flate::Members::~Members()
 {
-    if (this->initialized) {
-        z_stream& zstream = *(static_cast<z_stream*>(this->zdata));
+    if (initialized) {
+        z_stream& zstream = *(static_cast<z_stream*>(zdata));
         if (action == a_deflate) {
             deflateEnd(&zstream);
         } else {
@@ -62,7 +62,7 @@ Pl_Flate::Members::~Members()
     }
  
     delete static_cast<z_stream*>(this->zdata);
-    this->zdata = nullptr;
+    zdata = nullptr;
 }
  
 Pl_Flate::Pl_Flate(
@@ -99,7 +99,7 @@ Pl_Flate::setWarnCallback(std::function&lt;void(char const*, int)&gt; callback)
 void
 Pl_Flate::warn(char const* msg, int code)
 {
-    if (m->callback != nullptr) {
+    if (m->callback) {
         m->callback(msg, code);
     }
 }
@@ -107,7 +107,7 @@ Pl_Flate::warn(char const* msg, int code)
 void
 Pl_Flate::write(unsigned char const* data, size_t len)
 {
-    if (m->outbuf == nullptr) {
+    if (!m->outbuf) {
         throw std::logic_error(
             this->identifier + ": Pl_Flate: write() called after finish() called");
     }
@@ -184,7 +184,7 @@ Pl_Flate::handleData(unsigned char const* data, size_t len, int flush)
             // this error (including at least one in qpdf's test suite). In some cases, we want to
             // know about this, because it indicates incorrect compression, so call a callback if
             // provided.
-            this->warn("input stream is complete but output may still be valid", err);
+            warn("input stream is complete but output may still be valid", err);
             done = true;
             break;
  
@@ -215,7 +215,7 @@ Pl_Flate::handleData(unsigned char const* data, size_t len, int flush)
             break;
  
         default:
-            this->checkError("data", err);
+            checkError("data", err);
             break;
         }
     }
@@ -271,7 +271,7 @@ Pl_Flate::checkError(char const* prefix, int error_code)
     z_stream& zstream = *(static_cast<z_stream*>(m->zdata));
     if (error_code != Z_OK) {
         char const* action_str = (m->action == a_deflate ? "deflate" : "inflate");
-        std::string msg = this->identifier + ": " + action_str + ": " + prefix + ": ";
+        std::string msg = identifier + ": " + action_str + ": " + prefix + ": ";
  
         if (zstream.msg) {
             msg += zstream.msg;
@@ -39,7 +39,7 @@ Pl_PNGFilter::Pl_PNGFilter(
         throw std::runtime_error(
             "PNGFilter created with invalid bits_per_sample not 1, 2, 4, 8, or 16");
     }
-    this->bytes_per_pixel = ((bits_per_sample * samples_per_pixel) + 7) / 8;
+    bytes_per_pixel = ((bits_per_sample * samples_per_pixel) + 7) / 8;
     unsigned long long bpr = ((columns * bits_per_sample * samples_per_pixel) + 7) / 8;
     if ((bpr == 0) || (bpr > (UINT_MAX - 1))) {
         throw std::runtime_error("PNGFilter created with invalid columns value");
@@ -47,16 +47,16 @@ Pl_PNGFilter::Pl_PNGFilter(
     if (memory_limit > 0 && bpr > (memory_limit / 2U)) {
         throw std::runtime_error("PNGFilter memory limit exceeded");
     }
-    this->bytes_per_row = bpr & UINT_MAX;
-    this->buf1 = QUtil::make_shared_array<unsigned char>(this->bytes_per_row + 1);
-    this->buf2 = QUtil::make_shared_array<unsigned char>(this->bytes_per_row + 1);
-    memset(this->buf1.get(), 0, this->bytes_per_row + 1);
-    memset(this->buf2.get(), 0, this->bytes_per_row + 1);
-    this->cur_row = this->buf1.get();
-    this->prev_row = this->buf2.get();
+    bytes_per_row = bpr & UINT_MAX;
+    buf1 = QUtil::make_shared_array<unsigned char>(bytes_per_row + 1);
+    buf2 = QUtil::make_shared_array<unsigned char>(bytes_per_row + 1);
+    memset(buf1.get(), 0, bytes_per_row + 1);
+    memset(buf2.get(), 0, bytes_per_row + 1);
+    cur_row = buf1.get();
+    prev_row = buf2.get();
  
     // number of bytes per incoming row
-    this->incoming = (action == a_encode ? this->bytes_per_row : this->bytes_per_row + 1);
+    incoming = (action == a_encode ? bytes_per_row : bytes_per_row + 1);
 }
  
 void
@@ -68,34 +68,34 @@ Pl_PNGFilter::setMemoryLimit(unsigned long long limit)
 void
 Pl_PNGFilter::write(unsigned char const* data, size_t len)
 {
-    size_t left = this->incoming - this->pos;
+    size_t left = incoming - pos;
     size_t offset = 0;
     while (len >= left) {
         // finish off current row
-        memcpy(this->cur_row + this->pos, data + offset, left);
+        memcpy(cur_row + pos, data + offset, left);
         offset += left;
         len -= left;
  
         processRow();
  
         // Swap rows
-        unsigned char* t = this->prev_row;
-        this->prev_row = this->cur_row;
-        this->cur_row = t ? t : this->buf2.get();
-        memset(this->cur_row, 0, this->bytes_per_row + 1);
-        left = this->incoming;
-        this->pos = 0;
+        unsigned char* t = prev_row;
+        prev_row = cur_row;
+        cur_row = t ? t : buf2.get();
+        memset(cur_row, 0, bytes_per_row + 1);
+        left = incoming;
+        pos = 0;
     }
     if (len) {
-        memcpy(this->cur_row + this->pos, data + offset, len);
+        memcpy(cur_row + pos, data + offset, len);
     }
-    this->pos += len;
+    pos += len;
 }
  
 void
 Pl_PNGFilter::processRow()
 {
-    if (this->action == a_encode) {
+    if (action == a_encode) {
         encodeRow();
     } else {
         decodeRow();
@@ -105,22 +105,22 @@ Pl_PNGFilter::processRow()
 void
 Pl_PNGFilter::decodeRow()
 {
-    int filter = this->cur_row[0];
-    if (this->prev_row) {
+    int filter = cur_row[0];
+    if (prev_row) {
         switch (filter) {
         case 0:
             break;
         case 1:
-            this->decodeSub();
+            decodeSub();
             break;
         case 2:
-            this->decodeUp();
+            decodeUp();
             break;
         case 3:
-            this->decodeAverage();
+            decodeAverage();
             break;
         case 4:
-            this->decodePaeth();
+            decodePaeth();
             break;
         default:
             // ignore
@@ -128,17 +128,17 @@ Pl_PNGFilter::decodeRow()
         }
     }
  
-    next()->write(this->cur_row + 1, this->bytes_per_row);
+    next()->write(cur_row + 1, bytes_per_row);
 }
  
 void
 Pl_PNGFilter::decodeSub()
 {
     QTC::TC("libtests", "Pl_PNGFilter decodeSub");
-    unsigned char* buffer = this->cur_row + 1;
-    unsigned int bpp = this->bytes_per_pixel;
+    unsigned char* buffer = cur_row + 1;
+    unsigned int bpp = bytes_per_pixel;
  
-    for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
+    for (unsigned int i = 0; i < bytes_per_row; ++i) {
         unsigned char left = 0;
  
         if (i >= bpp) {
@@ -153,10 +153,10 @@ void
 Pl_PNGFilter::decodeUp()
 {
     QTC::TC("libtests", "Pl_PNGFilter decodeUp");
-    unsigned char* buffer = this->cur_row + 1;
-    unsigned char* above_buffer = this->prev_row + 1;
+    unsigned char* buffer = cur_row + 1;
+    unsigned char* above_buffer = prev_row + 1;
  
-    for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
+    for (unsigned int i = 0; i < bytes_per_row; ++i) {
         unsigned char up = above_buffer[i];
         buffer[i] = static_cast<unsigned char>(buffer[i] + up);
     }
@@ -166,11 +166,11 @@ void
 Pl_PNGFilter::decodeAverage()
 {
     QTC::TC("libtests", "Pl_PNGFilter decodeAverage");
-    unsigned char* buffer = this->cur_row + 1;
-    unsigned char* above_buffer = this->prev_row + 1;
-    unsigned int bpp = this->bytes_per_pixel;
+    unsigned char* buffer = cur_row + 1;
+    unsigned char* above_buffer = prev_row + 1;
+    unsigned int bpp = bytes_per_pixel;
  
-    for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
+    for (unsigned int i = 0; i < bytes_per_row; ++i) {
         int left = 0;
         int up = 0;
  
@@ -187,11 +187,11 @@ void
 Pl_PNGFilter::decodePaeth()
 {
     QTC::TC("libtests", "Pl_PNGFilter decodePaeth");
-    unsigned char* buffer = this->cur_row + 1;
-    unsigned char* above_buffer = this->prev_row + 1;
-    unsigned int bpp = this->bytes_per_pixel;
+    unsigned char* buffer = cur_row + 1;
+    unsigned char* above_buffer = prev_row + 1;
+    unsigned int bpp = bytes_per_pixel;
  
-    for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
+    for (unsigned int i = 0; i < bytes_per_row; ++i) {
         int left = 0;
         int up = above_buffer[i];
         int upper_left = 0;
@@ -201,8 +201,7 @@ Pl_PNGFilter::decodePaeth()
             upper_left = above_buffer[i - bpp];
         }
  
-        buffer[i] =
-            static_cast<unsigned char>(buffer[i] + this->PaethPredictor(left, up, upper_left));
+        buffer[i] = static_cast<unsigned char>(buffer[i] + PaethPredictor(left, up, upper_left));
     }
 }
  
@@ -229,27 +228,27 @@ Pl_PNGFilter::encodeRow()
     // For now, hard-code to using UP filter.
     unsigned char ch = 2;
     next()->write(&ch, 1);
-    if (this->prev_row) {
-        for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
-            ch = static_cast<unsigned char>(this->cur_row[i] - this->prev_row[i]);
+    if (prev_row) {
+        for (unsigned int i = 0; i < bytes_per_row; ++i) {
+            ch = static_cast<unsigned char>(cur_row[i] - prev_row[i]);
             next()->write(&ch, 1);
         }
     } else {
-        next()->write(this->cur_row, this->bytes_per_row);
+        next()->write(cur_row, bytes_per_row);
     }
 }
  
 void
 Pl_PNGFilter::finish()
 {
-    if (this->pos) {
+    if (pos) {
         // write partial row
         processRow();
     }
-    this->prev_row = nullptr;
-    this->cur_row = buf1.get();
-    this->pos = 0;
-    memset(this->cur_row, 0, this->bytes_per_row + 1);
+    prev_row = nullptr;
+    cur_row = buf1.get();
+    pos = 0;
+    memset(cur_row, 0, bytes_per_row + 1);
  
     next()->finish();
 }
@@ -5,8 +5,7 @@
 #include <stdexcept>
  
 Pl_SHA2::Pl_SHA2(int bits, Pipeline* next) :
-    Pipeline("sha2", next),
-    in_progress(false)
+    Pipeline("sha2", next)
 {
     if (bits) {
         resetBits(bits);
@@ -564,7 +564,7 @@ QPDF::copyForeignObject(QPDFObjectHandle foreign)
     obj_copier.to_copy.clear();
  
     auto og = foreign.getObjGen();
-    if (!obj_copier.object_map.count(og)) {
+    if (!obj_copier.object_map.contains(og)) {
         warn(damagedPDF(
             other.getFilename() + " object " + og.unparse(' '),
             foreign.getParsedOffset(),
@@ -594,7 +594,7 @@ QPDF::reserveObjects(QPDFObjectHandle foreign, ObjCopier&amp; obj_copier, bool top)
             QTC::TC("qpdf", "QPDF loop reserving objects");
             return;
         }
-        if (obj_copier.object_map.count(foreign_og) > 0) {
+        if (obj_copier.object_map.contains(foreign_og)) {
             QTC::TC("qpdf", "QPDF already reserved object");
             if (!(top && foreign.isPageObject() && obj_copier.object_map[foreign_og].isNull())) {
                 obj_copier.visiting.erase(foreign);
@@ -9,11 +9,6 @@
  
 using namespace qpdf;
  
-QPDFAcroFormDocumentHelper::Members::Members() :
-    cache_valid(false)
-{
-}
-
 QPDFAcroFormDocumentHelper::QPDFAcroFormDocumentHelper(QPDF& qpdf) :
     QPDFDocumentHelper(qpdf),
     m(new Members())
@@ -85,7 +80,7 @@ QPDFAcroFormDocumentHelper::addAndRenameFormFields(std::vector&lt;QPDFObjectHandle&gt;
                 // this field's /T is always at the end of the fully qualified name, appending to /T
                 // has the effect of appending the same thing to the fully qualified name.
                 std::string old_name = QPDFFormFieldObjectHelper(obj).getFullyQualifiedName();
-                if (renames.count(old_name) == 0) {
+                if (!renames.contains(old_name)) {
                     std::string new_name = old_name;
                     int suffix = 0;
                     std::string append;
@@ -145,7 +140,7 @@ QPDFAcroFormDocumentHelper::removeFormFields(std::set&lt;QPDFObjGen&gt; const&amp; to_remo
     int i = 0;
     while (i < fields.getArrayNItems()) {
         auto field = fields.getArrayItem(i);
-        if (to_remove.count(field.getObjGen())) {
+        if (to_remove.contains(field.getObjGen())) {
             fields.eraseItem(i);
         } else {
             ++i;
@@ -191,7 +186,7 @@ QPDFAcroFormDocumentHelper::getAnnotationsForField(QPDFFormFieldObjectHelper h)
     analyze();
     std::vector<QPDFAnnotationObjectHelper> result;
     QPDFObjGen og(h.getObjectHandle().getObjGen());
-    if (m->field_to_annotations.count(og)) {
+    if (m->field_to_annotations.contains(og)) {
         result = m->field_to_annotations[og];
     }
     return result;
@@ -228,7 +223,7 @@ QPDFAcroFormDocumentHelper::getFieldForAnnotation(QPDFAnnotationObjectHelper h)
     }
     analyze();
     QPDFObjGen og(oh.getObjGen());
-    if (m->annotation_to_field.count(og)) {
+    if (m->annotation_to_field.contains(og)) {
         result = m->annotation_to_field[og];
     }
     return result;
@@ -271,7 +266,7 @@ QPDFAcroFormDocumentHelper::analyze()
         for (auto const& iter: getWidgetAnnotationsForPage(ph)) {
             QPDFObjectHandle annot(iter.getObjectHandle());
             QPDFObjGen og(annot.getObjGen());
-            if (m->annotation_to_field.count(og) == 0) {
+            if (!m->annotation_to_field.contains(og)) {
                 QTC::TC("qpdf", "QPDFAcroFormDocumentHelper orphaned widget");
                 // This is not supposed to happen, but it's easy enough for us to handle this case.
                 // Treat the annotation as its own field. This could allow qpdf to sensibly handle a
@@ -542,7 +537,7 @@ ResourceReplacer::handleToken(QPDFTokenizer::Token const&amp; token)
     bool wrote = false;
     if (token.getType() == QPDFTokenizer::tt_name) {
         std::string name = QPDFObjectHandle::newName(token.getValue()).getName();
-        if (to_replace.count(name) && to_replace[name].count(offset)) {
+        if (to_replace.contains(name) && to_replace[name].contains(offset)) {
             QTC::TC("qpdf", "QPDFAcroFormDocumentHelper replaced DA token");
             write(to_replace[name][offset]);
             wrote = true;
@@ -675,7 +670,7 @@ QPDFAcroFormDocumentHelper::adjustAppearanceStream(
     resources.mergeResources(merge_with, &dr_map);
     // Remove empty subdictionaries
     for (auto iter: resources.ditems()) {
-        if (iter.second.isDictionary() && (iter.second.getKeys().size() == 0)) {
+        if (iter.second.isDictionary() && iter.second.getKeys().empty()) {
             resources.removeKey(iter.first);
         }
     }
@@ -807,7 +802,7 @@ QPDFAcroFormDocumentHelper::transformAnnotations(
     std::map<QPDFObjGen, QPDFObjectHandle> orig_to_copy;
     auto maybe_copy_object = [&](QPDFObjectHandle& to_copy) {
         auto og = to_copy.getObjGen();
-        if (orig_to_copy.count(og)) {
+        if (orig_to_copy.contains(og)) {
             to_copy = orig_to_copy[og];
             return false;
         } else {
@@ -893,7 +888,7 @@ QPDFAcroFormDocumentHelper::transformAnnotations(
                     auto parent = obj.getKey("/Parent");
                     if (parent.isIndirect()) {
                         auto parent_og = parent.getObjGen();
-                        if (orig_to_copy.count(parent_og)) {
+                        if (orig_to_copy.contains(parent_og)) {
                             obj.replaceKey("/Parent", orig_to_copy[parent_og]);
                         } else {
                             parent.warnIfPossible(
@@ -18,12 +18,7 @@ QPDFArgParser::Members::Members(int argc, char const* const argv[], char const* 
  
     argc(argc),
     argv(argv),
-    progname_env(progname_env),
-    cur_arg(0),
-    bash_completion(false),
-    zsh_completion(false),
-    option_table(nullptr),
-    final_check_handler(nullptr)
+    progname_env(progname_env)
 {
     auto tmp = QUtil::make_unique_cstr(argv[0]);
     whoami = QUtil::getWhoami(tmp.get());
@@ -71,7 +66,7 @@ QPDFArgParser::selectOptionTable(std::string const&amp; name)
 void
 QPDFArgParser::registerOptionTable(std::string const& name, bare_arg_handler_t end_handler)
 {
-    if (0 != m->option_tables.count(name)) {
+    if (m->option_tables.contains(name)) {
         QTC::TC("libtests", "QPDFArgParser register registered table");
         throw std::logic_error(
             "QPDFArgParser: registering already registered option table " + name);
@@ -84,7 +79,7 @@ QPDFArgParser::registerOptionTable(std::string const&amp; name, bare_arg_handler_t e
 QPDFArgParser::OptionEntry&
 QPDFArgParser::registerArg(std::string const& arg)
 {
-    if (0 != m->option_table->count(arg)) {
+    if (m->option_table->contains(arg)) {
         QTC::TC("libtests", "QPDFArgParser duplicate handler");
         throw std::logic_error(
             "QPDFArgParser: adding a duplicate handler for option " + arg + " in " +
@@ -198,13 +193,13 @@ QPDFArgParser::completionCommon(bool zsh)
     if (!zsh) {
         std::cout << " -o nospace";
     }
-    std::cout << " -C \"" << progname << "\" " << m->whoami << std::endl;
+    std::cout << " -C \"" << progname << "\" " << m->whoami << '\n';
     // Put output before error so calling from zsh works properly
     std::string path = progname;
     size_t slash = path.find('/');
     if ((slash != 0) && (slash != std::string::npos)) {
         std::cerr << "WARNING: " << m->whoami << " completion enabled"
-                  << " using relative path to executable" << std::endl;
+                  << " using relative path to executable" << '\n';
     }
 }
  
@@ -239,7 +234,7 @@ QPDFArgParser::handleArgFileArguments()
     // Support reading arguments from files. Create a new argv. Ensure that argv itself as well as
     // all its contents are automatically deleted by using shared pointers back to the pointers in
     // argv.
-    m->new_argv.push_back(QUtil::make_shared_cstr(m->argv[0]));
+    m->new_argv.emplace_back(m->argv[0]);
     for (int i = 1; i < m->argc; ++i) {
         char const* argfile = nullptr;
         if ((strlen(m->argv[i]) > 1) && (m->argv[i][0] == '@')) {
@@ -254,16 +249,16 @@ QPDFArgParser::handleArgFileArguments()
         if (argfile) {
             readArgsFromFile(1 + m->argv[i]);
         } else {
-            m->new_argv.push_back(QUtil::make_shared_cstr(m->argv[i]));
+            m->new_argv.emplace_back(m->argv[i]);
         }
     }
-    m->argv_ph = QUtil::make_shared_array<char const*>(1 + m->new_argv.size());
-    for (size_t i = 0; i < m->new_argv.size(); ++i) {
-        m->argv_ph.get()[i] = m->new_argv.at(i).get();
+    m->argv_ph.reserve(1 + m->new_argv.size());
+    for (auto const& a: m->new_argv) {
+        m->argv_ph.push_back(a.data());
     }
     m->argc = QIntC::to_int(m->new_argv.size());
-    m->argv_ph.get()[m->argc] = nullptr;
-    m->argv = m->argv_ph.get();
+    m->argv_ph.push_back(nullptr);
+    m->argv = m->argv_ph.data();
 }
  
 void
@@ -290,7 +285,7 @@ QPDFArgParser::handleBashArguments()
             case st_top:
                 if (util::is_space(ch)) {
                     if (!arg.empty()) {
-                        m->bash_argv.push_back(QUtil::make_shared_cstr(arg));
+                        m->bash_argv.emplace_back(arg);
                         arg.clear();
                     }
                 } else if (ch == '"') {
@@ -326,16 +321,16 @@ QPDFArgParser::handleBashArguments()
     if (m->bash_argv.empty()) {
         // This can't happen if properly invoked by bash, but ensure we have a valid argv[0]
         // regardless.
-        m->bash_argv.push_back(QUtil::make_shared_cstr(m->argv[0]));
+        m->bash_argv.emplace_back(m->argv[0]);
     }
     // Explicitly discard any non-space-terminated word. The "current word" is handled specially.
-    m->bash_argv_ph = QUtil::make_shared_array<char const*>(1 + m->bash_argv.size());
-    for (size_t i = 0; i < m->bash_argv.size(); ++i) {
-        m->bash_argv_ph.get()[i] = m->bash_argv.at(i).get();
+    m->bash_argv_ph.reserve(1 + m->bash_argv.size());
+    for (auto const& a: m->bash_argv) {
+        m->bash_argv_ph.push_back(a.data());
     }
     m->argc = QIntC::to_int(m->bash_argv.size());
-    m->bash_argv_ph.get()[m->argc] = nullptr;
-    m->argv = m->bash_argv_ph.get();
+    m->bash_argv_ph.push_back(nullptr);
+    m->argv = m->bash_argv_ph.data();
 }
  
 void
@@ -360,7 +355,7 @@ QPDFArgParser::readArgsFromFile(std::string const&amp; filename)
         lines = QUtil::read_lines_from_file(filename.c_str());
     }
     for (auto const& line: lines) {
-        m->new_argv.push_back(QUtil::make_shared_cstr(line));
+        m->new_argv.emplace_back(line);
     }
 }
  
@@ -471,7 +466,7 @@ QPDFArgParser::parseArgs()
             // positional arguments. Besides, it doesn't make sense to have an empty option.
             arg_s = arg;
             size_t equal_pos = std::string::npos;
-            if (arg_s.length() > 0) {
+            if (!arg_s.empty()) {
                 equal_pos = arg_s.find('=', 1);
             }
             if (equal_pos != std::string::npos) {
@@ -481,7 +476,7 @@ QPDFArgParser::parseArgs()
             }
  
             if ((!m->bash_completion) && (m->argc == 2) && (m->cur_arg == 1) &&
-                m->help_option_table.count(arg_s)) {
+                m->help_option_table.contains(arg_s)) {
                 // Handle help option, which is only valid as the sole option.
                 QTC::TC("libtests", "QPDFArgParser help option");
                 oep = m->help_option_table.find(arg_s);
@@ -508,8 +503,8 @@ QPDFArgParser::parseArgs()
         }
  
         OptionEntry& oe = oep->second;
-        if ((oe.parameter_needed && (!have_parameter)) ||
-            ((!oe.choices.empty() && have_parameter && (0 == oe.choices.count(parameter))))) {
+        if ((oe.parameter_needed && !have_parameter) ||
+            (!oe.choices.empty() && have_parameter && !oe.choices.contains(parameter))) {
             std::string message = "--" + arg_s + " must be given as --" + arg_s + "=";
             if (oe.invalid_choice_handler) {
                 oe.invalid_choice_handler(parameter);
@@ -584,7 +579,7 @@ void
 QPDFArgParser::addChoicesToCompletions(
     option_table_t& option_table, std::string const& option, std::string const& extra_prefix)
 {
-    if (option_table.count(option) != 0) {
+    if (option_table.contains(option)) {
         OptionEntry& oe = option_table[option];
         for (auto const& choice: oe.choices) {
             QTC::TC("libtests", "QPDFArgParser complete choices");
@@ -666,7 +661,7 @@ QPDFArgParser::handleCompletion()
     std::string prefix = extra_prefix + m->bash_cur;
     for (auto const& iter: m->completions) {
         if (prefix.empty() || (iter.substr(0, prefix.length()) == prefix)) {
-            std::cout << iter << std::endl;
+            std::cout << iter << '\n';
         }
     }
     exit(0);
@@ -686,11 +681,11 @@ QPDFArgParser::addHelpTopic(
         QTC::TC("libtests", "QPDFArgParser add reserved help topic");
         throw std::logic_error("QPDFArgParser: can't register reserved help topic " + topic);
     }
-    if (!((topic.length() > 0) && (topic.at(0) != '-'))) {
+    if (topic.empty() || topic.at(0) == '-') {
         QTC::TC("libtests", "QPDFArgParser bad topic for help");
         throw std::logic_error("QPDFArgParser: help topics must not start with -");
     }
-    if (m->help_topics.count(topic)) {
+    if (m->help_topics.contains(topic)) {
         QTC::TC("libtests", "QPDFArgParser add existing topic");
         throw std::logic_error("QPDFArgParser: topic " + topic + " has already been added");
     }
@@ -710,7 +705,7 @@ QPDFArgParser::addOptionHelp(
         QTC::TC("libtests", "QPDFArgParser bad option for help");
         throw std::logic_error("QPDFArgParser: options for help must start with --");
     }
-    if (m->option_help.count(option_name)) {
+    if (m->option_help.contains(option_name)) {
         QTC::TC("libtests", "QPDFArgParser duplicate option help");
         throw std::logic_error("QPDFArgParser: option " + option_name + " already has help");
     }
@@ -729,13 +724,13 @@ QPDFArgParser::addOptionHelp(
 void
 QPDFArgParser::getTopHelp(std::ostringstream& msg)
 {
-    msg << "Run \"" << m->whoami << " --help=topic\" for help on a topic." << std::endl
-        << "Run \"" << m->whoami << " --help=--option\" for help on an option." << std::endl
-        << "Run \"" << m->whoami << " --help=all\" to see all available help." << std::endl
-        << std::endl
-        << "Topics:" << std::endl;
+    msg << "Run \"" << m->whoami << " --help=topic\" for help on a topic." << '\n'
+        << "Run \"" << m->whoami << " --help=--option\" for help on an option." << '\n'
+        << "Run \"" << m->whoami << " --help=all\" to see all available help." << '\n'
+        << '\n'
+        << "Topics:" << '\n';
     for (auto const& i: m->help_topics) {
-        msg << "  " << i.first << ": " << i.second.short_text << std::endl;
+        msg << "  " << i.first << ": " << i.second.short_text << '\n';
     }
 }
  
@@ -746,29 +741,27 @@ QPDFArgParser::getAllHelp(std::ostringstream&amp; msg)
     auto show = [this, &msg](std::map<std::string, HelpTopic>& topics) {
         for (auto const& i: topics) {
             auto const& topic = i.first;
-            msg << std::endl
-                << "== " << topic << " (" << i.second.short_text << ") ==" << std::endl
-                << std::endl;
+            msg << '\n' << "== " << topic << " (" << i.second.short_text << ") ==" << '\n' << '\n';
             getTopicHelp(topic, i.second, msg);
         }
     };
     show(m->help_topics);
     show(m->option_help);
-    msg << std::endl << "====" << std::endl;
+    msg << '\n' << "====" << '\n';
 }
  
 void
 QPDFArgParser::getTopicHelp(std::string const& name, HelpTopic const& ht, std::ostringstream& msg)
 {
     if (ht.long_text.empty()) {
-        msg << ht.short_text << std::endl;
+        msg << ht.short_text << '\n';
     } else {
         msg << ht.long_text;
     }
     if (!ht.options.empty()) {
-        msg << std::endl << "Related options:" << std::endl;
+        msg << '\n' << "Related options:" << '\n';
         for (auto const& i: ht.options) {
-            msg << "  " << i << ": " << m->option_help[i].short_text << std::endl;
+            msg << "  " << i << ": " << m->option_help[i].short_text << '\n';
         }
     }
 }
@@ -782,9 +775,9 @@ QPDFArgParser::getHelp(std::string const&amp; arg)
     } else {
         if (arg == "all") {
             getAllHelp(msg);
-        } else if (m->option_help.count(arg)) {
+        } else if (m->option_help.contains(arg)) {
             getTopicHelp(arg, m->option_help[arg], msg);
-        } else if (m->help_topics.count(arg)) {
+        } else if (m->help_topics.contains(arg)) {
             getTopicHelp(arg, m->help_topics[arg], msg);
         } else {
             // should not be possible
@@ -88,7 +88,7 @@ QPDFCryptoProvider::registerImpl_internal(std::string const&amp; name, provider_fn f
 void
 QPDFCryptoProvider::setDefaultProvider_internal(std::string const& name)
 {
-    if (!m->providers.count(name)) {
+    if (!m->providers.contains(name)) {
         throw std::logic_error(
             "QPDFCryptoProvider: request to set default provider to unknown implementation \"" +
             name + "\"");
@@ -262,13 +262,11 @@ ImageOptimizer::provideStreamData(QPDFObjGen const&amp;, Pipeline* pipeline)
 }
  
 QPDFJob::PageSpec::PageSpec(
-    std::string const& filename, char const* password, std::string const& range) :
+    std::string const& filename, std::string const& password, std::string const& range) :
     filename(filename),
+    password(password.empty() ? "" : password),
     range(range)
 {
-    if (password) {
-        this->password = QUtil::make_shared_cstr(password);
-    }
 }
  
 QPDFPageData::QPDFPageData(std::string const& filename, QPDF* qpdf, std::string const& range) :
@@ -396,7 +394,7 @@ QPDFJob::parseRotationParameter(std::string const&amp; parameter)
     } else {
         angle_str = parameter;
     }
-    if (angle_str.length() > 0) {
+    if (!angle_str.empty()) {
         char first = angle_str.at(0);
         if ((first == '+') || (first == '-')) {
             relative = ((first == '+') ? 1 : -1);
@@ -440,7 +438,7 @@ QPDFJob::createQPDF()
     checkConfiguration();
     std::unique_ptr<QPDF> pdf_sp;
     try {
-        processFile(pdf_sp, m->infilename.get(), m->password.get(), true, true);
+        processFile(pdf_sp, m->infilename.data(), m->password.data(), true, true);
     } catch (QPDFExc& e) {
         if (e.getErrorCode() == qpdf_e_password) {
             // Allow certain operations to work when an incorrect password is supplied.
@@ -561,7 +559,7 @@ QPDFJob::hasWarnings() const
 bool
 QPDFJob::createsOutput() const
 {
-    return ((m->outfilename != nullptr) || m->replace_input);
+    return (!m->outfilename.empty() || m->replace_input);
 }
  
 int
@@ -604,34 +602,39 @@ QPDFJob::checkConfiguration()
  
     if (m->replace_input) {
         // Check for --empty appears later after we have checked m->infilename.
-        if (m->outfilename) {
+        if (!m->outfilename.empty()) {
             usage("--replace-input may not be used when an output file is specified");
-        } else if (m->split_pages) {
+        }
+        if (m->split_pages) {
             usage("--split-pages may not be used with --replace-input");
-        } else if (m->json_version) {
+        }
+        if (m->json_version) {
             usage("--json may not be used with --replace-input");
         }
     }
-    if (m->json_version && (m->outfilename == nullptr)) {
+    if (m->json_version && m->outfilename.empty()) {
         // The output file is optional with --json for backward compatibility and defaults to
         // standard output.
-        m->outfilename = QUtil::make_shared_cstr("-");
+        m->outfilename = "-";
     }
-    if (m->infilename == nullptr) {
+    if (m->infilename.empty() && !m->empty_input) {
         usage("an input file name is required");
-    } else if (m->replace_input && (strlen(m->infilename.get()) == 0)) {
+    }
+    if (m->replace_input && m->infilename.empty()) {
         usage("--replace-input may not be used with --empty");
-    } else if (m->require_outfile && (m->outfilename == nullptr) && (!m->replace_input)) {
+    }
+    if (m->require_outfile && m->outfilename.empty() && !m->replace_input) {
         usage("an output file name is required; use - for standard output");
-    } else if ((!m->require_outfile) && ((m->outfilename != nullptr) || m->replace_input)) {
+    }
+    if (!m->require_outfile && (!m->outfilename.empty() || m->replace_input)) {
         usage("no output file may be given for this option");
     }
     if (m->check_requires_password && m->check_is_encrypted) {
         usage("--requires-password and --is-encrypted may not be given together");
     }
  
-    if (m->encrypt && (!m->allow_insecure) &&
-        (m->owner_password.empty() && (!m->user_password.empty()) && (m->keylen == 256))) {
+    if (m->encrypt && !m->allow_insecure && m->owner_password.empty() &&
+        !m->user_password.empty() && m->keylen == 256) {
         // Note that empty owner passwords for R < 5 are copied from the user password, so this lack
         // of security is not an issue for those files. Also we are consider only the ability to
         // open the file without a password to be insecure. We are not concerned about whether the
@@ -644,7 +647,7 @@ QPDFJob::checkConfiguration()
     }
  
     bool save_to_stdout = false;
-    if (m->require_outfile && m->outfilename && (strcmp(m->outfilename.get(), "-") == 0)) {
+    if (m->require_outfile && m->outfilename == "-") {
         if (m->split_pages) {
             usage("--split-pages may not be used when writing to standard output");
         }
@@ -656,7 +659,7 @@ QPDFJob::checkConfiguration()
     if (save_to_stdout) {
         m->log->saveToStandardOutput(true);
     }
-    if ((!m->split_pages) && QUtil::same_file(m->infilename.get(), m->outfilename.get())) {
+    if (!m->split_pages && QUtil::same_file(m->infilename.data(), m->outfilename.data())) {
         QTC::TC("qpdf", "QPDFJob same file error");
         usage(
             "input file and output file are the same; use --replace-input to intentionally "
@@ -664,11 +667,11 @@ QPDFJob::checkConfiguration()
     }
  
     if (m->json_version == 1) {
-        if (m->json_keys.count("qpdf")) {
+        if (m->json_keys.contains("qpdf")) {
             usage("json key \"qpdf\" is only valid for json version > 1");
         }
     } else {
-        if (m->json_keys.count("objectinfo") || m->json_keys.count("objects")) {
+        if (m->json_keys.contains("objectinfo") || m->json_keys.contains("objects")) {
             usage("json keys \"objects\" and \"objectinfo\" are only valid for json version 1");
         }
     }
@@ -781,7 +784,7 @@ QPDFJob::doCheck(QPDF&amp; pdf)
     // may continue to perform additional checks after finding errors.
     bool okay = true;
     auto& cout = *m->log->getInfo();
-    cout << "checking " << m->infilename.get() << "\n";
+    cout << "checking " << m->infilename << "\n";
     QPDF::JobSetter::setCheckMode(pdf, true);
     try {
         int extension_level = pdf.getExtensionLevel();
@@ -942,7 +945,7 @@ QPDFJob::doListAttachments(QPDF&amp; pdf)
             });
         }
     } else {
-        *m->log->getInfo() << m->infilename.get() << " has no embedded files\n";
+        *m->log->getInfo() << m->infilename << " has no embedded files\n";
     }
 }
  
@@ -1002,13 +1005,13 @@ QPDFJob::doJSONObjects(Pipeline* p, bool&amp; first, QPDF&amp; pdf)
         for (auto& obj: pdf.getAllObjects()) {
             std::string key = obj.unparse();
  
-            if (all_objects || wanted_og.count(obj.getObjGen())) {
+            if (all_objects || wanted_og.contains(obj.getObjGen())) {
                 JSON::writeDictionaryKey(p, first_object, obj.unparse(), 2);
                 obj.writeJSON(1, p, true, 2);
                 first_object = false;
             }
         }
-        if (all_objects || m->json_objects.count("trailer")) {
+        if (all_objects || m->json_objects.contains("trailer")) {
             JSON::writeDictionaryKey(p, first_object, "trailer", 2);
             pdf.getTrailer().writeJSON(1, p, true, 2);
             first_object = false;
@@ -1016,7 +1019,7 @@ QPDFJob::doJSONObjects(Pipeline* p, bool&amp; first, QPDF&amp; pdf)
         JSON::writeDictionaryClose(p, first_object, 1);
     } else {
         std::set<std::string> json_objects;
-        if (m->json_objects.count("trailer")) {
+        if (m->json_objects.contains("trailer")) {
             json_objects.insert("trailer");
         }
         for (auto og: getWantedJSONObjects()) {
@@ -1043,7 +1046,7 @@ QPDFJob::doJSONObjectinfo(Pipeline* p, bool&amp; first, QPDF&amp; pdf)
     bool all_objects = m->json_objects.empty();
     auto wanted_og = getWantedJSONObjects();
     for (auto& obj: pdf.getAllObjects()) {
-        if (all_objects || wanted_og.count(obj.getObjGen())) {
+        if (all_objects || wanted_og.contains(obj.getObjGen())) {
             auto j_details = JSON::makeDictionary();
             auto j_stream = j_details.addDictionaryMember("stream", JSON::makeDictionary());
             bool is_stream = obj.isStream();
@@ -1165,7 +1168,7 @@ QPDFJob::addOutlinesToJson(
         JSON j_destpage = JSON::makeNull();
         if (page.isIndirect()) {
             QPDFObjGen og = page.getObjGen();
-            if (page_numbers.count(og)) {
+            if (page_numbers.contains(og)) {
                 j_destpage = JSON::makeInt(page_numbers[og]);
             }
         }
@@ -1384,190 +1387,201 @@ QPDFJob::json_schema(int json_version, std::set&lt;std::string&gt;* keys)
     // mismatch is a bug in qpdf. This helps to enforce our policy of consistently providing a known
     // structure where every documented key will always be present, which makes it easier to consume
     // our JSON. This is discussed in more depth in the manual.
-    JSON schema = JSON::makeDictionary();
-    schema.addDictionaryMember(
-        "version",
-        JSON::makeString("JSON format serial number; increased for non-compatible changes"));
-    JSON j_params = schema.addDictionaryMember("parameters", JSON::parse(R"({
-  "decodelevel": "decode level used to determine stream filterability"
-})"));
  
-    bool all_keys = ((keys == nullptr) || keys->empty());
+    static constexpr const char* objects_schema_v1 = R"({
+      "<n n R|trailer>": "json representation of object"
+    })";
  
-    // The list of selectable top-level keys id duplicated in the following places: job.yml,
-    // QPDFJob::json_schema, and QPDFJob::doJSON.
-    if (json_version == 1) {
-        if (all_keys || keys->count("objects")) {
-            schema.addDictionaryMember("objects", JSON::parse(R"({
-  "<n n R|trailer>": "json representation of object"
-})"));
-        }
-        if (all_keys || keys->count("objectinfo")) {
-            JSON objectinfo = schema.addDictionaryMember("objectinfo", JSON::parse(R"({
-  "<object-id>": {
-    "stream": {
-      "filter": "if stream, its filters, otherwise null",
-      "is": "whether the object is a stream",
-      "length": "if stream, its length, otherwise null"
-    }
-  }
-})"));
+    static constexpr const char* objectinfo_schema_v1 = R"({
+      "<object-id>": {
+        "stream": {
+          "filter": "if stream, its filters, otherwise null",
+          "is": "whether the object is a stream",
+          "length": "if stream, its length, otherwise null"
         }
-    } else {
-        if (all_keys || keys->count("qpdf")) {
-            schema.addDictionaryMember("qpdf", JSON::parse(R"([{
-  "jsonversion": "numeric JSON version",
-  "pdfversion": "PDF version as x.y",
-  "pushedinheritedpageresources": "whether inherited attributes were pushed to the page level",
-  "calledgetallpages": "whether getAllPages was called",
-  "maxobjectid": "highest object ID in output, ignored on input"
-},
-{
-  "<obj:n n R|trailer>": "json representation of object"
-}])"));
-        }
-    }
-    if (all_keys || keys->count("pages")) {
-        JSON page = schema.addDictionaryMember("pages", JSON::parse(R"([
-  {
-    "contents": [
-      "reference to each content stream"
-    ],
-    "images": [
+      }
+    })";
+
+    static constexpr const char* qpdf_schema = R"([{
+      "jsonversion": "numeric JSON version",
+      "pdfversion": "PDF version as x.y",
+      "pushedinheritedpageresources": "whether inherited attributes were pushed to the page level",
+      "calledgetallpages": "whether getAllPages was called",
+      "maxobjectid": "highest object ID in output, ignored on input"
+    },
+    {
+      "<obj:n n R|trailer>": "json representation of object"
+    }])";
+
+    static constexpr const char* pages_schema = R"([
       {
-        "bitspercomponent": "bits per component",
-        "colorspace": "color space",
-        "decodeparms": [
-          "decode parameters for image data"
+        "contents": [
+          "reference to each content stream"
+        ],
+        "images": [
+          {
+            "bitspercomponent": "bits per component",
+            "colorspace": "color space",
+            "decodeparms": [
+              "decode parameters for image data"
+            ],
+            "filter": [
+              "filters applied to image data"
+            ],
+            "filterable": "whether image data can be decoded using the decode level qpdf was invoked with",
+            "height": "image height",
+            "name": "name of image in XObject table",
+            "object": "reference to image stream",
+            "width": "image width"
+          }
         ],
-        "filter": [
-          "filters applied to image data"
+        "label": "page label dictionary, or null if none",
+        "object": "reference to original page object",
+        "outlines": [
+          {
+            "dest": "outline destination dictionary",
+            "object": "reference to outline that targets this page",
+            "title": "outline title"
+          }
         ],
-        "filterable": "whether image data can be decoded using the decode level qpdf was invoked with",
-        "height": "image height",
-        "name": "name of image in XObject table",
-        "object": "reference to image stream",
-        "width": "image width"
+        "pageposfrom1": "position of page in document numbering from 1"
+      }
+    ])";
+
+    static constexpr const char* pagelabels_schema = R"([
+      {
+        "index": "starting page position starting from zero",
+        "label": "page label dictionary"
       }
-    ],
-    "label": "page label dictionary, or null if none",
-    "object": "reference to original page object",
-    "outlines": [
+    ])";
+
+    static constexpr const char* outlines_schema = R"([
       {
         "dest": "outline destination dictionary",
-        "object": "reference to outline that targets this page",
+        "destpageposfrom1": "position of destination page in document numbered from 1; null if not known",
+        "kids": "array of descendent outlines",
+        "object": "reference to this outline",
+        "open": "whether the outline is displayed expanded",
         "title": "outline title"
       }
-    ],
-    "pageposfrom1": "position of page in document numbering from 1"
-  }
-])"));
-    }
-    if (all_keys || keys->count("pagelabels")) {
-        JSON labels = schema.addDictionaryMember("pagelabels", JSON::parse(R"([
-  {
-    "index": "starting page position starting from zero",
-    "label": "page label dictionary"
-  }
-])"));
-    }
-    if (all_keys || keys->count("outlines")) {
-        JSON outlines = schema.addDictionaryMember("outlines", JSON::parse(R"([
-  {
-    "dest": "outline destination dictionary",
-    "destpageposfrom1": "position of destination page in document numbered from 1; null if not known",
-    "kids": "array of descendent outlines",
-    "object": "reference to this outline",
-    "open": "whether the outline is displayed expanded",
-    "title": "outline title"
-  }
-])"));
-    }
-    if (all_keys || keys->count("acroform")) {
-        JSON acroform = schema.addDictionaryMember("acroform", JSON::parse(R"({
-  "fields": [
-    {
-      "alternativename": "alternative name of field -- this is the one usually shown to users",
-      "annotation": {
-        "annotationflags": "annotation flags from /F -- see pdf_annotation_flag_e in qpdf/Constants.h",
-        "appearancestate": "appearance state -- can be used to determine value for checkboxes and radio buttons",
-        "object": "reference to the annotation object"
+    ])";
+
+    static constexpr const char* acroform_schema = R"({
+      "fields": [
+        {
+          "alternativename": "alternative name of field -- this is the one usually shown to users",
+          "annotation": {
+            "annotationflags": "annotation flags from /F -- see pdf_annotation_flag_e in qpdf/Constants.h",
+            "appearancestate": "appearance state -- can be used to determine value for checkboxes and radio buttons",
+            "object": "reference to the annotation object"
+          },
+          "choices": "for choices fields, the list of choices presented to the user",
+          "defaultvalue": "default value of field",
+          "fieldflags": "form field flags from /Ff -- see pdf_form_field_flag_e in qpdf/Constants.h",
+          "fieldtype": "field type",
+          "fullname": "full name of field",
+          "ischeckbox": "whether field is a checkbox",
+          "ischoice": "whether field is a list, combo, or dropdown",
+          "isradiobutton": "whether field is a radio button -- buttons in a single group share a parent",
+          "istext": "whether field is a text field",
+          "mappingname": "mapping name of field",
+          "object": "reference to this form field",
+          "pageposfrom1": "position of containing page numbered from 1",
+          "parent": "reference to this field's parent",
+          "partialname": "partial name of field",
+          "quadding": "field quadding -- number indicating left, center, or right",
+          "value": "value of field"
+        }
+      ],
+      "hasacroform": "whether the document has interactive forms",
+      "needappearances": "whether the form fields' appearance streams need to be regenerated"
+    })";
+
+    static constexpr const char* encrypt_schema1 = R"({
+      "capabilities": {
+        "accessibility": "allow extraction for accessibility?",
+        "extract": "allow extraction?",
+        ")";
+
+    static constexpr const char* encrypt_schema2 = R"(": "allow modifying annotations?",
+        "modify": "allow all modifications?",
+        "modifyassembly": "allow modifying document assembly?",
+        "modifyforms": "allow modifying forms?",
+        "modifyother": "allow other modifications?",
+        "printhigh": "allow high resolution printing?",
+        "printlow": "allow low resolution printing?"
+      },
+      "encrypted": "whether the document is encrypted",
+      "ownerpasswordmatched": "whether supplied password matched owner password; always false for non-encrypted files",
+      "recovereduserpassword": "If the owner password was used to recover the user password, reveal user password; otherwise null",
+      "parameters": {
+        "P": "P value from Encrypt dictionary",
+        "R": "R value from Encrypt dictionary",
+        "V": "V value from Encrypt dictionary",
+        "bits": "encryption key bit length",
+        "filemethod": "encryption method for attachments",
+        "key": "encryption key; will be null unless --show-encryption-key was specified",
+        "method": "overall encryption method: none, mixed, RC4, AESv2, AESv3",
+        "streammethod": "encryption method for streams",
+        "stringmethod": "encryption method for string"
       },
-      "choices": "for choices fields, the list of choices presented to the user",
-      "defaultvalue": "default value of field",
-      "fieldflags": "form field flags from /Ff -- see pdf_form_field_flag_e in qpdf/Constants.h",
-      "fieldtype": "field type",
-      "fullname": "full name of field",
-      "ischeckbox": "whether field is a checkbox",
-      "ischoice": "whether field is a list, combo, or dropdown",
-      "isradiobutton": "whether field is a radio button -- buttons in a single group share a parent",
-      "istext": "whether field is a text field",
-      "mappingname": "mapping name of field",
-      "object": "reference to this form field",
-      "pageposfrom1": "position of containing page numbered from 1",
-      "parent": "reference to this field's parent",
-      "partialname": "partial name of field",
-      "quadding": "field quadding -- number indicating left, center, or right",
-      "value": "value of field"
-    }
-  ],
-  "hasacroform": "whether the document has interactive forms",
-  "needappearances": "whether the form fields' appearance streams need to be regenerated"
+      "userpasswordmatched": "whether supplied password matched user password; always false for non-encrypted files"
+    })";
+
+    static constexpr const char* attachments_schema = R"({
+      "<attachment-key>": {
+        "filespec": "object containing the file spec",
+        "preferredcontents": "most preferred embedded file stream",
+        "preferredname": "most preferred file name",
+        "description": "description of attachment",
+        "names": {
+          "<name-key>": "file name for key"
+        },
+        "streams": {
+          "<stream-key>": {
+            "creationdate": "ISO-8601 creation date or null",
+            "modificationdate": "ISO-8601 modification date or null",
+            "mimetype": "mime type or null",
+            "checksum": "MD5 checksum or null"
+          }
+        }
+      }
+    })";
+
+    JSON schema = JSON::makeDictionary();
+    schema.addDictionaryMember(
+        "version",
+        JSON::makeString("JSON format serial number; increased for non-compatible changes"));
+    JSON j_params = schema.addDictionaryMember("parameters", JSON::parse(R"({
+  "decodelevel": "decode level used to determine stream filterability"
 })"));
+
+    const bool all_keys = !keys || keys->empty();
+
+    auto add_if_want_key = [&](std::string const& key, std::string const& json) -> void {
+        if (all_keys || keys->contains(key)) {
+            (void)schema.addDictionaryMember(key, JSON::parse(json));
+        }
+    };
+
+    // The list of selectable top-level keys id duplicated in the following places: job.yml,
+    // QPDFJob::json_schema, and QPDFJob::doJSON.
+    if (json_version == 1) {
+        add_if_want_key("objects", objects_schema_v1);
+        add_if_want_key("objectinfo", objectinfo_schema_v1);
+    } else {
+        add_if_want_key("qpdf", qpdf_schema);
     }
+    add_if_want_key("pages", pages_schema);
+    add_if_want_key("pagelabels", pagelabels_schema);
+    add_if_want_key("outlines", outlines_schema);
+    add_if_want_key("acroform", acroform_schema);
+
     std::string MODIFY_ANNOTATIONS =
         (json_version == 1 ? "moddifyannotations" : "modifyannotations");
-    if (all_keys || keys->count("encrypt")) {
-        JSON encrypt = schema.addDictionaryMember("encrypt", JSON::parse(R"({
-  "capabilities": {
-    "accessibility": "allow extraction for accessibility?",
-    "extract": "allow extraction?",
-    ")" + MODIFY_ANNOTATIONS + R"(": "allow modifying annotations?",
-    "modify": "allow all modifications?",
-    "modifyassembly": "allow modifying document assembly?",
-    "modifyforms": "allow modifying forms?",
-    "modifyother": "allow other modifications?",
-    "printhigh": "allow high resolution printing?",
-    "printlow": "allow low resolution printing?"
-  },
-  "encrypted": "whether the document is encrypted",
-  "ownerpasswordmatched": "whether supplied password matched owner password; always false for non-encrypted files",
-  "recovereduserpassword": "If the owner password was used to recover the user password, reveal user password; otherwise null",
-  "parameters": {
-    "P": "P value from Encrypt dictionary",
-    "R": "R value from Encrypt dictionary",
-    "V": "V value from Encrypt dictionary",
-    "bits": "encryption key bit length",
-    "filemethod": "encryption method for attachments",
-    "key": "encryption key; will be null unless --show-encryption-key was specified",
-    "method": "overall encryption method: none, mixed, RC4, AESv2, AESv3",
-    "streammethod": "encryption method for streams",
-    "stringmethod": "encryption method for string"
-  },
-  "userpasswordmatched": "whether supplied password matched user password; always false for non-encrypted files"
-})"));
-    }
-    if (all_keys || keys->count("attachments")) {
-        JSON attachments = schema.addDictionaryMember("attachments", JSON::parse(R"({
-  "<attachment-key>": {
-    "filespec": "object containing the file spec",
-    "preferredcontents": "most preferred embedded file stream",
-    "preferredname": "most preferred file name",
-    "description": "description of attachment",
-    "names": {
-      "<name-key>": "file name for key"
-    },
-    "streams": {
-      "<stream-key>": {
-        "creationdate": "ISO-8601 creation date or null",
-        "modificationdate": "ISO-8601 modification date or null",
-        "mimetype": "mime type or null",
-        "checksum": "MD5 checksum or null"
-      }
-    }
-  }
-})"));
-    }
+    add_if_want_key("encrypt", encrypt_schema1 + MODIFY_ANNOTATIONS + encrypt_schema2);
+    add_if_want_key("attachments", attachments_schema);
+
     return schema;
 }
  
@@ -1590,9 +1604,9 @@ QPDFJob::doJSON(QPDF&amp; pdf, Pipeline* p)
     // are reserved for users.
  
     std::string captured_json;
-    std::shared_ptr<Pl_String> pl_str;
+    std::unique_ptr<Pl_String> pl_str;
     if (m->test_json_schema) {
-        pl_str = std::make_shared<Pl_String>("capture json", p, captured_json);
+        pl_str = std::make_unique<Pl_String>("capture json", p, captured_json);
         p = pl_str.get();
     }
  
@@ -1626,43 +1640,49 @@ QPDFJob::doJSON(QPDF&amp; pdf, Pipeline* p)
         j_params.addDictionaryMember("decodelevel", JSON::makeString(decode_level_str));
         JSON::writeDictionaryItem(p, first, "parameters", j_params, 1);
     }
-    bool all_keys = m->json_keys.empty();
+
+    const bool all_keys = m->json_keys.empty();
+
+    auto want_key = [&](std::string const& key) -> bool {
+        return all_keys || m->json_keys.contains(key);
+    };
+
     // The list of selectable top-level keys id duplicated in the following places: job.yml,
     // QPDFJob::json_schema, and QPDFJob::doJSON.
  
     // We do pages and pagelabels first since they have the side effect of repairing the pages tree,
     // which could potentially impact object references in remaining items.
-    if (all_keys || m->json_keys.count("pages")) {
+    if (want_key("pages")) {
         doJSONPages(p, first, pdf);
     }
-    if (all_keys || m->json_keys.count("pagelabels")) {
+    if (want_key("pagelabels")) {
         doJSONPageLabels(p, first, pdf);
     }
  
     // The non-special keys are output in alphabetical order, but the order doesn't actually matter.
-    if (all_keys || m->json_keys.count("acroform")) {
+    if (want_key("acroform")) {
         doJSONAcroform(p, first, pdf);
     }
-    if (all_keys || m->json_keys.count("attachments")) {
+    if (want_key("attachments")) {
         doJSONAttachments(p, first, pdf);
     }
-    if (all_keys || m->json_keys.count("encrypt")) {
+    if (want_key("encrypt")) {
         doJSONEncrypt(p, first, pdf);
     }
-    if (all_keys || m->json_keys.count("outlines")) {
+    if (want_key("outlines")) {
         doJSONOutlines(p, first, pdf);
     }
  
     // We do objects last so their information is consistent with repairing the page tree. To see
     // the original file with any page tree problems and the page tree not flattened, select
     // qpdf/objects/objectinfo without other keys.
-    if (all_keys || m->json_keys.count("objects") || m->json_keys.count("qpdf")) {
+    if (want_key("objects") || want_key("qpdf")) {
         doJSONObjects(p, first, pdf);
     }
     if (m->json_version == 1) {
         // "objectinfo" is not needed for version >1 since you can tell streams from other objects
         // in "objects".
-        if (all_keys || m->json_keys.count("objectinfo")) {
+        if (want_key("objectinfo")) {
             doJSONObjectinfo(p, first, pdf);
         }
     }
@@ -1700,9 +1720,9 @@ QPDFJob::doInspection(QPDF&amp; pdf)
     }
     if (m->check_linearization) {
         if (!pdf.isLinearized()) {
-            cout << m->infilename.get() << " is not linearized\n";
+            cout << m->infilename << " is not linearized\n";
         } else if (pdf.checkLinearization()) {
-            cout << m->infilename.get() << ": no linearization errors\n";
+            cout << m->infilename << ": no linearization errors\n";
         } else {
             m->warnings = true;
         }
@@ -1711,7 +1731,7 @@ QPDFJob::doInspection(QPDF&amp; pdf)
         if (pdf.isLinearized()) {
             pdf.showLinearizationData();
         } else {
-            cout << m->infilename.get() << " is not linearized\n";
+            cout << m->infilename << " is not linearized\n";
         }
     }
     if (m->show_xref) {
@@ -1748,7 +1768,7 @@ QPDFJob::doProcessOnce(
     if (empty) {
         pdf->emptyPDF();
     } else if (main_input && m->json_input) {
-        pdf->createFromJSON(m->infilename.get());
+        pdf->createFromJSON(m->infilename);
     } else {
         fn(pdf.get(), password);
     }
@@ -1862,7 +1882,7 @@ QPDFJob::validateUnderOverlay(QPDF&amp; pdf, UnderOverlay* uo)
 {
     QPDFPageDocumentHelper main_pdh(pdf);
     int main_npages = QIntC::to_int(main_pdh.getAllPages().size());
-    processFile(uo->pdf, uo->filename.c_str(), uo->password.get(), true, false);
+    processFile(uo->pdf, uo->filename.data(), uo->password.data(), true, false);
     QPDFPageDocumentHelper uo_pdh(*(uo->pdf));
     int uo_npages = QIntC::to_int(uo_pdh.getAllPages().size());
     try {
@@ -1891,7 +1911,7 @@ get_afdh_for_qpdf(
     std::map<unsigned long long, std::shared_ptr<QPDFAcroFormDocumentHelper>>& afdh_map, QPDF* q)
 {
     auto uid = q->getUniqueId();
-    if (!afdh_map.count(uid)) {
+    if (!afdh_map.contains(uid)) {
         afdh_map[uid] = std::make_shared<QPDFAcroFormDocumentHelper>(*q);
     }
     return afdh_map[uid].get();
@@ -1909,7 +1929,7 @@ QPDFJob::doUnderOverlayForPage(
     QPDFPageObjectHelper& dest_page)
 {
     int pageno = 1 + QIntC::to_int(page_idx);
-    if (!(pagenos.count(pageno) && pagenos[pageno].count(uo_idx))) {
+    if (!(pagenos.contains(pageno) && pagenos[pageno].contains(uo_idx))) {
         return "";
     }
  
@@ -1928,7 +1948,7 @@ QPDFJob::doUnderOverlayForPage(
             v << "    " << uo.filename << " " << uo.which << " " << from_pageno << "\n";
         });
         auto from_page = pages.at(QIntC::to_size(from_pageno - 1));
-        if (fo[from_pageno].count(uo_idx) == 0) {
+        if (!fo[from_pageno].contains(uo_idx)) {
             fo[from_pageno][uo_idx] = pdf.copyForeignObject(from_page.getFormXObjectForPage());
         }
  
@@ -2410,7 +2430,7 @@ QPDFJob::handlePageSpecs(QPDF&amp; pdf, std::vector&lt;std::unique_ptr&lt;QPDF&gt;&gt;&amp; page_hea
     // Handle "." as a shortcut for the input file
     for (auto& page_spec: m->page_specs) {
         if (page_spec.filename == ".") {
-            page_spec.filename = m->infilename.get();
+            page_spec.filename = m->infilename;
         }
         if (page_spec.range.empty()) {
             page_spec.range = "1-z";
@@ -2436,11 +2456,11 @@ QPDFJob::handlePageSpecs(QPDF&amp; pdf, std::vector&lt;std::unique_ptr&lt;QPDF&gt;&gt;&amp; page_hea
     // Create a QPDF object for each file that we may take pages from.
     std::map<std::string, QPDF*> page_spec_qpdfs;
     std::map<std::string, ClosedFileInputSource*> page_spec_cfis;
-    page_spec_qpdfs[m->infilename.get()] = &pdf;
+    page_spec_qpdfs[m->infilename] = &pdf;
     std::vector<QPDFPageData> parsed_specs;
     std::map<unsigned long long, std::set<QPDFObjGen>> copied_pages;
     for (auto& page_spec: m->page_specs) {
-        if (page_spec_qpdfs.count(page_spec.filename) == 0) {
+        if (!page_spec_qpdfs.contains(page_spec.filename)) {
             // Open the PDF file and store the QPDF object. Throw a std::shared_ptr to the qpdf into
             // a heap so that it survives through copying to the output but gets cleaned up
             // automatically at the end. Do not canonicalize the file name. Using two different
@@ -2448,11 +2468,11 @@ QPDFJob::handlePageSpecs(QPDF&amp; pdf, std::vector&lt;std::unique_ptr&lt;QPDF&gt;&gt;&amp; page_hea
             // you are using this an example of how to do this with the API, you can just create two
             // different QPDF objects to the same underlying file with the same path to achieve the
             // same effect.
-            char const* password = page_spec.password.get();
-            if ((!m->encryption_file.empty()) && (password == nullptr) &&
-                (page_spec.filename == m->encryption_file)) {
+            auto password = page_spec.password;
+            if (!m->encryption_file.empty() && password.empty() &&
+                page_spec.filename == m->encryption_file) {
                 QTC::TC("qpdf", "QPDFJob pages encryption password");
-                password = m->encryption_file_password.get();
+                password = m->encryption_file_password;
             }
             doIfVerbose([&](Pipeline& v, std::string const& prefix) {
                 v << prefix << ": processing " << page_spec.filename << "\n";
@@ -2470,7 +2490,7 @@ QPDFJob::handlePageSpecs(QPDF&amp; pdf, std::vector&lt;std::unique_ptr&lt;QPDF&gt;&gt;&amp; page_hea
                 is = std::shared_ptr<InputSource>(fis);
             }
             std::unique_ptr<QPDF> qpdf_sp;
-            processInputSource(qpdf_sp, is, password, true);
+            processInputSource(qpdf_sp, is, password.data(), true);
             page_spec_qpdfs[page_spec.filename] = qpdf_sp.get();
             page_heap.push_back(std::move(qpdf_sp));
             if (cis) {
@@ -2490,13 +2510,13 @@ QPDFJob::handlePageSpecs(QPDF&amp; pdf, std::vector&lt;std::unique_ptr&lt;QPDF&gt;&gt;&amp; page_hea
         for (auto const& iter: page_spec_qpdfs) {
             std::string const& filename = iter.first;
             ClosedFileInputSource* cis = nullptr;
-            if (page_spec_cfis.count(filename)) {
+            if (page_spec_cfis.contains(filename)) {
                 cis = page_spec_cfis[filename];
                 cis->stayOpen(true);
             }
             QPDF& other(*(iter.second));
             auto other_uuid = other.getUniqueId();
-            if (remove_unreferenced.count(other_uuid) == 0) {
+            if (!remove_unreferenced.contains(other_uuid)) {
                 remove_unreferenced[other_uuid] = shouldRemoveUnreferencedResources(other);
             }
             if (cis) {
@@ -2563,7 +2583,7 @@ QPDFJob::handlePageSpecs(QPDF&amp; pdf, std::vector&lt;std::unique_ptr&lt;QPDF&gt;&gt;&amp; page_hea
     std::set<QPDFObjGen> referenced_fields;
     for (auto& page_data: parsed_specs) {
         ClosedFileInputSource* cis = nullptr;
-        if (page_spec_cfis.count(page_data.filename)) {
+        if (page_spec_cfis.contains(page_data.filename)) {
             cis = page_spec_cfis[page_data.filename];
             cis->stayOpen(true);
         }
@@ -2582,7 +2602,7 @@ QPDFJob::handlePageSpecs(QPDF&amp; pdf, std::vector&lt;std::unique_ptr&lt;QPDF&gt;&gt;&amp; page_hea
             QPDFPageObjectHelper to_copy = page_data.orig_pages.at(QIntC::to_size(pageno));
             QPDFObjGen to_copy_og = to_copy.getObjectHandle().getObjGen();
             unsigned long long from_uuid = page_data.qpdf->getUniqueId();
-            if (copied_pages[from_uuid].count(to_copy_og)) {
+            if (copied_pages[from_uuid].contains(to_copy_og)) {
                 QTC::TC(
                     "qpdf",
                     "QPDFJob copy same page more than once",
@@ -2600,7 +2620,7 @@ QPDFJob::handlePageSpecs(QPDF&amp; pdf, std::vector&lt;std::unique_ptr&lt;QPDF&gt;&gt;&amp; page_hea
             if (this_file) {
                 // This is a page from the original file. Keep track of the fact that we are using
                 // it.
-                first_copy_from_orig = (selected_from_orig.count(pageno) == 0);
+                first_copy_from_orig = (!selected_from_orig.contains(pageno));
                 selected_from_orig.insert(pageno);
             }
             auto new_page = added_page(pdf, to_copy);
@@ -2645,7 +2665,7 @@ QPDFJob::handlePageSpecs(QPDF&amp; pdf, std::vector&lt;std::unique_ptr&lt;QPDF&gt;&gt;&amp; page_hea
     // sure we keep form fields from pages we preserved.
     for (size_t pageno = 0; pageno < orig_pages.size(); ++pageno) {
         auto page = orig_pages.at(pageno);
-        if (selected_from_orig.count(QIntC::to_int(pageno))) {
+        if (selected_from_orig.contains(QIntC::to_int(pageno))) {
             for (auto field: this_afdh->getFormFieldsForPage(page)) {
                 QTC::TC("qpdf", "QPDFJob pages keeping field from original");
                 referenced_fields.insert(field.getObjectHandle().getObjGen());
@@ -2664,7 +2684,7 @@ QPDFJob::handlePageSpecs(QPDF&amp; pdf, std::vector&lt;std::unique_ptr&lt;QPDF&gt;&gt;&amp; page_hea
                 new_fields = pdf.makeIndirectObject(new_fields);
             }
             for (auto const& field: fields.aitems()) {
-                if (referenced_fields.count(field.getObjGen())) {
+                if (referenced_fields.contains(field.getObjGen())) {
                     new_fields.appendItem(field);
                 }
             }
@@ -2940,8 +2960,8 @@ QPDFJob::setWriterOptions(QPDFWriter&amp; w)
         std::unique_ptr<QPDF> encryption_pdf;
         processFile(
             encryption_pdf,
-            m->encryption_file.c_str(),
-            m->encryption_file_password.get(),
+            m->encryption_file.data(),
+            m->encryption_file_password.data(),
             false,
             false);
         w.copyEncryptionParameters(*encryption_pdf);
@@ -2977,7 +2997,8 @@ QPDFJob::setWriterOptions(QPDFWriter&amp; w)
                 std::shared_ptr<QPDFWriter::ProgressReporter>(
                     new QPDFWriter::FunctionProgressReporter(m->progress_handler)));
         } else {
-            char const* outfilename = m->outfilename ? m->outfilename.get() : "standard output";
+            char const* outfilename =
+                !m->outfilename.empty() ? m->outfilename.data() : "standard output";
             w.registerProgressReporter(
                 std::shared_ptr<QPDFWriter::ProgressReporter>(
                     // line-break
@@ -2992,20 +3013,20 @@ QPDFJob::doSplitPages(QPDF&amp; pdf)
     // Generate output file pattern
     std::string before;
     std::string after;
-    size_t len = strlen(m->outfilename.get());
-    char* num_spot = strstr(const_cast<char*>(m->outfilename.get()), "%d");
-    if (num_spot != nullptr) {
+    size_t len = m->outfilename.size();
+    auto num_spot = m->outfilename.find("%d");
+    if (num_spot != std::string::npos) {
         QTC::TC("qpdf", "QPDFJob split-pages %d");
-        before = std::string(m->outfilename.get(), QIntC::to_size(num_spot - m->outfilename.get()));
-        after = num_spot + 2;
+        before = m->outfilename.substr(0, num_spot);
+        after = m->outfilename.substr(num_spot + 2);
     } else if (
-        (len >= 4) && (QUtil::str_compare_nocase(m->outfilename.get() + len - 4, ".pdf") == 0)) {
+        len >= 4 && QUtil::str_compare_nocase(m->outfilename.substr(len - 4).data(), ".pdf") == 0) {
         QTC::TC("qpdf", "QPDFJob split-pages .pdf");
-        before = std::string(m->outfilename.get(), len - 4) + "-";
-        after = m->outfilename.get() + len - 4;
+        before = std::string(m->outfilename.data(), len - 4) + "-";
+        after = m->outfilename.data() + len - 4;
     } else {
         QTC::TC("qpdf", "QPDFJob split-pages other");
-        before = std::string(m->outfilename.get()) + "-";
+        before = m->outfilename + "-";
     }
  
     if (shouldRemoveUnreferencedResources(pdf)) {
@@ -3064,7 +3085,7 @@ QPDFJob::doSplitPages(QPDF&amp; pdf)
             page_range += "-" + QUtil::uint_to_string(last, QIntC::to_int(pageno_len));
         }
         std::string outfile = before + page_range + after;
-        if (QUtil::same_file(m->infilename.get(), outfile.c_str())) {
+        if (QUtil::same_file(m->infilename.data(), outfile.data())) {
             throw std::runtime_error("split pages would overwrite input file with " + outfile);
         }
         QPDFWriter w(outpdf, outfile.c_str());
@@ -3079,15 +3100,15 @@ QPDFJob::doSplitPages(QPDF&amp; pdf)
 void
 QPDFJob::writeOutfile(QPDF& pdf)
 {
-    std::shared_ptr<char> temp_out;
+    std::string temp_out;
     if (m->replace_input) {
         // Append but don't prepend to the path to generate a temporary name. This saves us from
         // having to split the path by directory and non-directory.
-        temp_out = QUtil::make_shared_cstr(std::string(m->infilename.get()) + ".~qpdf-temp#");
+        temp_out = m->infilename + ".~qpdf-temp#";
         // m->outfilename will be restored to 0 before temp_out goes out of scope.
         m->outfilename = temp_out;
-    } else if (strcmp(m->outfilename.get(), "-") == 0) {
-        m->outfilename = nullptr;
+    } else if (m->outfilename == "-") {
+        m->outfilename.clear();
     }
     if (m->json_version) {
         writeJSON(pdf);
@@ -3095,8 +3116,8 @@ QPDFJob::writeOutfile(QPDF&amp; pdf)
         // QPDFWriter must have block scope so the output file will be closed after write()
         // finishes.
         QPDFWriter w(pdf);
-        if (m->outfilename) {
-            w.setOutputFilename(m->outfilename.get());
+        if (!m->outfilename.empty()) {
+            w.setOutputFilename(m->outfilename.data());
         } else {
             // saveToStandardOutput has already been called, but calling it again is defensive and
             // harmless.
@@ -3106,24 +3127,24 @@ QPDFJob::writeOutfile(QPDF&amp; pdf)
         setWriterOptions(w);
         w.write();
     }
-    if (m->outfilename) {
+    if (!m->outfilename.empty()) {
         doIfVerbose([&](Pipeline& v, std::string const& prefix) {
-            v << prefix << ": wrote file " << m->outfilename.get() << "\n";
+            v << prefix << ": wrote file " << m->outfilename << "\n";
         });
     }
     if (m->replace_input) {
-        m->outfilename = nullptr;
+        m->outfilename.clear();
     }
     if (m->replace_input) {
         // We must close the input before we can rename files
         pdf.closeInputSource();
-        std::string backup = std::string(m->infilename.get()) + ".~qpdf-orig";
+        std::string backup = m->infilename + ".~qpdf-orig";
         bool warnings = pdf.anyWarnings();
         if (!warnings) {
             backup.append(1, '#');
         }
-        QUtil::rename_file(m->infilename.get(), backup.c_str());
-        QUtil::rename_file(temp_out.get(), m->infilename.get());
+        QUtil::rename_file(m->infilename.data(), backup.data());
+        QUtil::rename_file(temp_out.data(), m->infilename.data());
         if (warnings) {
             *m->log->getError() << m->message_prefix
                                 << ": there are warnings; original file kept in " << backup << "\n";
@@ -3145,12 +3166,12 @@ QPDFJob::writeJSON(QPDF&amp; pdf)
     // File pipeline must have block scope so it will be closed after write.
     std::shared_ptr<QUtil::FileCloser> fc;
     std::shared_ptr<Pipeline> fp;
-    if (m->outfilename.get()) {
+    if (!m->outfilename.empty()) {
         QTC::TC("qpdf", "QPDFJob write json to file");
         if (m->json_stream_prefix.empty()) {
-            m->json_stream_prefix = m->outfilename.get();
+            m->json_stream_prefix = m->outfilename;
         }
-        fc = std::make_shared<QUtil::FileCloser>(QUtil::safe_fopen(m->outfilename.get(), "w"));
+        fc = std::make_shared<QUtil::FileCloser>(QUtil::safe_fopen(m->outfilename.data(), "w"));
         fp = std::make_shared<Pl_StdioFile>("json output", fc->f);
     } else if ((m->json_stream_data == qpdf_sj_file) && m->json_stream_prefix.empty()) {
         QTC::TC("qpdf", "QPDFJob need json-stream-prefix for stdout");
@@ -58,25 +58,25 @@ void
 ArgParser::initOptionTables()
 {
 #include <qpdf/auto_job_init.hh>
-    this->ap.addFinalCheck([this]() { c_main->checkConfiguration(); });
+    ap.addFinalCheck([this]() { c_main->checkConfiguration(); });
     // add_help is defined in auto_job_help.hh
-    add_help(this->ap);
+    add_help(ap);
     // Special case: ignore -- at the top level. This undocumented behavior is for backward
     // compatibility; it was unintentionally the case prior to 10.6, and some users were relying on
     // it.
-    this->ap.selectMainOptionTable();
-    this->ap.addBare("--", []() {});
+    ap.selectMainOptionTable();
+    ap.addBare("--", []() {});
 }
  
 void
 ArgParser::argPositional(std::string const& arg)
 {
-    if (!this->gave_input) {
+    if (!gave_input) {
         c_main->inputFile(arg);
-        this->gave_input = true;
-    } else if (!this->gave_output) {
+        gave_input = true;
+    } else if (!gave_output) {
         c_main->outputFile(arg);
-        this->gave_output = true;
+        gave_output = true;
     } else {
         usage("unknown argument " + arg);
     }
@@ -86,20 +86,20 @@ void
 ArgParser::argEmpty()
 {
     c_main->emptyInput();
-    this->gave_input = true;
+    gave_input = true;
 }
  
 void
 ArgParser::argReplaceInput()
 {
     c_main->replaceInput();
-    this->gave_output = true;
+    gave_output = true;
 }
  
 void
 ArgParser::argVersion()
 {
-    auto whoami = this->ap.getProgname();
+    auto whoami = ap.getProgname();
     *QPDFLogger::defaultLogger()->getInfo()
         << whoami << " version " << QPDF::QPDFVersion() << "\n"
         << "Run " << whoami << " --copyright to see copyright and license information.\n";
@@ -136,7 +136,7 @@ ArgParser::argCopyright()
     //               1         2         3         4         5         6         7         8
     //      12345678901234567890123456789012345678901234567890123456789012345678901234567890
     *QPDFLogger::defaultLogger()->getInfo()
-        << this->ap.getProgname()
+        << ap.getProgname()
         << " version " << QPDF::QPDFVersion() << "\n"
         << "\n"
         << "Copyright (c) 2005-2021 Jay Berkenbilt\n"
@@ -190,9 +190,9 @@ ArgParser::argShowCrypto()
 void
 ArgParser::argEncrypt()
 {
-    this->c_enc = c_main->encrypt(0, "", "");
-    this->accumulated_args.clear();
-    this->ap.selectOptionTable(O_ENCRYPTION);
+    c_enc = c_main->encrypt(0, "", "");
+    accumulated_args.clear();
+    ap.selectOptionTable(O_ENCRYPTION);
 }
  
 void
@@ -202,14 +202,14 @@ ArgParser::argEncPositional(std::string const&amp; arg)
         usage("positional and dashed encryption arguments may not be mixed");
     }
  
-    this->accumulated_args.push_back(arg);
-    if (this->accumulated_args.size() < 3) {
+    accumulated_args.push_back(arg);
+    if (accumulated_args.size() < 3) {
         return;
     }
-    user_password = this->accumulated_args.at(0);
-    owner_password = this->accumulated_args.at(1);
-    auto len_str = this->accumulated_args.at(2);
-    this->accumulated_args.clear();
+    user_password = accumulated_args.at(0);
+    owner_password = accumulated_args.at(1);
+    auto len_str = accumulated_args.at(2);
+    accumulated_args.clear();
     argEncBits(len_str);
 }
  
@@ -219,8 +219,8 @@ ArgParser::argEncUserPassword(std::string const&amp; arg)
     if (!accumulated_args.empty()) {
         usage("positional and dashed encryption arguments may not be mixed");
     }
-    this->used_enc_password_args = true;
-    this->user_password = arg;
+    used_enc_password_args = true;
+    user_password = arg;
 }
  
 void
@@ -229,8 +229,8 @@ ArgParser::argEncOwnerPassword(std::string const&amp; arg)
     if (!accumulated_args.empty()) {
         usage("positional and dashed encryption arguments may not be mixed");
     }
-    this->used_enc_password_args = true;
-    this->owner_password = arg;
+    used_enc_password_args = true;
+    owner_password = arg;
 }
  
 void
@@ -242,25 +242,25 @@ ArgParser::argEncBits(std::string const&amp; arg)
     int keylen = 0;
     if (arg == "40") {
         keylen = 40;
-        this->ap.selectOptionTable(O_40_BIT_ENCRYPTION);
+        ap.selectOptionTable(O_40_BIT_ENCRYPTION);
     } else if (arg == "128") {
         keylen = 128;
-        this->ap.selectOptionTable(O_128_BIT_ENCRYPTION);
+        ap.selectOptionTable(O_128_BIT_ENCRYPTION);
     } else if (arg == "256") {
         keylen = 256;
-        this->ap.selectOptionTable(O_256_BIT_ENCRYPTION);
+        ap.selectOptionTable(O_256_BIT_ENCRYPTION);
     } else {
         usage("encryption key length must be 40, 128, or 256");
     }
-    this->c_enc = c_main->encrypt(keylen, user_password, owner_password);
+    c_enc = c_main->encrypt(keylen, user_password, owner_password);
 }
  
 void
 ArgParser::argPages()
 {
-    this->accumulated_args.clear();
-    this->c_pages = c_main->pages();
-    this->ap.selectOptionTable(O_PAGES);
+    accumulated_args.clear();
+    c_pages = c_main->pages();
+    ap.selectOptionTable(O_PAGES);
 }
  
 void
@@ -308,29 +308,29 @@ ArgParser::argEndPages()
 void
 ArgParser::argUnderlay()
 {
-    this->c_uo = c_main->underlay();
-    this->ap.selectOptionTable(O_UNDERLAY_OVERLAY);
+    c_uo = c_main->underlay();
+    ap.selectOptionTable(O_UNDERLAY_OVERLAY);
 }
  
 void
 ArgParser::argOverlay()
 {
-    this->c_uo = c_main->overlay();
-    this->ap.selectOptionTable(O_UNDERLAY_OVERLAY);
+    c_uo = c_main->overlay();
+    ap.selectOptionTable(O_UNDERLAY_OVERLAY);
 }
  
 void
 ArgParser::argAddAttachment()
 {
-    this->c_att = c_main->addAttachment();
-    this->ap.selectOptionTable(O_ATTACHMENT);
+    c_att = c_main->addAttachment();
+    ap.selectOptionTable(O_ATTACHMENT);
 }
  
 void
 ArgParser::argCopyAttachmentsFrom()
 {
-    this->c_copy_att = c_main->copyAttachmentsFrom();
-    this->ap.selectOptionTable(O_COPY_ATTACHMENT);
+    c_copy_att = c_main->copyAttachmentsFrom();
+    ap.selectOptionTable(O_COPY_ATTACHMENT);
 }
  
 void
@@ -400,7 +400,7 @@ ArgParser::argEndCopyAttachment()
 void
 ArgParser::argSetPageLabels()
 {
-    this->ap.selectOptionTable(O_SET_PAGE_LABELS);
+    ap.selectOptionTable(O_SET_PAGE_LABELS);
     accumulated_args.clear();
 }
  
@@ -427,14 +427,14 @@ ArgParser::argJobJsonHelp()
 void
 ArgParser::usage(std::string const& message)
 {
-    this->ap.usage(message);
+    ap.usage(message);
 }
  
 void
 ArgParser::parseOptions()
 {
     try {
-        this->ap.parseArgs();
+        ap.parseArgs();
     } catch (std::runtime_error& e) {
         usage(e.what());
     }
@@ -15,8 +15,8 @@ QPDFJob::Config::checkConfiguration()
 QPDFJob::Config*
 QPDFJob::Config::inputFile(std::string const& filename)
 {
-    if (o.m->infilename == nullptr) {
-        o.m->infilename = QUtil::make_shared_cstr(filename);
+    if (o.m->infilename.empty()) {
+        o.m->infilename = filename;
     } else {
         usage("input file has already been given");
     }
@@ -26,13 +26,13 @@ QPDFJob::Config::inputFile(std::string const&amp; filename)
 QPDFJob::Config*
 QPDFJob::Config::emptyInput()
 {
-    if (o.m->infilename == nullptr) {
-        // Various places in QPDFJob.cc know that the empty string for infile means empty. We set it
-        // to something other than a null pointer as an indication that some input source has been
-        // specified. This approach means that passing "" as the argument to inputFile in job JSON,
-        // or equivalently using "" as a positional command-line argument would be the same as
-        // --empty. This probably isn't worth blocking or coding around.
-        o.m->infilename = QUtil::make_shared_cstr("");
+    if (o.m->infilename.empty()) {
+        // Various places in QPDFJob.cc used to know that the empty string for infile means empty.
+        // This approach meant that passing "" as the argument to inputFile in job JSON, or
+        // equivalently using "" as a positional command-line argument would be the same as
+        // --empty. This was deemed to be not worth blocking or coding around. This no longer holds
+        // from 12.3.
+        o.m->empty_input = true;
     } else {
         usage("empty input can't be used since input file has already been given");
     }
@@ -42,8 +42,8 @@ QPDFJob::Config::emptyInput()
 QPDFJob::Config*
 QPDFJob::Config::outputFile(std::string const& filename)
 {
-    if ((o.m->outfilename == nullptr) && (!o.m->replace_input)) {
-        o.m->outfilename = QUtil::make_shared_cstr(filename);
+    if (o.m->outfilename.empty() && !o.m->replace_input) {
+        o.m->outfilename = filename;
     } else {
         usage("output file has already been given");
     }
@@ -53,7 +53,7 @@ QPDFJob::Config::outputFile(std::string const&amp; filename)
 QPDFJob::Config*
 QPDFJob::Config::replaceInput()
 {
-    if ((o.m->outfilename == nullptr) && (!o.m->replace_input)) {
+    if (o.m->outfilename.empty() && !o.m->replace_input) {
         o.m->replace_input = true;
     } else {
         usage("replace-input can't be used since output file has already been given");
@@ -175,7 +175,7 @@ QPDFJob::Config::deterministicId()
 QPDFJob::Config*
 QPDFJob::Config::encryptionFilePassword(std::string const& parameter)
 {
-    o.m->encryption_file_password = QUtil::make_shared_cstr(parameter);
+    o.m->encryption_file_password = parameter;
     return this;
 }
  
@@ -456,7 +456,7 @@ QPDFJob::Config::optimizeImages()
 QPDFJob::Config*
 QPDFJob::Config::password(std::string const& parameter)
 {
-    o.m->password = QUtil::make_shared_cstr(parameter);
+    o.m->password = parameter;
     return this;
 }
  
@@ -696,12 +696,12 @@ QPDFJob::Config::passwordFile(std::string const&amp; parameter)
         QTC::TC("qpdf", "QPDFJob_config password file");
         lines = QUtil::read_lines_from_file(parameter.c_str());
     }
-    if (lines.size() >= 1) {
-        o.m->password = QUtil::make_shared_cstr(lines.front());
+    if (!lines.empty()) {
+        o.m->password = lines.front();
  
         if (lines.size() > 1) {
             *QPDFLogger::defaultLogger()->getError()
-                << this->o.m->message_prefix << ": WARNING: all but the first line of"
+                << o.m->message_prefix << ": WARNING: all but the first line of"
                 << " the password file are ignored\n";
         }
     }
@@ -806,7 +806,7 @@ QPDFJob::Config::jobJsonFile(std::string const&amp; parameter)
     } catch (std::exception& e) {
         throw std::runtime_error(
             "error with job-json file " + std::string(parameter) + ": " + e.what() + "\nRun " +
-            this->o.m->message_prefix + " --job-json-help for information on the file format.");
+            o.m->message_prefix + " --job-json-help for information on the file format.");
     }
     return this;
 }
@@ -832,32 +832,32 @@ QPDFJob::CopyAttConfig::CopyAttConfig(Config* c) :
 QPDFJob::CopyAttConfig*
 QPDFJob::CopyAttConfig::file(std::string const& parameter)
 {
-    this->caf.path = parameter;
+    caf.path = parameter;
     return this;
 }
  
 QPDFJob::CopyAttConfig*
 QPDFJob::CopyAttConfig::prefix(std::string const& parameter)
 {
-    this->caf.prefix = parameter;
+    caf.prefix = parameter;
     return this;
 }
  
 QPDFJob::CopyAttConfig*
 QPDFJob::CopyAttConfig::password(std::string const& parameter)
 {
-    this->caf.password = parameter;
+    caf.password = parameter;
     return this;
 }
  
 QPDFJob::Config*
 QPDFJob::CopyAttConfig::endCopyAttachmentsFrom()
 {
-    if (this->caf.path.empty()) {
+    if (caf.path.empty()) {
         usage("copy attachments: no file specified");
     }
-    this->config->o.m->attachments_to_copy.push_back(this->caf);
-    return this->config;
+    config->o.m->attachments_to_copy.push_back(caf);
+    return config;
 }
  
 QPDFJob::AttConfig::AttConfig(Config* c) :
@@ -874,21 +874,21 @@ QPDFJob::Config::addAttachment()
 QPDFJob::AttConfig*
 QPDFJob::AttConfig::file(std::string const& parameter)
 {
-    this->att.path = parameter;
+    att.path = parameter;
     return this;
 }
  
 QPDFJob::AttConfig*
 QPDFJob::AttConfig::key(std::string const& parameter)
 {
-    this->att.key = parameter;
+    att.key = parameter;
     return this;
 }
  
 QPDFJob::AttConfig*
 QPDFJob::AttConfig::filename(std::string const& parameter)
 {
-    this->att.filename = parameter;
+    att.filename = parameter;
     return this;
 }
  
@@ -898,7 +898,7 @@ QPDFJob::AttConfig::creationdate(std::string const&amp; parameter)
     if (!QUtil::pdf_time_to_qpdf_time(parameter)) {
         usage(std::string(parameter) + " is not a valid PDF timestamp");
     }
-    this->att.creationdate = parameter;
+    att.creationdate = parameter;
     return this;
 }
  
@@ -908,7 +908,7 @@ QPDFJob::AttConfig::moddate(std::string const&amp; parameter)
     if (!QUtil::pdf_time_to_qpdf_time(parameter)) {
         usage(std::string(parameter) + " is not a valid PDF timestamp");
     }
-    this->att.moddate = parameter;
+    att.moddate = parameter;
     return this;
 }
  
@@ -918,21 +918,21 @@ QPDFJob::AttConfig::mimetype(std::string const&amp; parameter)
     if (parameter.find('/') == std::string::npos) {
         usage("mime type should be specified as type/subtype");
     }
-    this->att.mimetype = parameter;
+    att.mimetype = parameter;
     return this;
 }
  
 QPDFJob::AttConfig*
 QPDFJob::AttConfig::description(std::string const& parameter)
 {
-    this->att.description = parameter;
+    att.description = parameter;
     return this;
 }
  
 QPDFJob::AttConfig*
 QPDFJob::AttConfig::replace()
 {
-    this->att.replace = true;
+    att.replace = true;
     return this;
 }
  
@@ -940,28 +940,28 @@ QPDFJob::Config*
 QPDFJob::AttConfig::endAddAttachment()
 {
     static std::string now = QUtil::qpdf_time_to_pdf_time(QUtil::get_current_qpdf_time());
-    if (this->att.path.empty()) {
+    if (att.path.empty()) {
         usage("add attachment: no file specified");
     }
-    std::string last_element = QUtil::path_basename(this->att.path);
+    std::string last_element = QUtil::path_basename(att.path);
     if (last_element.empty()) {
         usage("file for --add-attachment may not be empty");
     }
-    if (this->att.filename.empty()) {
-        this->att.filename = last_element;
+    if (att.filename.empty()) {
+        att.filename = last_element;
     }
-    if (this->att.key.empty()) {
-        this->att.key = last_element;
+    if (att.key.empty()) {
+        att.key = last_element;
     }
-    if (this->att.creationdate.empty()) {
-        this->att.creationdate = now;
+    if (att.creationdate.empty()) {
+        att.creationdate = now;
     }
-    if (this->att.moddate.empty()) {
-        this->att.moddate = now;
+    if (att.moddate.empty()) {
+        att.moddate = now;
     }
  
-    this->config->o.m->attachments_to_add.push_back(this->att);
-    return this->config;
+    config->o.m->attachments_to_add.push_back(att);
+    return config;
 }
  
 QPDFJob::PagesConfig::PagesConfig(Config* c) :
@@ -985,21 +985,21 @@ QPDFJob::PagesConfig::endPages()
     if (n_specs == 0) {
         usage("--pages: no page specifications given");
     }
-    return this->config;
+    return config;
 }
  
 QPDFJob::PagesConfig*
 QPDFJob::PagesConfig::pageSpec(
     std::string const& filename, std::string const& range, char const* password)
 {
-    this->config->o.m->page_specs.emplace_back(filename, password, range);
+    config->o.m->page_specs.emplace_back(filename, password, range);
     return this;
 }
  
 QPDFJob::PagesConfig*
 QPDFJob::PagesConfig::file(std::string const& arg)
 {
-    this->config->o.m->page_specs.emplace_back(arg, nullptr, "");
+    config->o.m->page_specs.emplace_back(arg, "", "");
     return this;
 }
  
@@ -1027,11 +1027,11 @@ QPDFJob::PagesConfig::password(std::string const&amp; arg)
         usage("in --pages, --password must follow a file name");
     }
     auto& last = config->o.m->page_specs.back();
-    if (last.password) {
+    if (!last.password.empty()) {
         QTC::TC("qpdf", "QPDFJob duplicated pages password");
         usage("--password already specified for this file");
     }
-    last.password = QUtil::make_shared_cstr(arg);
+    last.password = arg;
     return this;
 }
  
@@ -1063,7 +1063,7 @@ QPDFJob::UOConfig::endUnderlayOverlay()
         usage(config->o.m->under_overlay->which + " file not specified");
     }
     config->o.m->under_overlay = nullptr;
-    return this->config;
+    return config;
 }
  
 QPDFJob::UOConfig*
@@ -1108,7 +1108,7 @@ QPDFJob::UOConfig::repeat(std::string const&amp; parameter)
 QPDFJob::UOConfig*
 QPDFJob::UOConfig::password(std::string const& parameter)
 {
-    config->o.m->under_overlay->password = QUtil::make_shared_cstr(parameter);
+    config->o.m->under_overlay->password = parameter;
     return this;
 }
  
@@ -1192,7 +1192,7 @@ QPDFJob::EncConfig::endEncrypt()
     config->o.m->encrypt = true;
     config->o.m->decrypt = false;
     config->o.m->copy_encryption = false;
-    return this->config;
+    return config;
 }
  
 QPDFJob::EncConfig*
@@ -1341,5 +1341,5 @@ QPDFJob::PageLabelsConfig::PageLabelsConfig(Config* c) :
 QPDFJob::Config*
 QPDFJob::PageLabelsConfig::endSetPageLabels()
 {
-    return this->config;
+    return config;
 }
@@ -630,7 +630,7 @@ QPDFJob::initializeFromJson(std::string const&amp; json, bool partial)
         std::ostringstream msg;
         msg << m->message_prefix << ": job json has errors:";
         for (auto const& error: errors) {
-            msg << std::endl << "  " << error;
+            msg << "\n  " << error;
         }
         throw std::runtime_error(msg.str());
     }
@@ -467,7 +467,7 @@ BaseHandle::write_json(int json_version, JSON::Writer&amp; p) const
     case ::ot_real:
         {
             auto const& val = std::get<QPDF_Real>(obj->value).val;
-            if (val.length() == 0) {
+            if (val.empty()) {
                 // Can't really happen...
                 p << "0";
             } else if (val.at(0) == '.') {
@@ -1184,7 +1184,7 @@ QPDFObjectHandle::mergeResources(
                             initialized_maps = true;
                         }
                         auto rval_og = rval.getObjGen();
-                        if (rval.isIndirect() && og_to_name.count(rval_og)) {
+                        if (rval.isIndirect() && og_to_name.contains(rval_og)) {
                             QTC::TC("qpdf", "QPDFObjectHandle merge reuse");
                             auto new_key = og_to_name[rval_og];
                             if (new_key != key) {
@@ -1208,7 +1208,7 @@ QPDFObjectHandle::mergeResources(
                 }
                 for (auto other_item: other_val.aitems()) {
                     if (other_item.isScalar()) {
-                        if (scalars.count(other_item.unparse()) == 0) {
+                        if (!scalars.contains(other_item.unparse())) {
                             QTC::TC("qpdf", "QPDFObjectHandle merge array");
                             this_val.appendItem(other_item);
                         } else {
@@ -1247,7 +1247,7 @@ QPDFObjectHandle::getUniqueResourceName(
     int max_suffix = min_suffix + QIntC::to_int(names.size());
     while (min_suffix <= max_suffix) {
         std::string candidate = prefix + std::to_string(min_suffix);
-        if (names.count(candidate) == 0) {
+        if (!names.contains(candidate)) {
             return candidate;
         }
         // Increment after return; min_suffix should be the value
@@ -56,7 +56,7 @@ QPDFOutlineDocumentHelper::getOutlinesForPage(QPDFObjGen og)
         initializeByPage();
     }
     std::vector<QPDFOutlineObjectHelper> result;
-    if (m->by_page.count(og)) {
+    if (m->by_page.contains(og)) {
         result = m->by_page[og];
     }
     return result;
@@ -593,7 +593,7 @@ QPDFPageObjectHelper::removeUnreferencedResourcesHelper(
     for (auto const& i1: to_filter) {
         for (auto const& n_iter: names_by_rtype[i1]) {
             std::string const& name = n_iter.first;
-            if (!known_names.count(name)) {
+            if (!known_names.contains(name)) {
                 unresolved.insert(name);
                 local_unresolved.insert(name);
             }
@@ -624,10 +624,10 @@ QPDFPageObjectHelper::removeUnreferencedResourcesHelper(
  
     for (auto& dict: rdicts) {
         for (auto const& key: dict.getKeys()) {
-            if (is_page && unresolved.count(key)) {
+            if (is_page && unresolved.contains(key)) {
                 // This name is referenced by some nested form xobject, so don't remove it.
                 QTC::TC("qpdf", "QPDFPageObjectHelper resolving unresolved");
-            } else if (!rf.getNames().count(key)) {
+            } else if (!rf.getNames().contains(key)) {
                 dict.removeKey(key);
             }
         }
@@ -354,9 +354,9 @@ QPDFParser::parseRemainder(bool content_stream)
                     fixMissingKeys();
                 }
  
-                if (!frame->contents_string.empty() && dict.count("/Type") &&
-                    dict["/Type"].isNameAndEquals("/Sig") && dict.count("/ByteRange") &&
-                    dict.count("/Contents") && dict["/Contents"].isString()) {
+                if (!frame->contents_string.empty() && dict.contains("/Type") &&
+                    dict["/Type"].isNameAndEquals("/Sig") && dict.contains("/ByteRange") &&
+                    dict.contains("/Contents") && dict["/Contents"].isString()) {
                     dict["/Contents"] = QPDFObjectHandle::newString(frame->contents_string);
                     dict["/Contents"].setParsedOffset(frame->contents_offset);
                 }
@@ -560,7 +560,7 @@ QPDFParser::fixMissingKeys()
     for (auto const& item: frame->olist) {
         while (true) {
             const std::string key = "/QPDFFake" + std::to_string(next_fake_key++);
-            const bool found_fake = frame->dict.count(key) == 0 && names.count(key) == 0;
+            const bool found_fake = !frame->dict.contains(key) && !names.contains(key);
             QTC::TC("qpdf", "QPDFParser found fake", (found_fake ? 0 : 1));
             if (found_fake) {
                 warn(
@@ -271,7 +271,7 @@ void
 QPDFWriter::setExtraHeaderText(std::string const& text)
 {
     m->extra_header_text = text;
-    if ((m->extra_header_text.length() > 0) && (*(m->extra_header_text.rbegin()) != '\n')) {
+    if (!m->extra_header_text.empty() && *m->extra_header_text.rbegin() != '\n') {
         QTC::TC("qpdf", "QPDFWriter extra header text add newline");
         m->extra_header_text += "\n";
     } else {
@@ -1065,7 +1065,7 @@ void
 QPDFWriter::assignCompressedObjectNumbers(QPDFObjGen og)
 {
     int objid = og.getObj();
-    if ((og.getGen() != 0) || (m->object_stream_to_objects.count(objid) == 0)) {
+    if ((og.getGen() != 0) || (!m->object_stream_to_objects.contains(objid))) {
         // This is not an object stream.
         return;
     }
@@ -1115,7 +1115,7 @@ QPDFWriter::enqueueObject(QPDFObjectHandle object)
                 m->object_queue.push_back(object);
                 obj.renumber = m->next_objid++;
  
-                if ((og.getGen() == 0) && m->object_stream_to_objects.count(og.getObj())) {
+                if ((og.getGen() == 0) && m->object_stream_to_objects.contains(og.getObj())) {
                     // For linearized files, uncompressed objects go at end, and we take care of
                     // assigning numbers to them elsewhere.
                     if (!m->linearized) {
@@ -1285,7 +1285,7 @@ QPDFWriter::willFilterStream(
         filter = true;
         compress_stream = false;
         uncompress = true;
-    } else if (filter_on_write && m->normalize_content && m->normalized_streams.count(old_og)) {
+    } else if (filter_on_write && m->normalize_content && m->normalized_streams.contains(old_og)) {
         normalize = true;
         filter = true;
     } else if (filter_on_write && filter && m->compress_streams) {
@@ -1415,11 +1415,11 @@ QPDFWriter::unparseObject(
  
         if (extensions) {
             std::set<std::string> keys = extensions.getKeys();
-            if (keys.count("/ADBE") > 0) {
+            if (keys.contains("/ADBE")) {
                 have_extensions_adbe = true;
                 keys.erase("/ADBE");
             }
-            if (keys.size() > 0) {
+            if (!keys.empty()) {
                 have_extensions_other = true;
             }
         }
@@ -1807,12 +1807,12 @@ QPDFWriter::writeObject(QPDFObjectHandle object, int object_stream_index)
     indicateProgress(false, false);
     auto new_id = m->obj[old_og].renumber;
     if (m->qdf_mode) {
-        if (m->page_object_to_seq.count(old_og)) {
+        if (m->page_object_to_seq.contains(old_og)) {
             writeString("%% Page ");
             writeString(std::to_string(m->page_object_to_seq[old_og]));
             writeString("\n");
         }
-        if (m->contents_to_page_seq.count(old_og)) {
+        if (m->contents_to_page_seq.contains(old_og)) {
             writeString("%% Contents for page ");
             writeString(std::to_string(m->contents_to_page_seq[old_og]));
             writeString("\n");
@@ -2285,7 +2285,7 @@ QPDFWriter::write()
 QPDFObjGen
 QPDFWriter::getRenumberedObjGen(QPDFObjGen og)
 {
-    return QPDFObjGen(m->obj[og].renumber, 0);
+    return {m->obj[og].renumber, 0};
 }
  
 std::map<QPDFObjGen, QPDFXRefEntry>
@@ -20,7 +20,7 @@ bool
 BaseDictionary::hasKey(std::string const& key) const
 {
     auto d = dict();
-    return d->items.count(key) > 0 && !d->items[key].isNull();
+    return d->items.contains(key) && !d->items[key].null();
 }
  
 QPDFObjectHandle
@@ -702,17 +702,17 @@ QPDF::interpretCF(std::shared_ptr&lt;EncryptionParameters&gt; encp, QPDFObjectHandle c
 {
     if (cf.isName()) {
         std::string filter = cf.getName();
-        if (encp->crypt_filters.count(filter) != 0) {
-            return encp->crypt_filters[filter];
-        } else if (filter == "/Identity") {
+        auto it = encp->crypt_filters.find(filter);
+        if (it != encp->crypt_filters.end()) {
+            return it->second;
+        }
+        if (filter == "/Identity") {
             return e_none;
-        } else {
-            return e_unknown;
         }
-    } else {
-        // Default: /Identity
-        return e_none;
+        return e_unknown;
     }
+    // Default: /Identity
+    return e_none;
 }
  
 void
@@ -161,7 +161,7 @@ QPDF::test_json_validators()
     auto check_fn = [&passed](char const* msg, bool expr) {
         if (!expr) {
             passed = false;
-            std::cerr << msg << std::endl;
+            std::cerr << msg << '\n';
         }
     };
 #define check(expr) check_fn(#expr, expr)
@@ -192,7 +192,7 @@ QPDF::test_json_validators()
     check(is_unicode_string("u:potato", str));
     check(str == "potato");
     check(is_unicode_string("u:", str));
-    check(str == "");
+    check(str.empty());
     check(!is_binary_string("", str));
     check(!is_binary_string("x:", str));
     check(!is_binary_string("b:1", str));
@@ -889,7 +889,7 @@ QPDF::writeJSON(
     for (auto& obj: getAllObjects()) {
         auto const og = obj.getObjGen();
         std::string key = "obj:" + og.unparse(' ') + " R";
-        if (all_objects || wanted_objects.count(key)) {
+        if (all_objects || wanted_objects.contains(key)) {
             if (first) {
                 jw << "\n      \"" << key;
                 first = false;
@@ -911,7 +911,7 @@ QPDF::writeJSON(
             }
         }
     }
-    if (all_objects || wanted_objects.count("trailer")) {
+    if (all_objects || wanted_objects.contains("trailer")) {
         if (!first) {
             jw << "\n      },";
         }
@@ -10,7 +10,7 @@
 #include <qpdf/Pl_Flate.hh>
 #include <qpdf/Pl_String.hh>
 #include <qpdf/QPDFExc.hh>
-#include <qpdf/QPDFLogger.hh>
+#include <qpdf/QPDFObjectHandle_private.hh>
 #include <qpdf/QPDFWriter_private.hh>
 #include <qpdf/QTC.hh>
 #include <qpdf/QUtil.hh>
@@ -502,7 +502,7 @@ QPDF::checkLinearizationInternal()
     qpdf_offset_t max_E = -1;
     for (auto const& oh: m->part6) {
         QPDFObjGen og(oh.getObjGen());
-        if (m->obj_cache.count(og) == 0) {
+        if (!m->obj_cache.contains(og)) {
             // All objects have to have been dereferenced to be classified.
             throw std::logic_error("linearization part6 object not in cache");
         }
@@ -530,12 +530,12 @@ QPDF::checkLinearizationInternal()
 qpdf_offset_t
 QPDF::maxEnd(ObjUser const& ou)
 {
-    if (m->obj_user_to_objects.count(ou) == 0) {
+    if (!m->obj_user_to_objects.contains(ou)) {
         stopOnError("no entry in object user table for requested object user");
     }
     qpdf_offset_t end = 0;
     for (auto const& og: m->obj_user_to_objects[ou]) {
-        if (!m->obj_cache.count(og)) {
+        if (!m->obj_cache.contains(og)) {
             stopOnError("unknown object referenced in object user table");
         }
         end = std::max(end, m->obj_cache[og].end_after_space);
@@ -568,7 +568,7 @@ QPDF::getLinearizationOffset(QPDFObjGen og)
 QPDFObjectHandle
 QPDF::getUncompressedObject(QPDFObjectHandle& obj, std::map<int, int> const& object_stream_data)
 {
-    if (obj.isNull() || (object_stream_data.count(obj.getObjectID()) == 0)) {
+    if (obj.null() || (!object_stream_data.contains(obj.getObjectID()))) {
         return obj;
     } else {
         int repl = (*(object_stream_data.find(obj.getObjectID()))).second;
@@ -593,11 +593,11 @@ QPDF::lengthNextN(int first_object, int n)
     int length = 0;
     for (int i = 0; i < n; ++i) {
         QPDFObjGen og(first_object + i, 0);
-        if (m->xref_table.count(og) == 0) {
+        if (!m->xref_table.contains(og)) {
             linearizationWarning(
                 "no xref table entry for " + std::to_string(first_object + i) + " 0");
         } else {
-            if (m->obj_cache.count(og) == 0) {
+            if (!m->obj_cache.contains(og)) {
                 stopOnError("found unknown object while calculating length for linearization data");
             }
             length += toI(m->obj_cache[og].end_after_space - getLinearizationOffset(og));
@@ -625,7 +625,7 @@ QPDF::checkHPageOffset(
     int npages = toI(pages.size());
     qpdf_offset_t table_offset = adjusted_offset(m->page_offset_hints.first_page_offset);
     QPDFObjGen first_page_og(pages.at(0).getObjGen());
-    if (m->xref_table.count(first_page_og) == 0) {
+    if (!m->xref_table.contains(first_page_og)) {
         stopOnError("supposed first page object is not known");
     }
     qpdf_offset_t offset = getLinearizationOffset(first_page_og);
@@ -636,7 +636,7 @@ QPDF::checkHPageOffset(
     for (int pageno = 0; pageno < npages; ++pageno) {
         QPDFObjGen page_og(pages.at(toS(pageno)).getObjGen());
         int first_object = page_og.getObj();
-        if (m->xref_table.count(page_og) == 0) {
+        if (!m->xref_table.contains(page_og)) {
             stopOnError("unknown object in page offset hint table");
         }
         offset = getLinearizationOffset(page_og);
@@ -677,7 +677,7 @@ QPDF::checkHPageOffset(
  
         for (size_t i = 0; i < toS(he.nshared_objects); ++i) {
             int idx = he.shared_identifiers.at(i);
-            if (shared_idx_to_obj.count(idx) == 0) {
+            if (!shared_idx_to_obj.contains(idx)) {
                 stopOnError("unable to get object for item in shared objects hint table");
             }
             hint_shared.insert(shared_idx_to_obj[idx]);
@@ -693,7 +693,7 @@ QPDF::checkHPageOffset(
         }
  
         for (int iter: hint_shared) {
-            if (!computed_shared.count(iter)) {
+            if (!computed_shared.contains(iter)) {
                 // pdlin puts thumbnails here even though it shouldn't
                 linearizationWarning(
                     "page " + std::to_string(pageno) + ": shared object " + std::to_string(iter) +
@@ -702,7 +702,7 @@ QPDF::checkHPageOffset(
         }
  
         for (int iter: computed_shared) {
-            if (!hint_shared.count(iter)) {
+            if (!hint_shared.contains(iter)) {
                 // Acrobat does not put some things including at least built-in fonts and procsets
                 // here, at least in some cases.
                 linearizationWarning(
@@ -755,7 +755,7 @@ QPDF::checkHSharedObject(std::vector&lt;QPDFObjectHandle&gt; const&amp; pages, std::map&lt;in
                 cur_object = so.first_shared_obj;
  
                 QPDFObjGen og(cur_object, 0);
-                if (m->xref_table.count(og) == 0) {
+                if (!m->xref_table.contains(og)) {
                     stopOnError("unknown object in shared object hint table");
                 }
                 qpdf_offset_t offset = getLinearizationOffset(og);
@@ -806,7 +806,7 @@ QPDF::checkHOutlines()
                 return;
             }
             QPDFObjGen og(outlines.getObjGen());
-            if (m->xref_table.count(og) == 0) {
+            if (!m->xref_table.contains(og)) {
                 stopOnError("unknown object in outlines hint table");
             }
             qpdf_offset_t offset = getLinearizationOffset(og);
@@ -1086,7 +1086,7 @@ QPDF::calculateLinearizationData(T const&amp; object_stream_data)
                 break;
  
             case ObjUser::ou_root_key:
-                if (open_document_keys.count(ou.key) > 0) {
+                if (open_document_keys.contains(ou.key)) {
                     in_open_document = true;
                 } else if (ou.key == "/Outlines") {
                     in_outlines = true;
@@ -1187,7 +1187,7 @@ QPDF::calculateLinearizationData(T const&amp; object_stream_data)
         stopOnError("no pages found while calculating linearization data");
     }
     QPDFObjGen first_page_og(pages.at(0).getObjGen());
-    if (!lc_first_page_private.count(first_page_og)) {
+    if (!lc_first_page_private.contains(first_page_og)) {
         stopOnError(
             "INTERNAL ERROR: QPDF::calculateLinearizationData: first page "
             "object not in lc_first_page_private");
@@ -1226,7 +1226,7 @@ QPDF::calculateLinearizationData(T const&amp; object_stream_data)
         // Place this page's page object
  
         QPDFObjGen page_og(pages.at(i).getObjGen());
-        if (!lc_other_page_private.count(page_og)) {
+        if (!lc_other_page_private.contains(page_og)) {
             stopOnError(
                 "INTERNAL ERROR: QPDF::calculateLinearizationData: page object for page " +
                 std::to_string(i) + " not in lc_other_page_private");
@@ -1240,11 +1240,11 @@ QPDF::calculateLinearizationData(T const&amp; object_stream_data)
         m->c_page_offset_data.entries.at(i).nobjects = 1;
  
         ObjUser ou(ObjUser::ou_page, toI(i));
-        if (m->obj_user_to_objects.count(ou) == 0) {
+        if (!m->obj_user_to_objects.contains(ou)) {
             stopOnError("found unreferenced page while calculating linearization data");
         }
         for (auto const& og: m->obj_user_to_objects[ou]) {
-            if (lc_other_page_private.count(og)) {
+            if (lc_other_page_private.contains(og)) {
                 lc_other_page_private.erase(og);
                 m->part7.push_back(getObject(og));
                 ++m->c_page_offset_data.entries.at(i).nobjects;
@@ -1279,7 +1279,7 @@ QPDF::calculateLinearizationData(T const&amp; object_stream_data)
         stopOnError("found empty pages tree while calculating linearization data");
     }
     for (auto const& og: pages_ogs) {
-        if (lc_other.count(og)) {
+        if (lc_other.contains(og)) {
             lc_other.erase(og);
             m->part9.push_back(getObject(og));
         }
@@ -1293,7 +1293,7 @@ QPDF::calculateLinearizationData(T const&amp; object_stream_data)
         if (!thumb.isNull()) {
             // Output the thumbnail itself
             QPDFObjGen thumb_og(thumb.getObjGen());
-            if (lc_thumbnail_private.count(thumb_og)) {
+            if (lc_thumbnail_private.contains(thumb_og)) {
                 lc_thumbnail_private.erase(thumb_og);
                 m->part9.push_back(thumb);
             } else {
@@ -1304,7 +1304,7 @@ QPDF::calculateLinearizationData(T const&amp; object_stream_data)
             }
             std::set<QPDFObjGen>& ogs = m->obj_user_to_objects[ObjUser(ObjUser::ou_thumb, toI(i))];
             for (auto const& og: ogs) {
-                if (lc_thumbnail_private.count(og)) {
+                if (lc_thumbnail_private.contains(og)) {
                     lc_thumbnail_private.erase(og);
                     m->part9.push_back(getObject(og));
                 }
@@ -1384,11 +1384,11 @@ QPDF::calculateLinearizationData(T const&amp; object_stream_data)
     for (size_t i = 1; i < toS(npages); ++i) {
         CHPageOffsetEntry& pe = m->c_page_offset_data.entries.at(i);
         ObjUser ou(ObjUser::ou_page, toI(i));
-        if (m->obj_user_to_objects.count(ou) == 0) {
+        if (!m->obj_user_to_objects.contains(ou)) {
             stopOnError("found unreferenced page while calculating linearization data");
         }
         for (auto const& og: m->obj_user_to_objects[ou]) {
-            if ((m->object_to_obj_users[og].size() > 1) && (obj_to_index.count(og.getObj()) > 0)) {
+            if ((m->object_to_obj_users[og].size() > 1) && (obj_to_index.contains(og.getObj()))) {
                 int idx = obj_to_index[og.getObj()];
                 ++pe.nshared_objects;
                 pe.shared_identifiers.push_back(idx);
@@ -153,7 +153,7 @@ QPDF::parse(char const* password)
  
     initializeEncryption();
     m->parsed = true;
-    if (m->xref_table.size() > 0 && !getRoot().getKey("/Pages").isDictionary()) {
+    if (!m->xref_table.empty() && !getRoot().getKey("/Pages").isDictionary()) {
         // QPDFs created from JSON have an empty xref table and no root object yet.
         throw damagedPDF("", -1, "unable to find page tree");
     }
@@ -442,7 +442,7 @@ QPDF::read_xref(qpdf_offset_t xref_offset, bool in_stream_recovery)
         } else {
             xref_offset = read_xrefStream(xref_offset, in_stream_recovery);
         }
-        if (visited.count(xref_offset) != 0) {
+        if (visited.contains(xref_offset)) {
             QTC::TC("qpdf", "QPDF xref loop");
             throw damagedPDF("", -1, "loop detected following xref tables");
         }
@@ -1020,7 +1020,7 @@ QPDF::insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2)
         return;
     }
  
-    if (m->deleted_objects.count(obj)) {
+    if (m->deleted_objects.contains(obj)) {
         QTC::TC("qpdf", "QPDF xref deleted object");
         return;
     }
@@ -1056,7 +1056,7 @@ QPDF::insertXrefEntry(int obj, int f0, qpdf_offset_t f1, int f2)
 void
 QPDF::insertFreeXrefEntry(QPDFObjGen og)
 {
-    if (!m->xref_table.count(og)) {
+    if (!m->xref_table.contains(og)) {
         m->deleted_objects.insert(og.getObj());
     }
 }
@@ -1476,7 +1476,7 @@ QPDF::readObjectAtOffset(
         if (try_recovery) {
             // Try again after reconstructing xref table
             reconstruct_xref(e);
-            if (m->xref_table.count(exp_og) && (m->xref_table[exp_og].getType() == 1)) {
+            if (m->xref_table.contains(exp_og) && m->xref_table[exp_og].getType() == 1) {
                 qpdf_offset_t new_offset = m->xref_table[exp_og].getOffset();
                 QPDFObjectHandle result =
                     readObjectAtOffset(false, new_offset, description, exp_og, og, false);
@@ -1522,7 +1522,7 @@ QPDF::readObjectAtOffset(
             }
         }
         qpdf_offset_t end_after_space = m->file->tell();
-        if (skip_cache_if_in_xref && m->xref_table.count(og)) {
+        if (skip_cache_if_in_xref && m->xref_table.contains(og)) {
             // Ordinarily, an object gets read here when resolved through xref table or stream. In
             // the special case of the xref stream and linearization hint tables, the offset comes
             // from another source. For the specific case of xref streams, the xref stream is read
@@ -1564,7 +1564,7 @@ QPDF::resolve(QPDFObjGen og)
         return m->obj_cache[og].object;
     }
  
-    if (m->resolving.count(og)) {
+    if (m->resolving.contains(og)) {
         // This can happen if an object references itself directly or indirectly in some key that
         // has to be resolved during object parsing, such as stream length.
         QTC::TC("qpdf", "QPDF recursion loop in resolve");
@@ -1574,7 +1574,7 @@ QPDF::resolve(QPDFObjGen og)
     }
     ResolveRecorder rr(this, og);
  
-    if (m->xref_table.count(og) != 0) {
+    if (m->xref_table.contains(og)) {
         QPDFXRefEntry const& entry = m->xref_table[og];
         try {
             switch (entry.getType()) {
@@ -1628,7 +1628,7 @@ QPDF::resolveObjectsInStream(int obj_stream_number)
             true};
     };
  
-    if (m->resolved_object_streams.count(obj_stream_number)) {
+    if (m->resolved_object_streams.contains(obj_stream_number)) {
         return;
     }
     m->resolved_object_streams.insert(obj_stream_number);
@@ -1791,7 +1791,7 @@ QPDF::updateCache(
 bool
 QPDF::isCached(QPDFObjGen og)
 {
-    return m->obj_cache.count(og) != 0;
+    return m->obj_cache.contains(og);
 }
  
 bool
@@ -1807,7 +1807,7 @@ QPDF::nextObjGen()
     if (max_objid == std::numeric_limits<int>::max()) {
         throw std::range_error("max object id is too high to create new objects");
     }
-    return QPDFObjGen(max_objid + 1, 0);
+    return {max_objid + 1, 0};
 }
  
 QPDFObjectHandle
@@ -1835,7 +1835,7 @@ QPDF::getObjectForParser(int id, int gen, bool parse_pdf)
     if (auto iter = m->obj_cache.find(og); iter != m->obj_cache.end()) {
         return iter->second.object;
     }
-    if (m->xref_table.count(og) || !m->parsed) {
+    if (m->xref_table.contains(og) || !m->parsed) {
         return m->obj_cache.insert({og, QPDFObject::create<QPDF_Unresolved>(this, og)})
             .first->second.object;
     }
@@ -1852,7 +1852,7 @@ QPDF::getObjectForJSON(int id, int gen)
     auto [it, inserted] = m->obj_cache.try_emplace(og);
     auto& obj = it->second.object;
     if (inserted) {
-        obj = (m->parsed && !m->xref_table.count(og))
+        obj = (m->parsed && !m->xref_table.contains(og))
             ? QPDFObject::create<QPDF_Null>(this, og)
             : QPDFObject::create<QPDF_Unresolved>(this, og);
     }
@@ -1864,7 +1864,7 @@ QPDF::getObject(QPDFObjGen og)
 {
     if (auto it = m->obj_cache.find(og); it != m->obj_cache.end()) {
         return {it->second.object};
-    } else if (m->parsed && !m->xref_table.count(og)) {
+    } else if (m->parsed && !m->xref_table.contains(og)) {
         return QPDFObject::create<QPDF_Null>();
     } else {
         auto result =
@@ -1932,8 +1932,8 @@ QPDF::tableSize()
 {
     // If obj_cache is dense, accommodate all object in tables,else accommodate only original
     // objects.
-    auto max_xref = m->xref_table.size() ? m->xref_table.crbegin()->first.getObj() : 0;
-    auto max_obj = m->obj_cache.size() ? m->obj_cache.crbegin()->first.getObj() : 0;
+    auto max_xref = !m->xref_table.empty() ? m->xref_table.crbegin()->first.getObj() : 0;
+    auto max_obj = !m->obj_cache.empty() ? m->obj_cache.crbegin()->first.getObj() : 0;
     auto max_id = std::numeric_limits<int>::max() - 1;
     if (max_obj >= max_id || max_xref >= max_id) {
         // Temporary fix. Long-term solution is
@@ -303,7 +303,7 @@ QPDF::insertPage(QPDFObjectHandle newpage, int pos)
                                               : 2); // insert in middle
  
     auto og = newpage.getObjGen();
-    if (m->pageobj_to_pages_pos.count(og)) {
+    if (m->pageobj_to_pages_pos.contains(og)) {
         QTC::TC("qpdf", "QPDF resolve duplicated page in insert");
         newpage = makeIndirectObject(QPDFObjectHandle(newpage).shallowCopy());
     }
@@ -39,7 +39,7 @@ QTC::TC_real(char const* const scope, char const* const ccase, int n)
     }
 #undef TC_ENV
  
-    if (cache.count(std::make_pair(ccase, n))) {
+    if (cache.contains(std::make_pair(ccase, n))) {
         return;
     }
     cache.insert(std::make_pair(ccase, n));
@@ -1395,7 +1395,7 @@ QUtil::parse_numrange(char const* range, int max)
                 work = last_group;
                 last_group.clear();
                 for (auto n: work) {
-                    if (exclusions.count(n) == 0) {
+                    if (!exclusions.contains(n)) {
                         last_group.emplace_back(n);
                     }
                 }
@@ -1886,7 +1886,7 @@ QUtil::possible_repaired_encodings(std::string supplied)
     std::vector<std::string> t;
     std::set<std::string> seen;
     for (auto const& iter: result) {
-        if (!seen.count(iter)) {
+        if (!seen.contains(iter)) {
             seen.insert(iter);
             t.push_back(iter);
         }
@@ -1988,7 +1988,7 @@ QUtil::get_max_memory_usage()
                     attrs[m2->str(1)] = m2->str(2);
                 }
                 if (tag == "total") {
-                    if (attrs.count("size") > 0) {
+                    if (attrs.contains("size")) {
                         result += QIntC::to_size(QUtil::string_to_ull(attrs["size"].c_str()));
                     }
                 } else if (tag == "system" && attrs["type"] == "max") {
 #include <qpdf/ResourceFinder.hh>
  
-ResourceFinder::ResourceFinder() :
-    last_name_offset(0)
-{
-}
-
 void
 ResourceFinder::handleObject(QPDFObjectHandle obj, size_t offset, size_t)
 {
@@ -25,7 +25,7 @@ class AES_PDF_native
     unsigned char* cbc_block;
     std::unique_ptr<unsigned char[]> key;
     std::unique_ptr<uint32_t[]> rk;
-    unsigned int nrounds;
+    unsigned int nrounds{0};
 };
  
 #endif // AES_PDF_NATIVE_HH
@@ -21,8 +21,8 @@ class BitWriter
  
   private:
     Pipeline* pl;
-    unsigned char ch;
-    size_t bit_offset;
+    unsigned char ch{0};
+    size_t bit_offset{7};
 };
  
 #endif // BITWRITER_HH
@@ -6,7 +6,7 @@
 class ContentNormalizer final: public QPDFObjectHandle::TokenFilter
 {
   public:
-    ContentNormalizer();
+    ContentNormalizer() = default;
     ~ContentNormalizer() final = default;
     void handleToken(QPDFTokenizer::Token const&) final;
  
@@ -22,8 +22,8 @@ class ContentNormalizer final: public QPDFObjectHandle::TokenFilter
     }
  
   private:
-    bool any_bad_tokens;
-    bool last_token_was_bad;
+    bool any_bad_tokens{false};
+    bool last_token_was_bad{false};
 };
  
 #endif // CONTENTNORMALIZER_HH
@@ -3,18 +3,18 @@
  
 #include <qpdf/RandomDataProvider.hh>
  
-class InsecureRandomDataProvider: public RandomDataProvider
+class InsecureRandomDataProvider final: public RandomDataProvider
 {
   public:
-    InsecureRandomDataProvider();
-    ~InsecureRandomDataProvider() override = default;
-    void provideRandomData(unsigned char* data, size_t len) override;
+    InsecureRandomDataProvider() = default;
+    ~InsecureRandomDataProvider() final = default;
+    void provideRandomData(unsigned char* data, size_t len) final;
     static RandomDataProvider* getInstance();
  
   private:
     long random();
  
-    bool seeded_random;
+    bool seeded_random{false};
 };
  
 #endif // INSECURERANDOMDATAPROVIDER_HH
@@ -84,7 +84,7 @@ class NNTreeIterator
     NNTreeImpl& impl;
     std::list<PathElement> path;
     QPDFObjectHandle node;
-    int item_number;
+    int item_number{-1};
     value_type ivalue;
 };
  
@@ -123,7 +123,7 @@ class NNTreeImpl
  
     NNTreeDetails const& details;
     QPDF& qpdf;
-    int split_threshold;
+    int split_threshold{32};
     QPDFObjectHandle oh;
     bool auto_repair;
 };
@@ -25,7 +25,7 @@ class Pl_SHA2 final: public Pipeline
     std::string getRawDigest();
  
   private:
-    bool in_progress;
+    bool in_progress{false};
     std::shared_ptr<QPDFCryptoImpl> crypto;
 };
  
@@ -206,9 +206,9 @@ class QPDFArgParser
         char const* const* argv;
         std::string whoami;
         std::string progname_env;
-        int cur_arg;
-        bool bash_completion;
-        bool zsh_completion;
+        int cur_arg{0};
+        bool bash_completion{false};
+        bool zsh_completion{false};
         std::string bash_prev;
         std::string bash_cur;
         std::string bash_line;
@@ -216,13 +216,13 @@ class QPDFArgParser
         std::map<std::string, option_table_t> option_tables;
         option_table_t main_option_table;
         option_table_t help_option_table;
-        option_table_t* option_table;
+        option_table_t* option_table{nullptr};
         std::string option_table_name;
-        bare_arg_handler_t final_check_handler;
-        std::vector<std::shared_ptr<char const>> new_argv;
-        std::vector<std::shared_ptr<char const>> bash_argv;
-        std::shared_ptr<char const*> argv_ph;
-        std::shared_ptr<char const*> bash_argv_ph;
+        bare_arg_handler_t final_check_handler{nullptr};
+        std::vector<std::string> new_argv;
+        std::vector<std::string> bash_argv;
+        std::vector<char const*> argv_ph;
+        std::vector<char const*> bash_argv_ph;
         std::map<std::string, HelpTopic> help_topics;
         std::map<std::string, HelpTopic> option_help;
         std::string help_footer;
@@ -8,37 +8,38 @@
 #include <qpdf/SHA2_native.hh>
 #include <memory>
  
-class QPDFCrypto_native: public QPDFCryptoImpl
+class QPDFCrypto_native final: public QPDFCryptoImpl
 {
   public:
     QPDFCrypto_native() = default;
  
-    virtual ~QPDFCrypto_native() = default;
+    ~QPDFCrypto_native() final = default;
  
-    virtual void provideRandomData(unsigned char* data, size_t len);
+    void provideRandomData(unsigned char* data, size_t len) final;
  
-    virtual void MD5_init();
-    virtual void MD5_update(unsigned char const* data, size_t len);
-    virtual void MD5_finalize();
-    virtual void MD5_digest(MD5_Digest);
+    void MD5_init() final;
+    void MD5_update(unsigned char const* data, size_t len) final;
+    void MD5_finalize() final;
+    void MD5_digest(MD5_Digest) final;
  
-    virtual void RC4_init(unsigned char const* key_data, int key_len = -1);
-    virtual void RC4_process(unsigned char const* in_data, size_t len, unsigned char* out_data = 0);
-    virtual void RC4_finalize();
+    void RC4_init(unsigned char const* key_data, int key_len = -1) final;
+    void
+    RC4_process(unsigned char const* in_data, size_t len, unsigned char* out_data = nullptr) final;
+    void RC4_finalize() final;
  
-    virtual void SHA2_init(int bits);
-    virtual void SHA2_update(unsigned char const* data, size_t len);
-    virtual void SHA2_finalize();
-    virtual std::string SHA2_digest();
+    void SHA2_init(int bits) final;
+    void SHA2_update(unsigned char const* data, size_t len) final;
+    void SHA2_finalize() final;
+    std::string SHA2_digest() final;
  
-    virtual void rijndael_init(
+    void rijndael_init(
         bool encrypt,
         unsigned char const* key_data,
         size_t key_len,
         bool cbc_mode,
-        unsigned char* cbc_block);
-    virtual void rijndael_process(unsigned char* in_data, unsigned char* out_data);
-    virtual void rijndael_finalize();
+        unsigned char* cbc_block) final;
+    void rijndael_process(unsigned char* in_data, unsigned char* out_data) final;
+    void rijndael_finalize() final;
  
   private:
     std::shared_ptr<MD5_native> md5;
@@ -10,7 +10,7 @@ class RC4_native
     RC4_native(unsigned char const* key_data, int key_len = -1);
  
     // out_data = 0 means to encrypt/decrypt in place
-    void process(unsigned char const* in_data, size_t len, unsigned char* out_data = 0);
+    void process(unsigned char const* in_data, size_t len, unsigned char* out_data = nullptr);
  
   private:
     class RC4Key
@@ -3,20 +3,20 @@
  
 #include <qpdf/QPDFObjectHandle.hh>
  
-class ResourceFinder: public QPDFObjectHandle::ParserCallbacks
+class ResourceFinder final: public QPDFObjectHandle::ParserCallbacks
 {
   public:
-    ResourceFinder();
-    ~ResourceFinder() override = default;
-    void handleObject(QPDFObjectHandle, size_t, size_t) override;
-    void handleEOF() override;
+    ResourceFinder() = default;
+    ~ResourceFinder() final = default;
+    void handleObject(QPDFObjectHandle, size_t, size_t) final;
+    void handleEOF() final;
     std::set<std::string> const& getNames() const;
     std::map<std::string, std::map<std::string, std::set<size_t>>> const&
     getNamesByResourceType() const;
  
   private:
     std::string last_name;
-    size_t last_name_offset;
+    size_t last_name_offset{0};
     std::set<std::string> names;
     std::map<std::string, std::map<std::string, std::set<size_t>>> names_by_resource_type;
 };
@@ -11,15 +11,15 @@
 static void
 usage()
 {
-    std::cerr << "Usage: aes options hex-key infile outfile" << std::endl
-              << "  -cbc         -- disable CBC mode" << std::endl
-              << "  +cbc         -- enable CBC mode" << std::endl
-              << "  -encrypt     -- encrypt" << std::endl
-              << "  -decrypt     -- decrypt CBC mode" << std::endl
-              << "  -zero-iv     -- use zero initialization vector" << std::endl
-              << "  -static-iv   -- use static initialization vector" << std::endl
-              << "  -no-padding  -- disable padding" << std::endl
-              << "Options must precede key and file names." << std::endl;
+    std::cerr << "Usage: aes options hex-key infile outfile" << '\n'
+              << "  -cbc         -- disable CBC mode" << '\n'
+              << "  +cbc         -- enable CBC mode" << '\n'
+              << "  -encrypt     -- encrypt" << '\n'
+              << "  -decrypt     -- decrypt CBC mode" << '\n'
+              << "  -zero-iv     -- use zero initialization vector" << '\n'
+              << "  -static-iv   -- use static initialization vector" << '\n'
+              << "  -no-padding  -- disable padding" << '\n'
+              << "Options must precede key and file names." << '\n';
     exit(2);
 }
  
@@ -82,7 +82,7 @@ void
 ArgParser::output(std::string const& msg)
 {
     if (!this->ap.isCompleting()) {
-        std::cout << msg << std::endl;
+        std::cout << msg << '\n';
     }
 }
  
@@ -160,7 +160,7 @@ ArgParser::test_exceptions()
             fn();
             assert(msg == nullptr);
         } catch (std::exception& e) {
-            std::cout << msg << ": " << e.what() << std::endl;
+            std::cout << msg << ": " << e.what() << '\n';
         }
     };
  
@@ -196,10 +196,10 @@ main(int argc, char* argv[])
     try {
         ap.parseArgs();
     } catch (QPDFUsage& e) {
-        std::cerr << "usage: " << e.what() << std::endl;
+        std::cerr << "usage: " << e.what() << '\n';
         exit(2);
     } catch (std::exception& e) {
-        std::cerr << "exception: " << e.what() << std::endl;
+        std::cerr << "exception: " << e.what() << '\n';
         exit(3);
     }
     return 0;
@@ -23,7 +23,7 @@ main()
         }
         decode.finish();
     } catch (std::exception& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
         exit(2);
     }
  
@@ -20,7 +20,7 @@ write_some(FILE* f, size_t bytes, Pipeline* p)
     }
     if (len < bytes) {
         if (ferror(f)) {
-            std::cerr << "error reading file" << std::endl;
+            std::cerr << "error reading file" << '\n';
             exit(2);
         }
         p->finish();
@@ -32,7 +32,7 @@ write_some(FILE* f, size_t bytes, Pipeline* p)
 static void
 usage()
 {
-    std::cerr << "Usage: base64 encode|decode" << std::endl;
+    std::cerr << "Usage: base64 encode|decode" << '\n';
     exit(2);
 }
  
@@ -74,7 +74,7 @@ main(int argc, char* argv[])
             }
         }
     } catch (std::exception& e) {
-        std::cout << "exception: " << e.what() << std::endl;
+        std::cout << "exception: " << e.what() << '\n';
         exit(2);
     }
  
@@ -16,7 +16,7 @@ static void
 print_values(long long byte_offset, size_t bit_offset, size_t bits_available)
 {
     std::cout << "byte offset = " << byte_offset << ", " << "bit offset = " << bit_offset << ", "
-              << "bits available = " << bits_available << std::endl;
+              << "bits available = " << bits_available << '\n';
 }
  
 static void
@@ -29,7 +29,7 @@ test_read_bits(
 {
     unsigned long result = QIntC::to_ulong(read_bits(p, bit_offset, bits_available, bits_wanted));
  
-    std::cout << "bits read: " << bits_wanted << ", result = " << result << std::endl;
+    std::cout << "bits read: " << bits_wanted << ", result = " << result << '\n';
     print_values(p - buf, bit_offset, bits_available);
 }
  
@@ -39,7 +39,7 @@ test_write_bits(
 {
     write_bits(ch, bit_offset, val, bits, bp);
     std::cout << "ch = " << QUtil::uint_to_string_base(ch, 16, 2) << ", bit_offset = " << bit_offset
-              << std::endl;
+              << '\n';
 }
  
 static void
@@ -52,7 +52,7 @@ print_buffer(Pl_Buffer* bp)
     for (unsigned long i = 0; i < l; ++i) {
         std::cout << QUtil::uint_to_string_base(p[i], 16, 2) << ((i == l - 1) ? "\n" : " ");
     }
-    std::cout << std::endl;
+    std::cout << '\n';
     delete b;
 }
  
@@ -86,12 +86,12 @@ test()
     try {
         test_read_bits(buf, p, bit_offset, bits_available, 4);
     } catch (std::exception& e) {
-        std::cout << "exception: " << e.what() << std::endl;
+        std::cout << "exception: " << e.what() << '\n';
         print_values(p - buf, bit_offset, bits_available);
     }
  
     test_read_bits(buf, p, bit_offset, bits_available, 3);
-    std::cout << std::endl;
+    std::cout << '\n';
  
     // 11110101 00010101 01100101 01111001: 00010010 10001001 01110101 01001011
  
@@ -101,29 +101,29 @@ test()
     print_values(p - buf, bit_offset, bits_available);
     test_read_bits(buf, p, bit_offset, bits_available, 32);
     test_read_bits(buf, p, bit_offset, bits_available, 32);
-    std::cout << std::endl;
+    std::cout << '\n';
  
     BitStream b(buf, 8);
-    std::cout << b.getBits(32) << std::endl;
+    std::cout << b.getBits(32) << '\n';
     b.reset();
-    std::cout << b.getBits(32) << std::endl;
-    std::cout << b.getBits(32) << std::endl;
-    std::cout << std::endl;
+    std::cout << b.getBits(32) << '\n';
+    std::cout << b.getBits(32) << '\n';
+    std::cout << '\n';
  
     b.reset();
-    std::cout << b.getBits(6) << std::endl;
+    std::cout << b.getBits(6) << '\n';
     b.skipToNextByte();
-    std::cout << b.getBits(8) << std::endl;
+    std::cout << b.getBits(8) << '\n';
     b.skipToNextByte();
-    std::cout << b.getBits(8) << std::endl;
-    std::cout << std::endl;
+    std::cout << b.getBits(8) << '\n';
+    std::cout << '\n';
     b.reset();
-    std::cout << b.getBitsSigned(3) << std::endl;
-    std::cout << b.getBitsSigned(6) << std::endl;
-    std::cout << b.getBitsSigned(5) << std::endl;
-    std::cout << b.getBitsSigned(1) << std::endl;
-    std::cout << b.getBitsSigned(17) << std::endl;
-    std::cout << std::endl;
+    std::cout << b.getBitsSigned(3) << '\n';
+    std::cout << b.getBitsSigned(6) << '\n';
+    std::cout << b.getBitsSigned(5) << '\n';
+    std::cout << b.getBitsSigned(1) << '\n';
+    std::cout << b.getBitsSigned(17) << '\n';
+    std::cout << '\n';
  
     // Write tests
  
@@ -176,9 +176,9 @@ main()
     try {
         test();
     } catch (std::exception& e) {
-        std::cout << "unexpected exception: " << e.what() << std::endl;
+        std::cout << "unexpected exception: " << e.what() << '\n';
         exit(2);
     }
-    std::cout << "done" << std::endl;
+    std::cout << "done" << '\n';
     return 0;
 }
@@ -85,22 +85,22 @@ main()
         bp1.write(uc("12345"), 5);
         bp1.write(uc("67890"), 5);
         bp1.finish();
-        std::cout << "count: " << count.getCount() << std::endl;
+        std::cout << "count: " << count.getCount() << '\n';
         bp1.write(uc("abcde"), 5);
         bp1.write(uc("fghij"), 6);
         bp1.finish();
-        std::cout << "count: " << count.getCount() << std::endl;
+        std::cout << "count: " << count.getCount() << '\n';
         Buffer* b = bp1.getBuffer();
-        std::cout << "size: " << b->getSize() << std::endl;
-        std::cout << "data: " << b->getBuffer() << std::endl;
+        std::cout << "size: " << b->getSize() << '\n';
+        std::cout << "data: " << b->getBuffer() << '\n';
         delete b;
         bp1.write(uc("qwert"), 5);
         bp1.write(uc("yuiop"), 6);
         bp1.finish();
-        std::cout << "count: " << count.getCount() << std::endl;
+        std::cout << "count: " << count.getCount() << '\n';
         b = bp1.getBuffer();
-        std::cout << "size: " << b->getSize() << std::endl;
-        std::cout << "data: " << b->getBuffer() << std::endl;
+        std::cout << "size: " << b->getSize() << '\n';
+        std::cout << "data: " << b->getBuffer() << '\n';
         delete b;
  
         Pl_Buffer bp2("bp2");
@@ -109,12 +109,12 @@ main()
         try {
             delete bp2.getBuffer();
         } catch (std::exception& e) {
-            std::cout << e.what() << std::endl;
+            std::cout << e.what() << '\n';
         }
         bp2.finish();
         b = bp2.getBuffer();
-        std::cout << "size: " << b->getSize() << std::endl;
-        std::cout << "data: " << b->getBuffer() << std::endl;
+        std::cout << "size: " << b->getSize() << '\n';
+        std::cout << "data: " << b->getBuffer() << '\n';
         delete b;
  
         unsigned char lbuf[10];
@@ -125,17 +125,17 @@ main()
  
         Pl_Buffer bp3("bp3");
         b = bp3.getBuffer();
-        std::cout << "size: " << b->getSize() << std::endl;
+        std::cout << "size: " << b->getSize() << '\n';
         delete b;
         // Should be able to call getBuffer again and get an empty buffer
         b = bp3.getBuffer();
-        std::cout << "size: " << b->getSize() << std::endl;
+        std::cout << "size: " << b->getSize() << '\n';
         delete b;
         // Also can write 0 and do it.
         bp3.write(uc(""), 0);
         bp3.finish();
         b = bp3.getBuffer();
-        std::cout << "size: " << b->getSize() << std::endl;
+        std::cout << "size: " << b->getSize() << '\n';
         delete b;
  
         // Malloc buffer should behave similarly.
@@ -147,7 +147,7 @@ main()
             bp4.getMallocBuffer(&mbuf, &len);
             assert(false);
         } catch (std::logic_error& e) {
-            std::cout << "malloc buffer logic error: " << e.what() << std::endl;
+            std::cout << "malloc buffer logic error: " << e.what() << '\n';
         }
         bp4.finish();
         bp4.getMallocBuffer(&mbuf, &len);
@@ -160,10 +160,10 @@ main()
         assert(mbuf == nullptr);
         assert(len == 0);
     } catch (std::exception& e) {
-        std::cout << "unexpected exception: " << e.what() << std::endl;
+        std::cout << "unexpected exception: " << e.what() << '\n';
         exit(2);
     }
  
-    std::cout << "done" << std::endl;
+    std::cout << "done" << '\n';
     return 0;
 }
@@ -8,7 +8,7 @@ void
 check(std::string const& what, bool result)
 {
     if (!result) {
-        std::cout << "FAIL: " << what << std::endl;
+        std::cout << "FAIL: " << what << '\n';
     }
 }
  
@@ -73,6 +73,6 @@ main()
     std::cout << "testing with FileInputSource\n";
     FileInputSource f("input");
     do_tests(&f);
-    std::cout << "all assertions passed" << std::endl;
+    std::cout << "all assertions passed" << '\n';
     return 0;
 }
@@ -31,9 +31,9 @@ main(int argc, char* argv[])
     auto b2_buf = b2.getBufferSharedPointer();
     std::string result(reinterpret_cast<char*>(b2_buf->getBuffer()), b2_buf->getSize());
     if (result == "-one--two-") {
-        std::cout << "concatenate test passed" << std::endl;
+        std::cout << "concatenate test passed" << '\n';
     } else {
-        std::cout << "concatenate test failed: " << result << std::endl;
+        std::cout << "concatenate test failed: " << result << '\n';
     }
     return 0;
 }
@@ -47,7 +47,7 @@ class Potato: public QPDFCryptoImpl
     std::string
     SHA2_digest() override
     {
-        return std::string();
+        return {};
     }
     void
     RC4_init(const unsigned char* key_data, int key_len) override
@@ -12,7 +12,7 @@
 static void
 usage()
 {
-    std::cerr << "Usage: dct_compress infile outfile width height {rgb|cmyk|gray}" << std::endl;
+    std::cerr << "Usage: dct_compress infile outfile width height {rgb|cmyk|gray}" << '\n';
     exit(2);
 }
  
@@ -10,7 +10,7 @@ int
 main(int argc, char* argv[])
 {
     if (argc != 3) {
-        std::cerr << "Usage: dct_uncompress infile outfile" << std::endl;
+        std::cerr << "Usage: dct_uncompress infile outfile" << '\n';
         exit(2);
     }
  
@@ -53,7 +53,7 @@ run(char const* filename)
  
     def3->finish();
  
-    std::cout << "bytes written to o3: " << count3->getCount() << std::endl;
+    std::cout << "bytes written to o3: " << count3->getCount() << '\n';
  
     delete def3;
     delete inf3;
@@ -76,14 +76,14 @@ run(char const* filename)
     // At this point, filename, filename.2, and filename.3 should have
     // identical contents.  filename.1 should be a compressed version.
  
-    std::cout << "done" << std::endl;
+    std::cout << "done" << '\n';
 }
  
 int
 main(int argc, char* argv[])
 {
     if (argc != 2) {
-        std::cerr << "Usage: pipeline filename" << std::endl;
+        std::cerr << "Usage: pipeline filename" << '\n';
         exit(2);
     }
     char* filename = argv[1];
@@ -91,7 +91,7 @@ main(int argc, char* argv[])
     try {
         run(filename);
     } catch (std::exception& e) {
-        std::cout << e.what() << std::endl;
+        std::cout << e.what() << '\n';
     }
     return 0;
 }
@@ -23,7 +23,7 @@ main()
         }
         decode.finish();
     } catch (std::exception& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
         exit(2);
     }
  
@@ -47,7 +47,7 @@ Finder::check()
 void
 check(char const* description, bool expected, bool actual)
 {
-    std::cout << description << ": " << ((actual == expected) ? "PASS" : "FAIL") << std::endl;
+    std::cout << description << ": " << ((actual == expected) ? "PASS" : "FAIL") << '\n';
 }
  
 int
@@ -186,12 +186,12 @@ static void
 check_schema(JSON& obj, JSON& schema, unsigned long flags, bool exp, std::string const& description)
 {
     std::list<std::string> errors;
-    std::cout << "--- " << description << std::endl;
+    std::cout << "--- " << description << '\n';
     assert(exp == obj.checkSchema(schema, flags, errors));
     for (auto const& error: errors) {
-        std::cout << error << std::endl;
+        std::cout << error << '\n';
     }
-    std::cout << "---" << std::endl;
+    std::cout << "---" << '\n';
 }
  
 static void
@@ -8,43 +8,43 @@
 static void
 print_null(std::string const& path)
 {
-    std::cout << path << ": null" << std::endl;
+    std::cout << path << ": null" << '\n';
 }
  
 static void
 print_string(std::string const& path, std::string const& value)
 {
-    std::cout << path << ": string: " << value << std::endl;
+    std::cout << path << ": string: " << value << '\n';
 }
  
 static void
 print_number(std::string const& path, std::string const& value)
 {
-    std::cout << path << ": number: " << value << std::endl;
+    std::cout << path << ": number: " << value << '\n';
 }
  
 static void
 print_bool(std::string const& path, bool value)
 {
-    std::cout << path << ": bool: " << (value ? "true" : "false") << std::endl;
+    std::cout << path << ": bool: " << (value ? "true" : "false") << '\n';
 }
  
 static void
 print_json(std::string const& path, JSON value)
 {
-    std::cout << path << ": json: " << value.unparse() << std::endl;
+    std::cout << path << ": json: " << value.unparse() << '\n';
 }
  
 static JSONHandler::void_handler_t
 make_print_message(std::string msg)
 {
-    return [msg](std::string const& path) { std::cout << path << ": json: " << msg << std::endl; };
+    return [msg](std::string const& path) { std::cout << path << ": json: " << msg << '\n'; };
 }
  
 static void
 test_scalar()
 {
-    std::cout << "-- scalar --" << std::endl;
+    std::cout << "-- scalar --" << '\n';
     JSONHandler h;
     h.addStringHandler(print_string);
     JSON j = JSON::parse("\"potato\"");
@@ -97,7 +97,7 @@ make_all_handler()
 static void
 test_all()
 {
-    std::cout << "-- all --" << std::endl;
+    std::cout << "-- all --" << '\n';
     auto h = make_all_handler();
     /* cSpell: ignore phour */
     JSON j = JSON::parse(R"({
@@ -110,7 +110,7 @@ test_all()
    "six": {"a": {"b": "quack", "Q": "baaa"}, "b": "moo"}
 })");
     h->handle(".", j);
-    std::cerr << "-- fallback --" << std::endl;
+    std::cerr << "-- fallback --" << '\n';
     j = JSON::parse(R"({
    "five": "not-array"
 })");
@@ -120,14 +120,14 @@ test_all()
 static void
 test_errors()
 {
-    std::cout << "-- errors --" << std::endl;
+    std::cout << "-- errors --" << '\n';
     auto h = make_all_handler();
     auto t = [h](std::string const& msg, std::function<void()> fn) {
         try {
             fn();
             assert(false);
         } catch (QPDFUsage& e) {
-            std::cout << msg << ": " << e.what() << std::endl;
+            std::cout << msg << ": " << e.what() << '\n';
         }
     };
  
@@ -26,13 +26,13 @@ namespace
 void
 Reactor::dictionaryStart()
 {
-    std::cout << "dictionary start" << std::endl;
+    std::cout << "dictionary start" << '\n';
 }
  
 void
 Reactor::arrayStart()
 {
-    std::cout << "array start" << std::endl;
+    std::cout << "array start" << '\n';
 }
  
 void
@@ -45,7 +45,7 @@ Reactor::containerEnd(JSON const&amp; value)
 void
 Reactor::topLevelScalar()
 {
-    std::cout << "top-level scalar" << std::endl;
+    std::cout << "top-level scalar" << '\n';
 }
  
 bool
@@ -74,13 +74,13 @@ Reactor::arrayItem(JSON const&amp; value)
 void
 Reactor::printItem(JSON const& j)
 {
-    std::cout << "[" << j.getStart() << ", " << j.getEnd() << "): " << j.unparse() << std::endl;
+    std::cout << "[" << j.getStart() << ", " << j.getEnd() << "): " << j.unparse() << '\n';
 }
  
 static void
 usage()
 {
-    std::cerr << "Usage: json_parse file [--react]" << std::endl;
+    std::cerr << "Usage: json_parse file [--react]" << '\n';
     exit(2);
 }
  
@@ -102,9 +102,9 @@ main(int argc, char* argv[])
     }
     try {
         FileInputSource is(filename);
-        std::cout << JSON::parse(is, reactor.get()).unparse() << std::endl;
+        std::cout << JSON::parse(is, reactor.get()).unparse() << '\n';
     } catch (std::exception& e) {
-        std::cerr << "exception: " << filename << ": " << e.what() << std::endl;
+        std::cerr << "exception: " << filename << ": " << e.what() << '\n';
         return 2;
     }
     return 0;
@@ -15,7 +15,7 @@ main(int argc, char* argv[])
     }
  
     if (argc < 3) {
-        std::cerr << "Usage: lzw infile outfile [ --no-early-code-change ]" << std::endl;
+        std::cerr << "Usage: lzw infile outfile [ --no-early-code-change ]" << '\n';
         exit(2);
     }
  
@@ -41,7 +41,7 @@ main(int argc, char* argv[])
         }
         decode.finish();
     } catch (std::exception& e) {
-        std::cerr << e.what() << std::endl;
+        std::cerr << e.what() << '\n';
         exit(2);
     }
  
@@ -8,7 +8,7 @@ wmain_test()
     // writable args and function args
     auto realmain = [](int argc, char* argv[]) {
         for (int i = 0; i < argc; ++i) {
-            std::cout << argv[i] << std::endl;
+            std::cout << argv[i] << '\n';
         }
         return 0;
     };
@@ -28,7 +28,7 @@ cwmain_test()
     // const args and function args
     auto realmain = [](int argc, char const* const argv[]) {
         for (int i = 0; i < argc; ++i) {
-            std::cout << "const " << argv[i] << std::endl;
+            std::cout << "const " << argv[i] << '\n';
         }
         return 0;
     };
@@ -49,7 +49,7 @@ main(int argc, char* argv[])
         wmain_test();
         cwmain_test();
     } catch (std::exception& e) {
-        std::cout << "unexpected exception: " << e.what() << std::endl;
+        std::cout << "unexpected exception: " << e.what() << '\n';
     }
 #endif // QPDF_NO_WCHAR_T