3. What if I call delete twice on the same pointer?[5]
Don’t do that. It may try to call the destructor and free the same memory twice.

4. What if I call delete this; somewhere in my class?[21]
Suicide is usually not the answer. Don’t do that.

5. What if I call new twice on the same pointer?
Don’t do that. For every new there must be a delete.

(And if you think you have a smart idea, see question 3.)

6. What if I call new on a pointer, then change the pointer’s value?
Don’t do that. delete may do crazy things later.

7. Why isn’t the Derived class’ destructor called when I do polymorphism?
The Base class’ destructor must be declared virtual. [20]

8. How should I handle errors in destructors?
You don’t. In particular, don’t throw exceptions. Because your destructor itself may have been called as the result of a previous exception being thrown. [15]

9. Wow, six flavors of casts! Which one to use?[2][3]
You shouldn’t use any of them, if you can help it.

10. Then how else can I subvert the type system?
It already does a good job at subverting itself, by implicit conversions. But if that’s not enough, use macros, or better yet templates (which are considered to be type-safe).

11. What’s the meaning of “type-safe”, as in code?[11]
It means the compiler does less implicit conversions without complaining. So you’re forced to get the type right. Kind of.

12. I just realized that the templates’ purpose really is to punch a hole through the type system. So how exactly does type safety apply to them?
Well type safety and type agnosticism aren’t mutually exclusive. Or are they? [13][14]

13. What’s an explicit constructor?[4]
A constructor taking only one parameter can be used implicitly, for implicit conversions. Declaring such a constructor as explicit will prevent that.

15. What is the “Rule of Three”?[9]
It’s that if you need to write a custom destructor you probably also need to write a custom copy constructor and assignment (copy) operator. In C++11 you may also need to write a custom move constructor and move operator.

16. What’s an unnamed namespace?[12]
It’s… a namespace without a name. It makes its contents “invisible” outside the current file. In C, the keyword static has a similar role when applied to functions and global variables.

18. Why the archaic int main(int, char**), and not int main(std::list<std::string>&)?
Because std::list and std::string are templates which are part of the language’s library, and are not built-in into the language itself, duh.

19. Why do some people keep writing std:: over and over, instead of using a single …?

using namespace std;

The official answer is “to prevent namespace pollution”. [7] Unofficially, because it looks cool and professional.

20. What’s the difference between a class and a struct?
By default, a class has all members private, while a struct has all members public. They also inherit differently “by default”. Otherwise there’s no difference.

21. How come, no matter how many functions I add to myClass, sizeof (myClass) remains the same?
Because you’re adding non-virtual functions. If you add virtual functions, a hidden virtual function table (the “vtable”) would be added as a member variable, and increase the size.
The reason why “regular” functions don’t increase the size is that they’re not part of the class, to begin with. Under the hood, they simply receive a hidden parameter, pointing to the object they must work on. [1]

22. How can I make myClass printable to a file stream (such as std::cout)?
Overload the bitshift left operator:

24. What’s a lambda function?
It’s a new feature of C++11, which allows you to define a function “where needed”. Lambdas are most convenient for use with the STL algorithms, some of which require being fed a function to work.
What does this question do here? Well lambda’s syntax is… weird, to say the least. [10]

25. How can I pass around a reference to an array?[16]
Are you sure about this?

27a. Why do some people seem to hate me for using system("PAUSE");?
It’s a pet peeve that makes them feel superior to you. It is bad practice to use system() calls in production code. But if you’re only learning the language and experimenting, using system("PAUSE"); fits perfectly fine. The alternative would be what I call “input stream hackery”, dubious usage of cin.get() and cin.ignore(), which are called to have the side effect of pausing the program until the user hits Enter.

27b. So what’s The Right Way to do things?
If your IDE doesn’t pause the output automatically (as it should), start up the Command Prompt (cmd.exe or command.com) and run your program in it. [18] Thus, pausing will no longer be necessary. If you’re using Linux, you have to run the program in the Shell anyway because it won’t create its own output window like in Windows. If the Command Prompt looks too ugly for you, check out the Console project. [17]