Some practical C++ footgun avoidance.

Here is a list of problems I found worthwhile to write up to remind myself not to do the same mistake again or how to workaround various compiler problems. It consists of type problems, easy to make memory issues mostly around uninitialized memory and stack-local values, low quality library code, problems with virtual classes, template code problems and some compiler specific problems. For a more complete view on the edge cases of the language, consider taking a look at the C++ iceberg and preprocessor iceberg.

Do not use hashmap[key], use auto search_hashmap = hashmap.find(); and write via iterator or use emplace, because there is no check for the elements existence or (typically raw C) values of members can remain undefined after object creation due to implicit default constructor.

hashmap_simple_ub.cpp


class T1 {
public:
    T1(); // needed to allow convenient random access via [] operator
    T1(const std::string &t1): mName(t1) {};
    std::string mName;
    std::string prop1;
};
class T2 {
public:
    std::map mapex1;
    void AddT1 (const std::string &t1str) {
        T1 t1obj(t1str);
        mapex1.emplace(t1str, t1obj);
        mapex1[t1str].prop1 = "blabla"; // potential footgun!
    }
};

Providing const char * to a function with reference will use the stack-local memory instead of using a copy. If further, c_str() is used to emplace into a std::map, this leads to UB due to usage of invalid memory once the stack local memory goes out of scope.
1. In doubt, allocate a copy with std::string newstring = std::string(some_string)
2. Especially in std::map or other owned containers.
3. Only if there is an explicit comment on the storage including handling of move and copy constructor, use (const) char* as provided argument for (const) std::string &.

There is no type safety in reinterpret_cast usage, which is worse than memcpy. However, the prevention of another temporary for portable code may be worth it.

hashmap_simple_ub.cpp


int64_t usage_ptr(int64_t * val) {
  return *val;
}
int reinterpret_cast_usage() {
  // clang-format: off
  uint8_t some_vals[9] = { 0
                         , 1, 0, 0, 0
                         , 0, 0, 0, 0 };
  // clang-format: on
  int64_t val_mcpy;
  // val_mcpy = memcpy(&val_mcpy, some_vals[1], sizeof(val_mcpy);  // refusal to compile
  val_mcpy = memcpy(&val_mcpy, &some_vals[1], sizeof(val_mcpy);   // refusal to compile
  int64_t val_wrong = *reinterpret_cast(some_vals[1]);            // runtime error
  int64_t val_ok = *reinterpret_cast(&some_vals[1]);              // correct usage
  int64_t * val_ok_ptr = reinterpret_cast(&some_vals[1]);         // correct usage
  usage_ptr(val_ok_ptr);
  usage_ptr(&val_mcpy);                              // necessary temporary copy hopefully elided
  if (val != INT64_MIN) return 1;
  return 0;
}



     
    C++ conversion string to int is worse without boost, so use C's strtol.
    





















     Checking, if typename is a string is complex (even with C++17 extension).
      hashmap_simple_ub.cpp

template<typename STR>
inline constexpr bool is_string_class_decayed = false;
template<typename... STR>
inline constexpr bool is_string_class_decayed<std::basic_string<STR...>> = true;
// decay_t will remove const, & and volatile from the type
template<typename STR>
inline constexpr bool is_string_class = is_string_class_decayed
template <typename TChar, typename TString>
inline constexpr bool is_string = is_string_class<TString> && std::is_same_v<TChar, typename TString::value_type>;
static_assert(is_string_class<std::string>);
static_assert(is_string_class<const std::wstring&>); // that's why we need decay_t
static_assert(!is_string_class<int>);
static_assert(!is_string_class<const double>);
static_assert(!is_string_class<const char*>);
static_assert(!is_string_class<<std::vector<char>>);

      
    

    
      auto does verbatim replacement of the return type, which can hide a stack-local copy.
      Only use 'auto' for well-known iterators, status tuples, shared pointers etc, but never for
      objects and object references.
    

     Interoperating type safe with c strings is cumbersome.
      hashmap_simple_ub.cpp

void cstring_string_interop() {
  const char * cmd = "ls";
  char const * buffer[] = {"ls", "-l", NULL};
  char * const * argv = const_cast(buffer);
  int execed = execve(cmd, argv, NULL);
  (void)execed;
}

      
    

     MSVC has no reliable relative paths as macro yet (see experimental:deterministic mode).
        Workaround get filename by Andry https://stackoverflow.com/a/54335644.
      hashmap_simple_ub.cpp

template 
inline constexpr size_t fname_offs(const T(&str)[S], size_t i = S - 1) {
  return (str[i] == '/' || str[i] == '\\') ? i + 1 : (i > 0 ? fname_offs(str, i - 1) : 0);
}
template 
inline constexpr size_t fname_offs(T(&str)[1]) {
  return 0;
}
namespace util_force_const_eval {
  template 
  struct const_expr_value
  {
    static constexpr const T value = v;
  };
}
#define FORCE_CONST_EVAL(exp) ::util_force_const_eval::const_expr_value::value
#define LEAF(FN) (&FN[FORCE_CONST_EVAL(fname_offs(FN))])

int testEq(int a, int b) {
  if (a != b) {
    // Prefer __FILE_NAME__, which also works in C. Ideally, the compiler
    // can be told to provide relative file paths.
    fprintf(stderr,"%s:%d got '%d' expected '%d'\n", LEAF(__FILE__), __LINE__, a, b);
    return 1;
  }
  return 0;
}

      
    

    
      Destructors of virtual classes should have lifetime annotation, unless
      final class. Otherwise, debugging problems will be painful, because the
      intended object lifetimes become ambiguous on reading the code. Consider
      using clang -Wnon-virtual-dtor or recent msvc (~ year 2020).
    

     Delete copy + move constructors for non-final classes with no pure-virtual methods.

    
      Consider marking copy constructor as explicit and deleting copy assignment, if
      copying class is expensive. Consider providing a "clone fn" as syntactic sugar.
    

    
      Do not use std::vector<bool>, because it is a
      bitset and has horrible naming. Accidental byte operations on
      it like memcpy will be UB.