C++ nullptr Explained: Why It Is Better Than NULL and 0

By the end of this page, you will understand what nullptr is in C++, why it was added in C++11, how std::nullptr_t relates to it, and why it is safer than NULL or 0. You will also see examples involving overload resolution, comparisons, and real-world coding patterns where nullptr avoids bugs and makes code clearer.

nullptr is the C++11 null pointer literal. It represents “this pointer points to nothing” in a type-safe way.

Before C++11, programmers often used:

0

or:

NULL

for null pointers. The problem is that 0 is fundamentally an integer literal, and NULL is usually just a macro that expands to 0 or 0L. That means they can behave like integers in contexts where you really intended a pointer.

nullptr fixes this problem.

What nullptr really is

• nullptr is a keyword in the language.
• It is a special literal value, similar in spirit to true, false, or numeric literals.
• The type of that literal is std::nullptr_t.

So these two statements are both true:

• nullptr is a language keyword.

Think of pointers as street addresses.

• A normal pointer holds the address of a real house.
• A null pointer means “no house exists here.”

Before nullptr, C++ often used the number 0 as a special code meaning “no address.” That worked, but it was awkward because 0 is also just the number zero.

So imagine writing on a form:

• 0 could mean “house number zero” or “no address.”
• nullptr is like having a dedicated checkbox labeled No Address.

That makes your intent obvious to both the compiler and other programmers.

Another useful analogy:

• 0 is a general-purpose symbol.
• nullptr is a purpose-built tool.

If you need to tighten a screw, you can sometimes force a coin to work, but a screwdriver is the right tool. nullptr is the right tool for null pointers.

Basic syntax

int* p = nullptr;
char* text = nullptr;

This means both pointers currently point to nothing.

Checking for null

if (p == nullptr) {
    std::cout << "p is null\n";
}

You will also often see:

if (!p) {
    std::cout << "p is null\n";
}

That works because pointers can be used in boolean contexts.

Function call example

#include <iostream>

void print(int value) {
    std::cout << "int overload: " << value << "\n";
}

void print(int* ptr) {
    std::cout << "pointer overload\n";
}

int main() {
    ();         
    ();   
}

Consider this program:

#include <iostream>

void show(int) {
    std::cout << "int version\n";
}

void show(const char*) {
    std::cout << "pointer version\n";
}

int main() {
    show(0);
    show(nullptr);
}

Step-by-step

1. The compiler sees two overloads

void show(int)
void show(const char*)

One accepts an integer, and one accepts a pointer.

2. show(0) is called

show();

1. Initializing pointers safely

FILE* file = nullptr;

This makes it obvious that the pointer does not currently refer to a valid object.

2. Optional ownership or resources

class Logger {
    std::ofstream* stream = nullptr;
};

A null pointer can mean “resource not available yet.”

3. Returning “not found” from pointer-based APIs

Node* findNode(const std::string& id) {
    return nullptr;
}

This clearly signals that no object was found.

4. Linked lists and trees

struct Node {
    int value;
    Node* next = nullptr;
};

Many data structures use null pointers to mark the end or absence of children.

5. Interfacing with older APIs

When working with libraries that still use raw pointers, nullptr expresses null safely:

In real codebases, nullptr is most commonly used as part of defensive programming and clear intent.

Guard clauses

void process(User* user) {
    if (user == nullptr) {
        return;
    }

    // safe to use user
}

This quickly exits when an invalid pointer is passed.

Constructor member initialization

class Engine {
public:
    Engine() : currentTask(nullptr) {}

private:
    Task* currentTask;
};

This prevents uninitialized pointer bugs.

Error handling in legacy pointer APIs

Connection* connect() {
    if (!serverAvailable()) {
        return nullptr;
    }

    return new Connection();
}

Configuration or optional dependency injection

1. Using NULL in modern C++

Problem

void log(int);
void log(char*);

log(NULL);

If NULL is 0, the integer overload may be chosen.

Better

log(nullptr);

2. Assuming nullptr is the same as integer zero

Problem

int x = nullptr; // error

nullptr is not an integer.

Fix

Use it only where a pointer-like null value is intended.

* p = ;

vs

Quick reference

Declare a null pointer

int* p = nullptr;

Check for null

if (p == nullptr) {}
if (p != nullptr) {}
if (!p) {}

Important facts

• nullptr was added in C++11.
• nullptr is a keyword.
• The type of nullptr is std::nullptr_t.
• It converts to any pointer type.
• It converts to any pointer-to-member type.
• It does not convert to normal integer types.
• Prefer nullptr over NULL and 0.

Good uses

MyClass* obj = nullptr;
return nullptr;
functionTakingPointer(nullptr);

Avoid

What is the type of nullptr in C++?

The type of nullptr is std::nullptr_t.

Is nullptr a keyword or an object?

It is a keyword that denotes a special literal value. That literal has the type std::nullptr_t.

Why is nullptr better than NULL?

nullptr has its own type and behaves like a real null pointer literal. NULL is usually just a macro for 0, which can cause overload and type-safety problems.

Why is nullptr better than 0?

0 is an integer literal. nullptr is specifically for pointers, so it is clearer and safer.

Can nullptr be compared with pointers?

Yes. It can be compared with any pointer type and pointer-to-member type.

Can nullptr be assigned to an ?

• pointers — nullptr is used to represent a pointer that points to nothing.
• references — useful to contrast with pointers, since references cannot be null in normal C++.
• function overloading — one of the main reasons nullptr is safer than 0 or NULL.
• implicit conversions — nullptr is designed to convert to pointer types but not integer types.
• std::nullptr_t — the dedicated type of the nullptr literal.
• smart pointers — modern C++ often uses nullptr with std::unique_ptr and std::shared_ptr.
• pointer-to-member — nullptr also works with pointer-to-member types, not just ordinary pointers.
• uninitialized variables — initializing pointers with nullptr helps avoid undefined behavior.