nullptr

I want to check the result of dynamic_cast. In c++11 (or c++0x, for compilers that support nullptr), should I compare against nullptr or 0? Does it matter, and if so, why? Is the result compiler-dependent? Both the constant nullptr (which is of type nullptr_t ) and the constant 0 will implicitly convert to the null value of any pointer type. So comparing against either one will work and is technically OK. By the way, this means that dynamic_cast return neither one, it returns the null value for the particular pointer type. It's probably best to get in the habit of using nullptr rather than 0 .

The Standard states, that nullptr is a pointer literal of type std::nullptr_t (2.14.7). And 18.2p9 defines nullptr_t by namespace std { typedef decltype(nullptr) nullptr_t; } By 7.1.6.2p4 decltype(nullptr) is the type of the expression nullptr , which is by definition std::nullptr_t (since the expression nullptr is a prvalue). Substituting that into the definition of nullptr_t results in typedef nullptr_t nullptr_t On the other hand a typedef specifier does not introduce a new type, it's just a name for another existing type. So, what is exactly nullptr_t ? I'm not able to comprehend these

I learned that nullptr , in addition to being convertible to any pointer type (but not to any integral type) also has its own type std::nullptr_t . So it is possible to have a method overload that accepts std::nullptr_t . Exactly why is such an overload required? If more than one overload accepts a pointer type, an overload for std::nullptr_t is necessary to accept a nullptr argument. Without the std::nullptr_t overload, it would be ambiguous which pointer overload should be selected when passed nullptr . Example: void f(int *intp) { // Passed an int pointer } void f(char *charp) { // Passed a

If I write int zero = 0; void *p1 = (void *)0; void *p2 = (void *)(int)0; void *p3 = (void *)(0 /*no-op, but does it affect the next zero?*/, 0); void *p4 = (void *)zero; // For reference, this is a pointer to address zero void *p5 = 0; // For reference, this is a null pointer void *p6 = NULL; // For reference, this is a null pointer void *p7 = nullptr; // For reference, this is a null pointer (C++11) static const int static_zero_1 = 0; // Is this a literal zero when used? static const int static_zero_2 = 1 - 1; // No "literals 0" per se... is it? void *p8 = (void *)static_zero_1; // I have

I saw that nullptr was implemented in Visual Studio 2010. I like the concept and want to start using it as soon as possible; however GCC does not support it yet. My code needs to run on both (but doesn't have to compile with other compilers). Is there a way to "emulate" it? Something like: #define nullptr NULL (That obviously wouldn't work well at all, it's just to show what I mean.) The Official proposal has a workaround - const // this is a const object... class { public: template<class T> // convertible to any type operator T*() const // of null non-member { return 0; } // pointer...