nullptr

This question already has answers here : Closed 8 years ago . Possible Duplicate: What exactly is nullptr? I first thought it's a keyword. My present gcc doesn't highlight nullptr in a different shade. To verify that, I wrote following: void *&p = nullptr; So I got some clue from the error that: error: invalid initialization of non-const reference of type ‘void*&’ from an rvalue of type ‘std::nullptr_t’ If nullptr is an object then is it really a pointer equivalent of simple 0 ? In other word, suppose I write: #define NULL nullptr Is the above statement doesn't alter anything in my code ? Also

Here is an example of a code that works perfectly: #include<iostream> #include<vector> template< class D, template< class D, class A > class C, class A = std::allocator< D > > void foo( C< D, A > *bar, C< D, A > *bas ) { std::cout << "Ok!" << std::endl; } int main( ) { std::vector< int > *sample1 = nullptr; std::vector< int > *sample2 = nullptr; foo( sample1, sample2 ); return( 0 ); } In the code below, however, the compiler is unable to match std::vector< int >* with nullptr for the second parameter, even being able to deduct the template types from the first parameter. #include<iostream>

Possible Duplicate: “Backporting” nullptr to C++-pre-C++0x programs How to define nullptr for supporting both C++03 and C++11? Does below code is compiled with both C++03 and C++11 compiles without change the meaning of nullptr in C++11 compiler? #include <cstddef> #if !defined(nullptr) #define nullptr NULL #endif In C++11, nullptr is of type nullptr_t . One of its big advantages compared to NULL (or to 0 would say Bjarne since he does not like macros) is that between these two functions: void foo(char*); void foo(int); foo(nullptr) will call the char* overload but foo(NULL) will call the int

I was playing with SFINAE and found behavior I cannot explain. This compiles fine : template<typename Integer, std::enable_if_t<std::is_integral<Integer>::value>* = nullptr> void foo(Integer) {} template<typename Floating, std::enable_if_t<std::is_floating_point<Floating>::value>* = nullptr> void foo(Floating) {} While this ( nullptr replaced with 0 ): template<typename Integer, std::enable_if_t<std::is_integral<Integer>::value>* = 0> void foo(Integer) {} template<typename Floating, std::enable_if_t<std::is_floating_point<Floating>::value>* = 0> void foo(Floating) {} gives me a compile error :

This question already has answers here : Assigning a reference by dereferencing a NULL pointer (5 answers) Closed 6 years ago . The following code fools around with nullptr pointer and reference: #include <cstdio> void printRefAddr(int &ref) { printf("printAddr %p\n", &ref); } int main() { int *ip = nullptr; int &ir = *ip; // 1. get address of nullptr reference printf("ip=%p &ir=%p\n", ip, &ir); // 2. dereference a nullptr pointer and pass it as reference printRefAddr(*ip); // 3. pass nullptr reference printRefAddr(ir); return 0; } Question : In C++ standards, are commented statements 1..3