C++ NULL与nullptr的区别
在C里面，由于处处都要使用指针，所以导致NULL遍布各地。我们先来看C99是怎么定义NULL的：
NULL can be defined as any null pointer constant. Thus existing code can retain definitions of
NULL as 0 or 0L, but an implementation may also choose to define it as (void*)0. This latterform of definition is convenient on architectures where sizeof(void*) does not equal thesize of any integer type. It has never been wise to use NULL in place of an arbitrary pointer as afunction argument, however, since pointers to different types need not be the same size. Thelibrary avoids this problem by providing special macros for the arguments to signal, the onelibrary function that might see a null function pointer.
A null pointer constant is an integer literal (2.13.2) with value zero or a prvalue of type std::nullptr_t.
A null pointer constant can be converted to a pointer type; the result is the null pointer value of that typeand is distinguishable from every other value of object pointer or function pointer type. Such a conversionis called a null pointer conversion. Two null pointer values of the same type shall compare equal. Theconversion of a null pointer constant to a pointer to cv-qualified type is a single conversion, and not thesequence of a pointer conversion followed by a qualification conversion (4.4). A null pointer constant ofintegral type can be converted to a prvalue of type std::nullptr_t. [ Note: The resulting prvalue is not anull pointer value. —end note ]
A prvalue of type “pointer to cv T,” where T is an object type, can be converted to a prvalue of type “pointerto cv void”. The result of converting a non-null pointer value of a pointer to object type to a “pointer tocv void” represents the address of the same byte in memory as the original pointer value. The null pointervalue is converted to the null pointer value of the destination type.
A prvalue of type “pointer to cv D”, where D is a class type, can be converted to a prvalue of type “pointerto cv B”, where B is a base class (Clause 10) of D. If B is an inaccessible (Clause 11) or ambiguous (10.2)base class of D, a program that necessitates this conversion is ill-formed. The result of the conversion is apointer to the base class subobject of the derived class object. The null pointer value is converted to thenull pointer value of the destination type.
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
#include <iostream>
#include <algorithm>
#include <memory>
void fun(int)
{
std::cout << "fuck1" << std::endl;
}
void fun(void *)
{
std::cout << "fuck2" << std::endl;
}
int main(int argc, char *argv[])
{
fun(NULL);
system("pause");
return 0;
}
int main(int argc, char *argv[])
{
fun(nullptr);
system("pause");
return 0;
}
struct Fuck
{
Fuck(char *){ }
};
int main(int argc, char *argv[])
{
auto p = std::make_shared<Fuck>(NULL);
throwing();
system("pause");
return 0;
}
template<class _Ty,
class... _Types> inline
shared_ptr<_Ty> make_shared(_Types&&... _Args)
{ // make a shared_ptr
_Ref_count_obj<_Ty> *_Rx =
new _Ref_count_obj<_Ty>(_STD forward<_Types>(_Args)...);
shared_ptr<_Ty> _Ret;
_Ret._Resetp0(_Rx->_Getptr(), _Rx);
return (_Ret);
}
// TEMPLATE CLASS _Ref_count_obj
template<class _Ty>
class _Ref_count_obj
: public _Ref_count_base
{ // handle reference counting for object in control block, no allocator
public:
template<class... _Types>
_Ref_count_obj(_Types&&... _Args)
: _Ref_count_base()
{ // construct from argument list
::new ((void *)&_Storage) _Ty(_STD forward<_Types>(_Args)...);
}
_Ty *_Getptr() const
{ // get pointer
return ((_Ty *)&_Storage);
}
private:
virtual void _Destroy() _NOEXCEPT
{ // destroy managed resource
_Getptr()->~_Ty();
}
virtual void _Delete_this() _NOEXCEPT
{ // destroy self
delete this;
}
typename aligned_union<1, _Ty>::type _Storage;
};
auto p = std::make_shared<Fuck>(nullptr);
