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

Answer 1

• That anonymous namespaces are almost always what is truly wanted when people are making static variables in C++
• When making library header files, the pimpl idiom (http://www.gotw.ca/gotw/024.htm) should be used for almost all private functions and members to aid in dependency management

Answer 2

There are a few things that people seem to be constantly confused by or have no idea about:

1. Pointers, especially function pointers and multiple pointers (e.g. int(*)(void*), void***)

2. The const keyword and const correctness (e.g. what is the difference between const char*, char* const and const char* const, and what does void class::member() const; mean?)

3. Memory allocation (e.g. every pointer new'ed should be deleted, malloc/free should not be mixed with new/delete, when to use delete [] instead of delete, why the C functions are still useful (e.g. expand(), realloc()))

4. Scope (i.e. that you can use { } on its own to create a new scope for variable names, rather than just as part of if, for etc...)

5. Switch statements. (e.g. not understanding that they can optimise as well (or better in some cases) than chains of ifs, not understanding fall through and its practical applications (loop unrolling as an example) or that there is a default case)

6. Calling conventions (e.g. what is the difference between cdecl and stdcall, how would you implement a pascal function, why does it even matter?)

7. Inheritance and multiple inheritance and, more generally, the entire OO paradigm.

8. Inline assembler, as it is usually implemented, is not part of C++.

Answer 3

The static keyword which can mean one of three distinct things depending on where it is used.

1. It can be a static member function or member variable.
2. It can be a static variable or function declared at namespace scope.
3. It can be a static variable declared inside a function.

Answer 4

std::vector does not create elements when reserve is used

I've seen it that programmers argue that they can access members at positions greater than what size() returns if they reserve()'ed up to that positions. That's a wrong assumption but is very common among programmers - especially because it's quite hard for the compiler to diagnose a mistake, which will silently make things "work".

Answer 5

a classic among beginners to c++ from c:

confuse delete and delete[]

EDIT:

another classic failure among all levels of experience when using C API:

std::string helloString = "hello world";
printf("%s\n", helloString);

instead of:

printf("%s\n", helloString.c_str());

it happens to me every week. You could use streams, but sometimes you have to deal with printf-like APIs.

Answer 6

If a function accepts a pointer to a pointer, void* will still do it

I've seen that the concept of a void pointer is frequently confused. It's believed that if you have a pointer, you use a void*, and if you have a pointer to a pointer, you use a void**. But you can and should in both cases use void*. A void** does not have the special properties that a void* has.

It's the special property that a void* can also be assigned a pointer to a pointer and when cast back the original value is received.