What are the often misunderstood concepts in C++? [closed]

Answer 1

In decreasing order:

1. make sure to release pointers for allocated memory
2. when destructors should be virtual
3. how virtual functions work

Interestingly not many people know the full details of virtual functions, but still seem to be ok with getting work done.

Answer 2

Given this:

int x = sizeof(char);

what value is X?

The answer you often hear is dependant on the level of understanding of the specification.

1. Beginner - x is one because chars are always eight bit values.
2. Intermediate - it depends on the compiler implementation, chars could be UTF16 format.
3. Expert - x is one and always will be one since a char is the smallest addressable unit of memory and sizeof determines the number of units of memory required to store an instance of the type. So in a system where a char is eight bits, a 32 bit value will have a sizeof of 4; but in a system where a char is 16 bits, a 32 bit value will have a sizeof of 2.

It's unfortunate that the standard uses 'byte' to refer to a unit of memory since many programmers think of 'byte' as being eight bits.

Answer 3

C++ is a multi-paradigm language. Many people associate C++ strictly with OOP.

Answer 4

C++ is not C with string and vector!

Answer 5

That C++ does have automatic resource management.

(Most people who claim that C++ does not have memory management try to use new and delete way too much, not realising that if they allowed C++ to manage the resource themselves, the task gets much easier).

Example: (Made with a made up API because I do not have time to check the docs now)

// C++
void DoSomething()
{
  File file("/tmp/dosomething", "rb");
  ... do stuff with file...
  // file is automatically free'ed and closed.
}

// C#
public void DoSomething()
{
  File file = new File("/tmp/dosomething", "rb");
  ... do stuff with file...

  // file is NOT automatically closed.
  // What if the caller calls DoSomething() in a tight loop?
  // C# requires you to be aware of the implementation of the File class
  // and forces you to accommodate, thus voiding implementation-hiding
  // principles.
  // Approaches may include:
  // 1) Utilizing the IDisposable pattern.
  // 2) Utilizing try-finally guards, which quickly gets messy.
  // 3) The nagging doubt that you've forgotten something /somewhere/ in your
  //    1 million loc project.
  // 4) The realization that point #3 can not be fixed by fixing the File
  //    class.
}

Answer 6

Memory Alignment.