1. While the ternary operator (?:) is well known, many dont realise that it can also be used as lvalues.

x = (y < 0) ? 10 : 20; (a == 0 ? a : b) = 1; Otherwise, you would be writing this as, if (a == 0) a = 1; else b = 1; 2. The namespace alias is pretty easy to miss. Once you know about it though, you will start recognising it everywhere. It is especially useful when yourr writing a large code with a lot of namespace hierarchies. namespace x = boost::filesystem; x::path myPath(strPath, fs::native ); 3. Variables arent the only ones that can be declared in the init part of functions. You can also declare classes and other functions. for(struct { int x; float y; } loop = { 1, 2 }; ...; ...) { ... } 4. The unary + operator can be used in order to promote or decay a number of things. See below for some examples. +EnumeratorValue: This gives your enumerator value a perfect integer type, which lets it fit its value. This is quite useful for implementing overloaded operators for enumeration. Passing a temporary value to a variable: You can create a temporary value for a variable using this operator. For example, if you have a class that uses an in class static initializer without any out of class definition, but sometimes the system fails to link. struct Foo { static int const value = 42; }; template void f(T const&);

int main() { // fails to link and tries to get the address of "Foo::value"! f(Foo::value); // works - pass a temporary value f(+Foo::value); } Decay an array to a pointer: The operator also works when you want to pass two values to a function. template void f(T const& a, T const& b); int main() { int a[2]; int b[3]; f(a, b); // won't work! different values for "T"! f(+a, +b); // works! T is "int*" both time } 5. You must know the id/identity metafunction. Now check out this usecase for it, which is for non-template cases. // void (*f)(); // same id::type *f; // void (*f(void(*p)()))(int); // same id::type *f(id::type *p); // int (*p)[2] = new int[10][2]; // same id::type *p = new int[10][2]; // void (C::*p)(int) = 0; // same id::type C::*p = 0; It helps decrypting C++ declarations greatly! // boost::identity is pretty much the same template struct id { typedef T type; };