there is no such thing as a null reference.
no need to check reference is null, but pointers must check before using it.

static_cast(expression)
dynamic_cast(expression)
reinterpret_cast(expression)
const_cast(expression)

use smart pointer, such as std::unique_ptr, ans shared_ptr.

1. destrcutors swallow the exception.
2. use another function to do cleaning up.

Throw by value, catch by reference.

you can throw any type exception value or no exception.
make sure you understand the stack unwinding.
you can know the what happens when exception occuring.

for readability, exception is good thing to detect the error.
with modern architecture, the zero-cost model exceptions is possible.

80 percent of a programs are used by about 20 percent of the code.

user-defined swap function is good example.
overloading operator operators, such as operator+.
const Number operator+(const Number& lhs, const Number& rhs)

return value optimization and the compiler.
the compiler will not guarantee the RVO, but may allows it.

NOTE: don't use auto_ptr, it's old-fashioned. use unique_ptr and shared_ptr instead.

three examples:

1. Multidimensional arrays.
2. lvalue/rvalue differences.
3. suppression of implicit conversions.

disadvantages:

1. temporaries is inevitable, it costs too much.
2. increase the complexity of software system.

1. Provide complete classes.
2. Design your interfaces to facilitate common operations and prevent common errors.

1. Make sure the C++ and C compilers produce compatible object files.
2. Declare functions to be used by both languages extern "C".
3. If at all possible, write main in C++.
4. Always use delete with memory from new, always use free with memory from malloc.
5. Limit what you pass between the two languages to data structures that compile under C; the C++ version of structs may contain non-virutal member functions.

throw away the old C-style fashion.
familiarize STL (Standard Template Library).