what is null pointer assignment error in c

Null Pointer Assignment Errors Explained

by Embarcadero USA Oct 19, 1993

Article originally contributed by Borland Staff

Understanding 0x0 0x0: A Deep Dive into the Null Pointer

10 min read

Table of contents

Background: what does 0x0 mean, definition of a null pointer, why null pointers are used, common null pointer errors, how memory addressing works, what does 0x0 mean in memory addressing, common errors with 0x0 memory addressing, best practices in writing code to avoid null errors, how to handle null pointer exceptions, debugging null pointer errors.

In programming, the null pointer is a concept that often perplexes even experienced developers. It's a source of frustration, bugs, and crashes that can derail even the most well-designed software. But what exactly is a null pointer, and why does it cause so many headaches?

In this article, we will unravel the mysteries surrounding null pointers and explore their significance, common errors, and how to prevent and handle them effectively. We will also examine real-world case studies to illustrate the impact of null pointer errors and the measures taken to overcome them.

The term "0x0 0x0" holds significance in the world of programming, particularly when it comes to null pointers. To understand its meaning, we need to explore the concept of null pointers and their representation in memory addressing.

In programming, a null pointer refers to a pointer variable that does not point to any valid memory address. Instead, it holds a special value called "null" or "nil," indicating the absence of a meaningful memory location. This concept is widely used in languages like C, C++, Java, and many others.

In computer systems, memory is divided into distinct units called memory addresses. These addresses act as unique identifiers for each location in memory, allowing the program to access and manipulate data stored in memory.

In hexadecimal notation, memory addresses are often represented with a prefix "0x." For example, "0x7FFF" is a memory address in hexadecimal form.

However, when we encounter "0x0 0x0," it refers specifically to the null pointer value. The "0x0" indicates that the pointer is pointing to address zero, which is an invalid or null memory location. It signifies that the pointer does not currently point to any valid object or data. This null value is commonly used to indicate the absence of a valid memory address, serving as a placeholder or default value for pointers.

Understanding the meaning of " 0x0 0x0 " in the context of null pointers is crucial for recognizing and handling null pointer errors effectively. By being aware of this representation, developers can identify when a pointer is null and take appropriate measures to prevent crashes, bugs, and unexpected behavior in their code.

Understanding Null Pointers

Null pointers are a fundamental concept in programming that can cause confusion and lead to errors if not handled properly. In this section, we will delve into the definition of a null pointer, why null pointers are used, and the common errors associated with them.

A null pointer is a special value assigned to a pointer variable that indicates it does not currently point to any valid memory location. Instead of containing the address of an object or data, a null pointer holds a value of "null" or "nil," signifying the absence of a meaningful memory address.

In programming languages, null pointers serve as a way to represent the concept of "nothingness" or the absence of an object or data reference. They are used as placeholders or default values for pointer variables when they do not have a valid object to point to.

It's important to note that a null pointer is distinct from a pointer that points to an empty memory location or a memory location with zeroed-out data. A null pointer explicitly signifies the absence of a valid memory address.

Null pointers have several uses in programming. They allow for the representation of optional or uninitialized values, provide a sentinel value to indicate the end of a data structure, and help in error handling and exception handling mechanisms.

One common use case for null pointers is when dealing with optional data.

For example , in a database application, a field may be optional, and if it is not filled, the corresponding pointer can be set to null. This allows for more flexibility in handling optional data and avoids unnecessary memory allocation.

Null pointers are also used in data structures such as linked lists, where a null pointer is often used to indicate the end of the list. This sentinel value helps in traversing the list and determining when to stop.

Additionally, null pointers play a crucial role in error handling and exception handling. When a function encounters an error or cannot return a valid result, it may use a null pointer to indicate the failure. This allows the calling code to check for the null value and handle the error accordingly.

While null pointers have their uses, they can also lead to errors if not handled properly. Here are some common null pointer errors that developers may encounter:

Null Pointer Dereference : This error occurs when a program attempts to access or manipulate data through a null pointer. Since null pointers do not point to valid memory locations, any attempt to access the data they are supposed to point to will result in a crash or undefined behavior.

Uninitialized Pointers : If a pointer is not properly initialized and is left with an indeterminate value, it can inadvertently hold a null value. Using such uninitialized pointers can lead to null pointer errors when attempting to dereference them.

Missing Null Pointer Checks : It is essential to check whether a pointer is null before attempting to use it. Failing to perform this check can result in null pointer errors, as the program may assume the pointer points to valid data and attempt to access it.

Incorrect Pointer Assignment : Assigning an incorrect value or forgetting to update a pointer can lead to null pointer errors. If a pointer is not assigned a valid memory address or is assigned a null value unintentionally, it can cause unexpected behavior and crashes.

Understanding these common null pointer errors is crucial for writing robust and reliable code.

The Significance of 0x0 in Memory Addressing

When it comes to memory addressing, the value 0x0 holds a particular significance. In this section, we will explore how memory addressing works, what 0x0 represents in memory addressing, and the common errors associated with it.

Before deep-diving into the significance of 0x0, it's important to understand the basics of memory addressing. In computer systems, memory is organized into a linear array of storage locations, each with a unique address. These addresses serve as identifiers for accessing and manipulating data stored in memory.

The size of each memory address depends on the architecture of the system. For example, in a 32-bit system, memory addresses may be represented using 32 bits, allowing for a range of 2^32 (approximately 4.3 billion) unique memory locations. In a 64-bit system, the address size expands to 64 bits, providing a significantly larger addressable memory space.

When a program is executed, it is loaded into memory, and variables, objects, and data structures are allocated memory addresses. Pointers, in particular, hold these memory addresses as their values, allowing for indirect access to the data they point to.

In memory addressing, the value 0x0 represents address zero, which is typically the lowest memory location in a system's address space. This address is often referred to as the "null address" or "null pointer."

Assigning a pointer a value of 0x0 indicates that it is currently not pointing to any valid memory location. It represents a null pointer, signifying the absence of an object or data reference.

It's important to note that the address zero is typically reserved and not accessible for storing valid data. Attempting to access or dereference a pointer with a value of 0x0 can result in a null pointer error, leading to crashes or undefined behavior.

One common error associated with 0x0 memory addressing is the null pointer dereference. This occurs when a program attempts to access or manipulate data through a pointer with a value of 0x0. Since the null address does not point to a valid memory location, any attempt to access or modify data through such a pointer will result in a crash or undefined behavior.

Another error is improperly assigning or comparing pointers with the value 0x0. It's crucial to handle null pointers appropriately and avoid unintended assignments or comparisons that could lead to null pointer errors.

Understanding the significance of 0x0 in memory addressing is essential for detecting and handling null pointer errors effectively. In the next section, we will explore best practices in writing code to avoid null errors altogether, providing useful strategies for preventing such errors and ensuring robust software development.

Preventing and Handling Null Pointer Errors

Preventing and handling null pointer errors is crucial for writing robust and reliable code. In this section, we will discuss best practices in writing code to avoid null errors, strategies for handling null pointer exceptions, and techniques for debugging null pointer errors.

To prevent null pointer errors, it's important to follow certain best practices during the code development process. Here are some guidelines to consider:

Initialize Pointers : Always initialize pointers to a valid memory address or null explicitly. Avoid leaving pointers uninitialized, as they can inadvertently hold a null value, leading to null pointer errors.

Avoid Unnecessary Null Assignments : Be cautious when assigning null values to pointers. Only assign null when necessary, such as when representing optional or uninitialized values. Avoid unintentional null assignments that can introduce null pointer errors.

Null Pointer Checks : Before accessing or dereferencing a pointer, perform a null pointer check to ensure it is not null. This can be done using conditional statements or language-specific null-checking mechanisms. By checking for null values, you can handle them gracefully and prevent crashes.

Proper Pointer Usage : Ensure that pointers are used correctly throughout your code. Avoid using pointers that have been deallocated or have gone out of scope, as they can result in null pointer errors. Additionally, be mindful of pointer arithmetic and ensure that it is performed on valid memory addresses.

Despite taking preventative measures, null pointer exceptions can still occur in certain scenarios. Handling these exceptions effectively is crucial for maintaining the stability of your code. Here are strategies to handle null pointer exceptions:

Null Check before Usage : Before accessing or manipulating data through a pointer, perform a null check. If the pointer is null, handle the exception appropriately, such as by returning an error or displaying a user-friendly message.

Error Handling Mechanisms : Implement robust error handling mechanisms in your code. This may include try-catch blocks, exception handling routines, or error reporting systems. By capturing and handling null pointer exceptions, you can prevent crashes and provide informative feedback to users or developers.

Graceful Recovery : Whenever possible, aim to recover gracefully from null pointer exceptions. This may involve providing default values, alternative paths, or fallback options to ensure the smooth execution of your code even in the presence of null pointers.

When null pointer errors occur, debugging becomes essential to identify the root causes and rectify the issues. Here are some techniques to help debug null pointer errors effectively:

Logging and Error Messages : Implement comprehensive logging and error message systems in your code. By logging relevant information and displaying informative error messages, you can gain insights into the occurrence of null pointer errors and their specific contexts.

Code Inspection and Review : Conduct thorough code inspections and reviews to identify potential null pointer errors. Look for instances where pointers are assigned null values, where null checks are missing, or where uninitialized pointers are used.

Debugging Tools : Utilize debugging tools provided by your development environment or programming language to step through the code and track the flow of execution. These tools can help pinpoint the exact location and cause of null pointer errors, making the debugging process more efficient.

By following best practices, handling null pointer exceptions effectively, and employing appropriate debugging techniques, you can minimize the occurrence of null pointer errors and ensure the stability and reliability of your code.

We examined the meaning of 0x0 in memory addressing and its relation to null pointers. We also discussed best practices to avoid null errors, strategies for handling null pointer exceptions, and techniques for debugging null pointer errors.

By understanding null pointers and their associated challenges, developers can write more robust and error-free code. Through effective prevention, handling, and debugging, null pointer errors can be minimized, leading to more stable and reliable software applications.

We hope this deep dive into the world of null pointers has provided you with valuable insights and practical knowledge to navigate the complexities of null pointer errors. Remember to always be vigilant when working with pointers and strive for best practices to ensure the quality of your code.

• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

NULL pointer in C

A null pointer is a pointer which points nothing.

Some uses of the null pointer are:

a) To initialize a pointer variable when that pointer variable isn’t assigned any valid memory address yet.

b) To pass a null pointer to a function argument when we don’t want to pass any valid memory address.

c) To check for null pointer before accessing any pointer variable. So that, we can perform error handling in pointer related code e.g. dereference pointer variable only if it’s not NULL.

 Live Demo

Related Articles

• Null Pointer Exception in C#
• Differentiate the NULL pointer with Void pointer in C language
• Calling class method through NULL class pointer in C++
• Null Pointer Exception in Java Programming
• Why is address zero used for the null pointer in C/C++?
• Calling a member function on a NULL object pointer in C++
• Why do we check for a NULL pointer before deleting in C/C++?
• Double Pointer (Pointer to Pointer) in C
• What should we assign to a C++ pointer: A Null or 0?
• Pointer Arithmetic in C/C++
• void pointer in C
• Function Pointer in C
• Explain the concept of pointer to pointer and void pointer in C language?
• How to define pointer to pointer in C language?
• Explain the concept of Array of Pointer and Pointer to Pointer in C programming

Kickstart Your Career

Get certified by completing the course

To Continue Learning Please Login

• Design Pattern
• Interview Q

C Control Statements

C functions, c dynamic memory, c structure union, c file handling, c preprocessor, c command line, c programming test, c interview.

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse

Next: Argument Promotions , Previous: Explicit Type Conversion , Up: Type Conversions   [ Contents ][ Index ]

24.2 Assignment Type Conversions

Certain type conversions occur automatically in assignments and certain other contexts. These are the conversions assignments can do:

• Converting any numeric type to any other numeric type.
• Converting void * to any other pointer type (except pointer-to-function types).
• Converting any other pointer type to void * . (except pointer-to-function types).
• Converting 0 (a null pointer constant) to any pointer type.
• Converting any pointer type to bool . (The result is 1 if the pointer is not null.)
• Converting between pointer types when the left-hand target type is upward compatible with the right-hand target type. See Compatible Types .

These type conversions occur automatically in certain contexts, which are:

converts 5 to double .

also converts 5 to double .

In all three contexts, if the conversion is impossible, that constitutes an error.

• Understanding Quick Sort for coding interviews
• Understanding Insertion Sort for coding interviews
• Understanding Bubble Sort for coding interviews
• Understanding selection sort for coding interviews
• Generate binary numbers using a queue

Top 20 C pointer mistakes and how to fix them

After I graduated college with a BS in Electrical Engineering, I thought that was the last time I was going to program in “C”. I could not have been more wrong. Throughout various points in my career, I’ve encountered and wrangled with a decent amount of “C” code either due to legacy or portability reasons.

Pointers are the most complicated and fundamental part of the C Programming language. Most of the mistakes I’ve made in school assignments and production code is in handling pointers. So here is my attempt to catalog some of the common and not so common mistakes – something I ca refer back to the next time I have to write production code in C. Hope it helps you as well.

Mistake # 1: Omitting the pointer “*” character when declaring multiple pointers in same declaration

Consider the following declaration:

It declares an integer pointer p1 and an integer p2 . More often than not, the intent is to declare two integer pointers.

In the test code below, the last line will result in a compile error “Error C2440 ‘=’: cannot convert from ‘int *’ to ‘int’ ”

This is a pretty basic mistake that most modern compilers will catch.

Recommended Fix:

Use the following declaration to declare two pointers of the same type:

Alternatively, use a typedef – for example,

and then, use this type when declaraing pointers:

Mistake # 2: Using uninitialized pointers

The usage of an uninitialized pointer typically results in program crashes if the pointer accesses memory it is not allowed to.

Consider the code below:

On debug builds in Visual Studio, you’ll first get the following error:

followed by:

0xcc is microsoft’s debug mode marker for uninitialized stack memory.

On release builds, you’ll encounter a runtime crash on the line :printf(“%d”, n);

Recommended Fix: Always initialize pointers to a valid value.

Mistake # 3: Assigning a pointer to an uninitialized variable

This is more dangerous, IMHO, than an uninitialized pointer.In this case, unlike an uninitialized pointer, you won’t get a crash. Instead it can lead to serious logic errors in your code.

On debug builds, it’ll result in a large negative number like “-858993460”. In VC++, the result will be 0 but that is not guaranteed by the C standard .  More specifically item 1652 in the referenced doc states that If an object that has automatic storage duration is not initialized explicitly, its value is indeterminate.

Deceptively simple – do not assign pointers to uninitialized variables.

Mistake # 4: Assigning value to pointer variables

Another one of the novice errors where the IDE/compiler will most likely bail you out. Consider the code:

The problem is that p1 can contain an address of an int and not the int value itself. You’ll get a compiler error:

Assign the address of the integer variable to the pointer .

Mistake # 5: Incorrect syntax for incrementing dereferenced pointer values

If the intent is to increment a variable pointed to by a pointer, the following code fails to achieve that.

In fact, p1 now points to an undefined memory location. When you run this code, you get the following output with the first line corresponding to the value at the address p1 points to.

Recommended Fix: To increment a dereferenced pointer, use : (*p1)++;

Mistake # 6: Trying to deallocate stack memory using free()

Consider the code below where variable m is allocated on the stack.

Attempting to free memory on the stack using the free() function throws an access violation.

Memory on the stack(non-pointer variables) is done implicitly by the system. It is illegal to get memory from the stack and return it to the heap.

Recommended Fix: Use free() to deallocate memory that has been previously allocated by malloc() or one of its variants. Always remember where the memory came from – stack or heap 🙂

Mistake # 7: Dereferncing the value of a pointer after it has been freed

Consider the following code – we allocate an integre pointer, use it , free the memory associated with the pointer and then try to use the pointer again. This’ll end in undefined behavior – maybe crashes depending on the state of the system/platform.

Never use a pointer after it has been freed. A good practice is to set the pointer to NULL after it has been freed such that any attempt to use it again is caught by an access violation.A crash during development is better than undefined behavior after release 🙂

Mistake # 8 : Double free()

Calling free() on a block of memory twice will lead to heap corruption. For example, the following code results in an unhandled exception indicating heap corruption using MS VC++:

This type of issue caused a security vulnerability in zlib which you can read about here .

Do not free the same block of memory twice! Simply assign NULL to a pointer after it has been freed. Subsequent attempts to free a null pointer will be ignored by most heap managers.

Mistake # 9 : Not using sizeof() operator with malloc

If you’re implementing something in C in this day and age, most likely you’re doing it with platform portability in mind. The size of data types can vary across different platform architectures. If you write something like malloc(2), you might have trouble porting it across platforms.

Recommended Fix: Always use sizeof(type) with malloc – for example:

Mistake # 10 : Using a pointer and sizeof() to determine the size of an array

In the code below, sizeof(arr) will correctly determine the size of the char array but a pointer to the array won’t. The type of *cp is const char, which can only have a size of 1, whereas the type of arr is different: array of const char.

Recommended Fix: Never use sizeof on a pointer to an array to determine the size of the array.

Mistake # 11 : Creating garbage objects using C pointers

You need a pointer to a memory location to free / deallocate that memory. If you re-assign a pointer and there is no other pointer pointing to that memory block, you cannot deallocate that previous memory block. This causes a memory leak.

“Memory block 1” is not inaccessible because we don’t have a pointer to it. Without having a pointer to a memory block, we cannot call free() on a block and we’ve created a garbage object in that block – in other words, we leaked memory.

In general, it’s not a good idea to recycle pointer variables. Use new pointer variables where possible and remember to set a pointer variable to NULL right after it has been freed.

Mistake # 12 : Not Understanding the difference between shallow copy and deep copy

Given two pointers p and q, the assignment p = q does not copy the block of memory pointed to by q into a block of memory pointed to by p; instead it assigns memory addresses ( so that both p and q point to the same memory location; changing the value of that memory location affects both pointers).

So what just happened?

In the shallow copy case, af1 and af2 both points to the same memory location. Any change to the memory location via af2 is reflected when af1 is used.

In the deep copy case, when we modify af3 (which points to an entirely different memory block than af1), the memory block pointed by af1 is not affected.

Mistake # 13 : Freeing a memory block shared by two pointers using one of the pointers and subsequently trying to use the other pointer

In the code below,. str1 and str2 points to the same memory block – so when str1 is freed, essentially the memory block pointed to by str2 is freed. Any attempt to use str2 after str1 has been freed will cause undefined behavior. In the case of the program below – it’ll print some garbage value.

There’s really no good way around this in C except to use static analyzers. If you’re in C++, you can use shared_pointers – but use caution as advised in the linked article. . There’s also a good discussion on Stackoverflow on this topic.

Mistake # 14 : Trying to access memory locations not allocated by your code

If you have allocated a block of n objects, do not try to access objects beyond this block ( which includes any objects in locations p+n and beyond)

The statement  doubleVals[SIZE] = 25.99  is essentially writing over memory it does not own – which can cause undefined behavior in programs.

Always be aware of the bounds of memory allocated by your code and operate within those safe limits.

Mistake # 15 : Off by one errors when operating on C pointers

Given a block of memory of SIZE objects pointed to by p, the last object in the block can be retrieved by using another pointer q and setting it to (p+SIZE-1) instead of (p+SIZE).

The first print statement incorrectly prints “0” while the last element is “9”. The second print statement fixes it by accessing the last element at (q + SIZE – 1)

Carefully apply the “off by one error” rules that you learnt for array access to pointers.

Mistake # 16 : Mismatching the type of pointer and type of underlying data

Always use the appropriate pointer type for the data. Consider the code below where a pointer to an integer is assigned to a short:

Notice that it appears that the first hexadecimal digit stored at address 100 is 7 or f, depending on whether it is displayed as an integer or as a short. This apparent contradiction is an artifact of executing this sequence on a little endian machine.If we treat this as a short number and only use the first two bytes, then we get the short value of –1. If we treat this as an integer and use all four bytes, then we get 2,147,483,647.

Always use the correct pointer type for a specific data type – int* for int , double* for double etc.

Mistake # 17 : Comparing two pointers to determine object equality

Often we want to compare if the contents of two objects are same – for example check if two strings are equal.

In the code below, clearly the intent was to check if both strings are “Thunderbird”. But, we ended up comparing the memory addresses with the statement “str1 == str2”. Here str1 and str2 are essentially pointers to different memory addresses which holds the same string.

The code can be made to work as intended, i.e., compare string contents by making the following changes:

Always remember to compare the contents of the memory location pointed to by pointers instead of comparing the address of pointer themselves.

Mistake # 18 : Thinking that C arrays are pointers

While C pointers and Arrays can be used interchangeably in most situations, they are not quite the same. Here’s an example of where it is a recipe for access violation.

In File2.cpp, global_array is declared as an pointer but defined as an array in File1.cpp. At a high level, the compile generates different code for array indexing and access via pointer.

Change the declaration so it does match the definition, like:

Note: A detailed discussion is beyond the scope of this article. The best explanation of this issue I found was in the section, “Chapter 4. The Shocking Truth: C Arrays and Pointers Are NOT the Same!” in Deep C Secrets . It’s a fantastic book if you really want to become an expert C programmer – highly recommended.

Mistake # 19 : Not clearing out sensitive heap data managed through pointers

When an application terminates, most operating systems do not zero out or erase the heap memory that was in use by your application. The memory blocks used by your application can be allocated to another program, which can use the contents of non-zeroed out memory blocks. Just imagine you asked for a security question from the user and stored it in heap memory – it’s always a good idea to erase that memory block contents before returning the memory to the Operating System via free().

Mistake # 20 : Not taking time to understand C function pointers

Functions pointers are used extensively in many large scale production system. It’s also critical to understand more advanced concepts like callbacks, events in Win32 or lambdas in standard C++.

Here’s an example of function pointer in linux kernel:

If code like this makes your head swivel, no sweat – mine did too when i started my career. 🙂

The problem is that most college level C courses seldom does any deep exploration of function pointers, whereas once you’re in industry, it’s all over the place. Here is a good book that has an in-depth treatment of C function pointers : Understanding and Using C Pointers .

Final Thoughts

C is one of the oldest languages in use today. Pointers forms the heart and soul of C. Pointers are not only useful for writing production quality code but also in school for understanding the concepts behind self referential data structures like linked list and binary trees. Even if you are working in a high level language like Java or C#, an object is essentially a pointer. So, study pointers well because they keep showing up in coding interviews and tech screens – I wouldn’t be surprised if you get a question similar to the code snippets in this article and asked “what’s wrong with this piece of C code?”.

Good luck !

• 35 things I learnt at Game Developer Conference (GDC) 2018
• System Design Interview Concepts – CAP Theorem

12.8 — Null pointers

In the previous lesson ( 12.7 -- Introduction to pointers ), we covered the basics of pointers, which are objects that hold the address of another object. This address can be dereferenced using the dereference operator (*) to get the object at that address:

The above example prints:

In the prior lesson, we also noted that pointers do not need to point to anything. In this lesson, we’ll explore such pointers (and the various implications of pointing to nothing) further.

Null pointers

Besides a memory address, there is one additional value that a pointer can hold: a null value. A null value (often shortened to null ) is a special value that means something has no value. When a pointer is holding a null value, it means the pointer is not pointing at anything. Such a pointer is called a null pointer .

The easiest way to create a null pointer is to use value initialization:

Best practice

Value initialize your pointers (to be null pointers) if you are not initializing them with the address of a valid object.

Because we can use assignment to change what a pointer is pointing at, a pointer that is initially set to null can later be changed to point at a valid object:

The nullptr keyword

Much like the keywords true and false represent Boolean literal values, the nullptr keyword represents a null pointer literal. We can use nullptr to explicitly initialize or assign a pointer a null value.

In the above example, we use assignment to set the value of ptr2 to nullptr , making ptr2 a null pointer.

Use nullptr when you need a null pointer literal for initialization, assignment, or passing a null pointer to a function.

Dereferencing a null pointer results in undefined behavior

Much like dereferencing a dangling (or wild) pointer leads to undefined behavior, dereferencing a null pointer also leads to undefined behavior. In most cases, it will crash your application.

The following program illustrates this, and will probably crash or terminate your application abnormally when you run it (go ahead, try it, you won’t harm your machine):

Conceptually, this makes sense. Dereferencing a pointer means “go to the address the pointer is pointing at and access the value there”. A null pointer holds a null value, which semantically means the pointer is not pointing at anything. So what value would it access?

Accidentally dereferencing null and dangling pointers is one of the most common mistakes C++ programmers make, and is probably the most common reason that C++ programs crash in practice.

Whenever you are using pointers, you’ll need to be extra careful that your code isn’t dereferencing null or dangling pointers, as this will cause undefined behavior (probably an application crash).

Checking for null pointers

Much like we can use a conditional to test Boolean values for true or false , we can use a conditional to test whether a pointer has value nullptr or not:

The above program prints:

In lesson 4.9 -- Boolean values , we noted that integral values will implicitly convert into Boolean values: an integral value of 0 converts to Boolean value false , and any other integral value converts to Boolean value true .

Similarly, pointers will also implicitly convert to Boolean values: a null pointer converts to Boolean value false , and a non-null pointer converts to Boolean value true . This allows us to skip explicitly testing for nullptr and just use the implicit conversion to Boolean to test whether a pointer is a null pointer. The following program is equivalent to the prior one:

Conditionals can only be used to differentiate null pointers from non-null pointers. There is no convenient way to determine whether a non-null pointer is pointing to a valid object or dangling (pointing to an invalid object).

Use nullptr to avoid dangling pointers

Above, we mentioned that dereferencing a pointer that is either null or dangling will result in undefined behavior. Therefore, we need to ensure our code does not do either of these things.

We can easily avoid dereferencing a null pointer by using a conditional to ensure a pointer is non-null before trying to dereference it:

But what about dangling pointers? Because there is no way to detect whether a pointer is dangling, we need to avoid having any dangling pointers in our program in the first place. We do that by ensuring that any pointer that is not pointing at a valid object is set to nullptr .

That way, before dereferencing a pointer, we only need to test whether it is null -- if it is non-null, we assume the pointer is not dangling.

A pointer should either hold the address of a valid object, or be set to nullptr. That way we only need to test pointers for null, and can assume any non-null pointer is valid.

Unfortunately, avoiding dangling pointers isn’t always easy: when an object is destroyed, any pointers to that object will be left dangling. Such pointers are not nulled automatically! It is the programmer’s responsibility to ensure that all pointers to an object that has just been destroyed are properly set to nullptr .

When an object is destroyed, any pointers to the destroyed object will be left dangling (they will not be automatically set to nullptr ). It is your responsibility to detect these cases and ensure those pointers are subsequently set to nullptr .

Legacy null pointer literals: 0 and NULL

In older code, you may see two other literal values used instead of nullptr .

The first is the literal 0 . In the context of a pointer, the literal 0 is specially defined to mean a null value, and is the only time you can assign an integral literal to a pointer.

As an aside…

On modern architectures, the address 0 is typically used to represent a null pointer. However, this value is not guaranteed by the C++ standard, and some architectures use other values. The literal 0 , when used in the context of a null pointer, will be translated into whatever address the architecture uses to represent a null pointer.

Additionally, there is a preprocessor macro named NULL (defined in the <cstddef> header). This macro is inherited from C, where it is commonly used to indicate a null pointer.

Both 0 and NULL should be avoided in modern C++ (use nullptr instead). We discuss why in lesson 12.11 -- Pass by address (part 2) .

Favor references over pointers whenever possible

Pointers and references both give us the ability to access some other object indirectly.

Pointers have the additional abilities of being able to change what they are pointing at, and to be pointed at null. However, these pointer abilities are also inherently dangerous: A null pointer runs the risk of being dereferenced, and the ability to change what a pointer is pointing at can make creating dangling pointers easier:

Since references can’t be bound to null, we don’t have to worry about null references. And because references must be bound to a valid object upon creation and then can not be reseated, dangling references are harder to create.

Because they are safer, references should be favored over pointers, unless the additional capabilities provided by pointers are required.

Favor references over pointers unless the additional capabilities provided by pointers are needed.

Question #1

1a) Can we determine whether a pointer is a null pointer or not? If so, how?

Show Solution

Yes, we can use a conditional (if statement or conditional operator) on the pointer. A pointer will convert to Boolean false if it is a null pointer, and true otherwise.

1b) Can we determine whether a non-null pointer is valid or dangling? If so, how?

There is no easy way to determine this.

Question #2

For each subitem, answer whether the action described will result in behavior that is: predictable, undefined, or possibly undefined. If the answer is “possibly undefined”, clarify when.

2a) Assigning a new address to a non-const pointer

Predictable.

2b) Assigning nullptr to a pointer

2c) Dereferencing a pointer to a valid object

2d) Dereferencing a dangling pointer

2e) Dereferencing a null pointer

2f) Dereferencing a non-null pointer

Possibly undefined, if the pointer is dangling.

Question #3

Why should we set pointers that aren’t pointing to a valid object to ‘nullptr’?

We can not determine whether a non-null pointer is valid or dangling, and accessing a dangling pointer will result in undefined behavior. Therefore, we need to ensure that we do not have any dangling pointers in our program.

If we ensure all pointers are either pointing to valid objects or set to nullptr , then we can use a conditional to test for null to ensure we don’t dereference a null pointer, and assume all non-null pointers are pointing to valid objects.

cppreference.com

Std:: unique_ptr.

std::unique_ptr is a smart pointer that owns and manages another object through a pointer and disposes of that object when the unique_ptr goes out of scope.

The object is disposed of, using the associated deleter when either of the following happens:

• the managing unique_ptr object is destroyed.
• the managing unique_ptr object is assigned another pointer via operator= or reset() .

The object is disposed of, using a potentially user-supplied deleter by calling get_deleter ( ) ( ptr ) . The default deleter uses the delete operator, which destroys the object and deallocates the memory.

A unique_ptr may alternatively own no object, in which case it is called empty .

There are two versions of std::unique_ptr :

• Manages a single object (e.g. allocated with new ).
• Manages a dynamically-allocated array of objects (e.g. allocated with new [ ] ).

The class satisfies the requirements of MoveConstructible and MoveAssignable , but of neither CopyConstructible nor CopyAssignable .

[ edit ] Notes

Only non-const unique_ptr can transfer the ownership of the managed object to another unique_ptr . If an object's lifetime is managed by a const std :: unique_ptr , it is limited to the scope in which the pointer was created.

std::unique_ptr is commonly used to manage the lifetime of objects, including:

• providing exception safety to classes and functions that handle objects with dynamic lifetime, by guaranteeing deletion on both normal exit and exit through exception.
• passing ownership of uniquely-owned objects with dynamic lifetime into functions.
• acquiring ownership of uniquely-owned objects with dynamic lifetime from functions.
• as the element type in move-aware containers, such as std::vector , which hold pointers to dynamically-allocated objects (e.g. if polymorphic behavior is desired).

std::unique_ptr may be constructed for an incomplete type T , such as to facilitate the use as a handle in the pImpl idiom . If the default deleter is used, T must be complete at the point in code where the deleter is invoked, which happens in the destructor, move assignment operator, and reset member function of std::unique_ptr . (Conversely, std::shared_ptr can't be constructed from a raw pointer to incomplete type, but can be destroyed where T is incomplete). Note that if T is a class template specialization, use of unique_ptr as an operand, e.g. ! p requires T 's parameters to be complete due to ADL .

If T is a derived class of some base B , then std :: unique_ptr < T > is implicitly convertible to std :: unique_ptr < B > . The default deleter of the resulting std :: unique_ptr < B > will use operator delete for B , leading to undefined behavior unless the destructor of B is virtual . Note that std::shared_ptr behaves differently: std:: shared_ptr < B > will use the operator delete for the type T and the owned object will be deleted correctly even if the destructor of B is not virtual .

Unlike std::shared_ptr , std::unique_ptr may manage an object through any custom handle type that satisfies NullablePointer . This allows, for example, managing objects located in shared memory, by supplying a Deleter that defines typedef boost::offset_ptr pointer; or another fancy pointer .

[ edit ] Member types

[ edit ] member functions, [ edit ] non-member functions, [ edit ] helper classes, [ edit ] example.

Possible output:

[ edit ] See also

• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 10 October 2023, at 11:28.
• This page has been accessed 5,735,047 times.
• Privacy policy
• About cppreference.com
• Disclaimers

Fill out the form in 2 simple steps below:

Your contact information:, desired license type:.

Your message has been sent. We will email you at

If you haven't received our response, please do the following: check your Spam/Junk folder and click the "Not Spam" button for our message. This way, you won't miss messages from our team in the future.

Error on verge of extinction, or why I put if (x = 42) in Red List of C & C++ bugs

If we ask a programmer what bugs are the most common in C and C++ code, they'll name a null pointer dereference, undefined behavior, array overrun, and other typical error patterns. They may name an accidental assignment in condition as well. However, let's see if this error is common today.

C and C++ use the = symbol for the assignment operator and == for the comparison operator. That's why we may make typos when we write = instead of == and get compliable but incorrectly operating code.

These errors look like this:

There are two unpleasant things going on at once:

• The condition is always true or false, depending on what is assigned to the variable.
• The correct value has been lost. If the abcd variable is used elsewhere, its value will be invalid (corrupted).

These errors are simple yet common and notorious among programmers. Although devs don't film movies about bugs, they make memes about them.

The bugs look like they're from these memes, though. For example, I've found the following code in the AMT SDK project:

Because of this bug, developers invented the Yoda notation : a programming style where the constant is placed on the left side of the comparison operator.

This style was meant to prevent a typo. If a programmer writes = instead of == , the code won't compile.

However, this notation hasn't caught on in real cases. At least, I've seen it very rarely in open-source projects.

Btw, I don't like this coding style too. First, it makes the code a bit more complicated: you look at the constant and only then realize what the code is about and what is checked.

Second, the coding style won't help if two variables are compared with each other:

In my opinion, it's better to declare all variables that are further used read-only as const . This reduces the likelihood that typos or failed refactoring will cause accidental modification.

Sorry, I got a little distracted. In the beginning, I talked about the rarity of such bugs and the Red List. Let's get back to the main topic of the article.

Once I was preparing for a conference talk, where I've discussed how expectations to find errors in code align with reality. To prove it, I researched our collection of bugs found over several years of writing articles about open-source project checking.

Sometimes, expectations match reality. For example, programmers suppose that there are many bugs in C and C++ code related to null pointer dereference and array overrun. Indeed, such bugs are common.

Sometimes, expectations don't match reality. A programmer is very likely to say something about division by zero, but there are few such errors in reality. At least if we compare it to many other bugs.

Of course, I couldn't help but look at assignment errors in conditions. It seems like there should be a mountain of them.

But, surprise, surprise, that such errors are quite rare in open-source projects! We only found 14 cases . Fun fact, but the last error we wrote out was in 2016 !

It's amazing how high expectations are, and there are no errors!

Let's dig deeper into the statistics again. With the V559 diagnostic rule, the PVS-Studio analyzer detects errors related to an assignment in a condition. The rule was introduced in PVS-Studio 4.12 on February 7, 2011.

For some time, the analyzer found these errors, but gradually they became fewer and fewer. The last one we found was in 2016. Although we still write many articles about checking open-source projects, it has been eight years since we last saw errors like that.

I think this is an amazing and nice example of how some kinds of errors go extinct due to development of programmers' tools. I don't think that such errors have died off because everyone is aware of them, and now developers write code more carefully. As our experience shows, typos are still as common as they're 10 years ago.

So, it looks like the tools affect it. At first, static analyzers detected such errors. Then the compilers caught it up and started to detect it too. Generally, there are no compilers that will ignore an assignment in a condition. If we write such code now, and we'll see warnings all around: an IDE highlights the code, compilers and static analyzers issue warnings. We just can't help but see the error. Gorgeous!

Of course, I'm not saying that there are no programs with these bugs at all. We encounter such programs, but they're very rare. In addition, in my experience, we haven't seen them in a long time when checking different projects.

By the way, doesn't it mean that static analyzers will become unnecessary as compilers issue more and more warnings? No, of course not. The analyzer development doesn't stand still, either. They are working on to detect more and more complex and intricate errors. Analyzers comprises such technologies as interprocedural and intermodular analysis, data-flow analysis, symbolic execution, taint analysis, and so on. In addition, they can afford to run longer and use more memory than compilers. This means we can go deeper and analyze more complex data.

We may say that static analyzers set the direction of compilers development in terms of detecting bugs. We've even noticed how diagnostic rules from PVS-Studio move into compilers. Our team is proud that PVS-Studio is a source of inspiration for new things coming out. Let good diagnostic rules influence the tools. This way, there will be fewer errors. Meanwhile, we'll write more rules. After all, someone has to find bugs in compilers :)

Here's an example of the typo in the LLVM code — the PVS-Studio analyzer issued the following warning: V547 Expression 'FirstSemiPos == std::string::npos' is always false. UnicodeNameMappingGenerator.cpp 46.

If you wish, you can look at other bugs in compilers .

Finally, let's look back at the assignment in the condition:

What if the code author really wants to assign and check at the same time?

The first option: if we write in C++ and we need the variable only inside the body of the if/while instruction, we can declare it directly in the condition.

Now it's obvious, that there's a variable declaration with initialization and subsequent check.

The second option: almost all developers of compilers and code analyzers have an unspoken agreement that additional parentheses are a sign that everything is OK.

If a programmer has written the code like this, it almost sounds like, "I know what I am doing, this code is correct". In this case, compilers and analyzers don't issue the warning.

Thank you for your attention. The Skeletor Unicorn will be back soon with some new, mind-boggling information.

We can email you a selection of our best articles once a month

Posts: articles

Date: May 29 2024

Author: Alexey Smolskas

Date: May 23 2024

Author: Andrey Karpov

Date: May 16 2024

Date: May 14 2024

Author: Taras Shevchenko

Date: May 07 2024

Get notifications about comments to this article

You subscribed to the comments

Comments ( 0 )

Want to try pvs‑studio for free.

• C++ Data Types
• C++ Input/Output
• C++ Pointers
• C++ Interview Questions
• C++ Programs
• C++ Cheatsheet
• C++ Projects
• C++ Exception Handling
• C++ Memory Management

NULL Pointer in C++

• Opaque Pointer in C++
• Function Pointer in C++
• Function Pointer in C
• void Pointer in C++
• 'this' pointer in C++
• type_traits::is_null_pointer in C++
• Smart Pointers in C++
• Pointers in Objective-C
• is_pointer Template in C++
• Dereference Pointer in C
• Understanding nullptr in C++
• NULL Pointer in C
• C File Pointer
• Null Pointer Exception In Java
• void Pointer in C
• Passing NULL to printf in C
• Structure Pointer in C

A NULL Pointer in C++ indicates the absence of a valid memory address in C++. It tells that the pointer is not pointing to any valid memory location In other words, it has the value “NULL” (or ‘ nullpt r’ since C++11). This is generally done at the time of variable declaration to check whether the pointer points to some valid memory address or not. It is also returned by several inbuilt functions as a failure response.

Trying to dereference a NULL pointer i.e. trying to access the memory it points to leads to some undefined behavior leading to the program crash.

Syntax of Null Pointer in C++

We can create a NULL pointer of any type by simply assigning the value NULL to the pointer as shown:

A null pointer is represented by the value 0 or by using the keyword NULL. With the new versions of C++ like C++11 and later, we can use “nullptr” to indicate a null pointer.

Checking NULL Pointer

We can check whether a pointer is a NULL pointer by using the equality comparison operator.

The above expression will return true if the pointer is a NULL pointer. False otherwise.

Applications of Null Pointer in C++

Null Pointer finds its applications in the following scenarios:

• Initialization: It is a good practice to Initialize pointers to a null value as it helps avoid undefined behavior by explicitly indicating they are not pointing to valid memory locations.
• Default Values: Null pointers act as default or initial values for pointers when no valid address is assigned to the pointers.
• Error Handling: They are useful in error conditions or to signify the absence of data that enables better handling of exceptional cases.
• Resource Release: To release the resources, like the destructor of a class, or to set pointers to NULL after deletion we can use a null pointer to avoid accidentally using or accessing the released memory.
• Sentinel Values : A null pointer can be used to indicate the end of a data structure or a list like in the linked list last node has a null pointer as the next field.

Example of NULL Pointer in C++

The below example demonstrates the dereferencing and assignment of a null pointer to another value.

Explanation : In the example given above first the pointer is pointing to a null value. First, we check whether the pointer is pointing to a null value or not before dereferencing it to avoid any kind of runtime error. Then we assign the pointer a valid memory address and then check it before dereferencing it. As the pointer is not pointing to a null value, the else part is executed.

Disadvantages of NULL Pointers in C++

NULL pointer makes it possible to check for pointer errors but it also has its limitations:

• Dereferencing a NULL pointer causes undefined behavior that may lead to runtime errors like segmentation faults.
• We need to check explicitly for NULL pointers before dereferencing it to avoid undefined behavior.

It is important to understand null pointers in C++ to handle pointers safely and prevent unexpected runtime errors. They signify the absence of valid memory addresses and help in error handling and pointer initialization. Proper usage and precautions regarding null pointers are essential in writing error-free C++ code.

Please Login to comment...

Similar reads.

• cpp-pointer
• Geeks Premier League 2023
• Geeks Premier League

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Apache Arrow nanoarrow 0.5.0 Release

Published 27 May 2024 By The Apache Arrow PMC (pmc)

The Apache Arrow team is pleased to announce the 0.5.0 release of Apache Arrow nanoarrow. This release covers 79 resolved issues from 9 contributors.

Release Highlights

The primary focus of the nanoarrow 0.5.0 release was expanding the initial Python bindings that were released in 0.4.0. The nanoarrow Python package can now create and consume most Arrow data types, arrays, and array streams, including conversion to/from objects compatible with the Python buffer protocol and conversion to/from lists of Python objects.

The nanoarrow 0.5.0 release also includes updates to its build configuration to make it possible to use nanoarrow with FetchContent in projects with a wider variety of CMake usage. In addition to CMake, nanoarrow now supports the Meson build system. Thanks to @vyasr and @WillAyd for contributing these changes!

In the R bindings , support for reading IPC streams is now accessible with read_nanoarrow() !

Finally, build system helpers and helpers to reconcile modern C++ usage with nanorrow C structures (e.g., iterating over an ArrowArrayStream or ArrowArray using a range-for loop) were added to nanoarrow.hpp . Thanks to @bkeitz for contributing these changes!

See the Changelog for a detailed list of contributions to this release.

Breaking Changes

Most changes included in the nanoarrow 0.5.0 release will not break downstream code; however, several changes in the C library are breaking changes to previous behaviour.

• ArrowBufferResize() and ArrowBitmapResize() now adjust size_bytes / size_bits in addition to capacity_bytes / buffer.capacity_bytes . Preivously these functions only adjusted the capacity of the underlying buffer which caused some understandable confusion even though this behaviour was documented. This change affects all usage of ArrowBufferReisze() and ArrowBitmapResize() that increased the size of the underlying buffer (i.e., usage where shrink_to_fit was non zero should be unaffected).
• ArrowBufferReset() now always calls the allocator’s free() callback. Previously, a call to the free() callback was skipped if the pointer was NULL ; however, this led to some confusion and made it easy to accidentally leak a custom deallocator whose pointer happened to be NULL .
• As a consequence of the above, it is now mandatory to call ArrowBufferInit() before calling ArrowBufferReset() . There was some existing usage of nanoarrow that zero-ed the memory for an ArrowBuffer and then (sometimes) called ArrowBufferReset() . Preivously this was a no-op; however, after 0.5.0 this will crash. This is consistent with other structures in the nanoarrow C library (which require an initialization before it is safe to reset/release them).

Python bindings

The nanoarrow Python bindings are distributed as the nanoarrow package on PyPI and conda-forge :

High level users can use the Schema , Array , and ArrayStream classes to interact with data types, arrays, and array streams:

Low-level users can use c_schema() , c_array() , and c_array_stream() to interact with thin wrappers around the Arrow C Data interface structures:

All nanoarrow type/array-like objects implement the Arrow PyCapsule interface for both producing and consuming and are zero-copy interchangeable with pyarrow objects in many cases:

For a more detailed tour of the nanoarrow Python bindings, see the Getting started in Python guide and the Python API reference .

The nanoarrow 0.5.0 release includes a number of bugfixes and improvements to the core C library and C++ helpers.

First, the CMake build system was refactored to enable FetchContent to work in a wider variety of develop/build/install scenarios . In most cases, CMake-based projects should be able to add the nanoarrow C library as a dependency with:

Projects using the Meson build system can install nanoarrow from WrapDB using:

…and use dependency('nanoarrow') to add the dependency:

Finally, a set of C++ range/view helpers were added to smooth out some of more verbose aspects of working with nanoarrow in C++. While the new helpers are targeted at more than just nanoarrow’s tests, they have been particularly helpful in allowing nanoarrow’s tests to be more less repetitive and more effective. For example, one particularly verbose test was collapsed to:

See the new section in the C++ API reference for details.

The nanoarrow R bindings are distributed as the nanoarrow package on CRAN .

Whereas nanoarrow has had an IPC reader supporting most features of the IPC streaming format since 0.3.0, the R bindings did not implement bindings until this release. The 0.5.0 release of the R package includes read_nanoarrow() as an entrypoint to reading streams from various sources including URLs, filenames, and R connections:

In developing the Python bindings, it became clear that a representation of a Arrow C++’s ChunkedArray was an important concept to represent. Whereas the Python bindings have the Array class to provide this structure, the R bindings had only the nanoarrow_array as a thin wrapper around the Arrow C Data interface. When developing the geospatial extension GeoArrow for R , a data structure that maintained chunked Arrow memory as an R vector was needed as an intermediary between an Arrow-native source and an R-native destination. This experimental structure can be created with as_nanoarrow_vctr() :

Contributors

This release consists of contributions from 9 contributors in addition to the invaluable advice and support of the Apache Arrow developer mailing list.