Differences between revisions 38 and 39
⇤ ← Revision 38 as of 2020-04-07 19:27:12 →
Size: 5729
Editor: SamatJain
Comment:
← Revision 39 as of 2020-09-02 20:49:51 → ⇥
Size: 5933
Editor: SamatJain
Comment: Iterating over maps
Deletions are marked like this. Additions are marked like this.
Line 92: Line 92:
For iterating over maps:

{{{#!highlight c++ numbers=off
// Nothing changed
for (const auto& [key, value]: some_map) { observ(value); }
for (auto& [key, value]: some_map) { value.change(); }
}}}

Contents

  1. C++ style guides
  2. `const` correctness
  3. Formatting
  4. Static analysis tools
    1. Thread safety analysis (TSA)
    2. Lifetime safety analysis
  5. Stuff I never remember
    1. Unnecessary copies w/ `auto`
    2. Don't evaluate `end()` in loops
    3. Use `const` iterators if not mutating a structure
  6. Naming
  7. Dynamic loading of DLL/DSOs

See also:

C++ style guides

`const` correctness

Formatting

ClangFormat: auto-formats C++ code

Static analysis tools

  • Clang-Tidy: C/C++ linting tool, à la Google's cpplint. 

clang-tidy -checks='*' *.cpp -- -std=c++11

# Highest severity warnings only (i.e. memory leaks, etc)
cppcheck --enable=all *.cpp
# Everything except style-related linting
cppcheck --enable=warning,performance,portability,information,missingInclude \
         --std=c++11 --library=std.cfg --verbose --quiet \
         *.cpp

Overview articles:

Thread safety analysis (TSA)

Documentation:

Example projects:

Lifetime safety analysis

Stuff I never remember

Unnecessary copies w/ `auto`

Beware unncessary copies w/ auto; default semantics is to make a copy. 

// Typically there's no reason to copy.
for (const auto &Val : Container) { observe(Val); }
for (auto &Val : Container) { Val.change(); }

// Remove the reference if you really want a new copy.
for (auto Val : Container) { Val.change(); saveSomewhere(Val); }

// Copy pointers, but make it clear that they're pointers.
for (const auto *Ptr : Container) { observe(*Ptr); }
for (auto *Ptr : Container) { Ptr->change(); }

For iterating over maps: 

// Nothing changed
for (const auto& [key, value]: some_map) { observ(value); }
for (auto& [key, value]: some_map) { value.change(); }

Don't evaluate `end()` in loops

// BAD
BasicBlock *BB = ...
for (BasicBlock::iterator I = BB->begin(); I != BB->end(); ++I)
  // ... use I ...

// GOOD (unless you are mutating BB; use the above loop if you are, and document you are doing so)
BasicBlock *BB = ...
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
  // ... use I ...

Notes:

Use `const` iterators if not mutating a structure

Expanding on the above: 

BasicBlock *BB = ...
for (BasicBlock::const_iterator I = BB->cbegin(), E = BB->cend(); I != E; ++I)
  // ... use I ...

Naming

  • "create" and "destroy" for heap-allocated (i.e. pointer) objects
  • "init" and "finish" for stack-allocated objects

Dynamic loading of DLL/DSOs

Example of loading OpenCL dynamically. Uses a Python parser script to create special header file with defines that map both functions and does appropriate type conversion. https://github.com/opencv/opencv/pull/1542/files

Boost.DLL: Boost library for easily loading DLLs (e.g. for plugins). Cross platform, but requires runtime libraryes boost_system (integrated into C++11?) and boost_filesystem (integrated into C++17).

https://github.com/knusbaum/CPP-Dynamic-Class-Loading: Class for dynamically loading classes (Linux only)

SamatsWiki: CodingStyle/C++ (last edited 2020-09-02 20:49:51 by SamatJain)