Welcome to the Lounge

Gerry Schmitz wrote:

So, I compared definitions and "calculating" indicates simplicity whereas "computing" indicates complexity.

Bastard Programmer from Hell
"If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.

#realJSOP wrote:

Now I can relax...

• Confusion between a variable and its value. If you think of a variable as being a value rather than having a value, pointers don't make sense.
• Having no down-to-earth view of what memory is. If you view it as a mystical black box where value are associated to variables by some unholy combination of the name of a variable and a particular function invocation or whatever (to be able to handle recursion), pointers don't make sense.

• Given Class* p, p += n is p + n * sizeof(Class), not p + n. For a long time, I worked in a language where this wasn't the case, so I've rediscovered it several times.
• The idiomatic if(p) instead of if(p != nullptr). I still refuse to write the former, probably because I never used C and because nullptr was equivalent to UINTPTR_MAX in the language that I used.
• Smart pointers, particularly unique_ptr. These are great, but adopting them isn't always transparent. It took me a while to find a bug that was caused by the implementation of unique_ptr::reset, which was equivalent to
  C++

  item = this->ptr_;
  this->ptr_ = nullptr;
  delete item;

  I had code that needed to know the object being deleted, so it got broken when it started using unique_ptr::get instead of looking at a raw pointer. The workaround (ctx_ being the unique_ptr) was
  C++

  auto ctx = ctx_.get();
  delete ctx;
  ctx_.release();