CsTutorialPoint - Computer Science Tutorials For Beginners

NULL Pointer In C [Explained With Examples] – CsTutorialpoint

Hello friends, in today’s article we are going to talk about NULL Pointer In C Language

Today we will learn in detail about, what is NULL Pointer In C and why and how they are used in C language.

So without wasting time let’s first understand what is NULL Pointer In C

NULL Pointer In C

What is NULL Pointer In C

In C language, when we do not have any address to assign to a pointer variable, then we assign that pointer variable with NULL. 

NULL is a keyword which means that now the pointer is not pointing to anything and when the pointer is not pointing to anything then such pointer is called NULL Pointer .

We can also say that “ a NULL pointer is a pointer that is not pointing to nothing .” NULL is a constant whose value is zero (0). We can create a NULL Pointer by assigning NULL or zero (0) to the pointer variable.

  • data_type -: any data type can come here like int, char, float, etc.
  • pointer_name -: Pointer name you can keep anything according to you.
  • NULL -: Here NULL is a keyword which we assign to pointer variable to make NULL Pointer.

Here ptr is a NULL pointer.

Let’s understand NULL Pointer better through a program.

Example Program of Null pointer

Check out this program, In this program, we have declared four pointer variables, out of which we have assigned the first pointer (ptr1) to the address of one variable and we have left the second pointer (ptr2) as declared without assigning anything.

We have assigned the third pointer (ptr3) with zero (0) and assigned the fourth pointer with NULL. And as we know, assigning any pointer to zero or NULL becomes a NULL pointer, so ptr3 and ptr4 is a NULL pointer and ptr1 and pt2 are not a NULL pointer.

Some important points of the NULL pointer

  • If we compare a null pointer to a pointer that is pointing to an object or function, then this comparison will be unequal.
  • In C language, we can compare two null pointers of any type because they are both equal.
  • In C language, NULL pointers cannot be dereferenced. If you try to do this then there will be a segmentation fault.
  • According to the C standard, 0 is a null pointer constant. example -: “int *ptr = 0;” Here “ptr” is a null pointer.
  • NULL vs Void Pointer -: NULL is a value in a null pointer and Void is a type in a void pointer.

Use of null pointer in C

  • When a pointer does not point to any valid address, then such pointer becomes a dangling pointer. By assigning NULL to such pointer, we can prevent it from becoming a dangling pointer.
  • The null pointer is used in error handling.

Friends, I hope you have found the answer to your question and you will not have to search about what is NULL Pointer In C and why and how they are used in C language.

However, if you want any information related to this post or related to programming language, or computer science, then comment below I will clear your all doubts 

If you want a complete tutorial on C language, then see here C Language Tutorial . Here you will get all the topics of C Programming Tutorial step by step.

Friends, if you liked this post, then definitely share this post with your friends so that they can get information about Null Pointer In C

To get the information related to Programming Language, Coding, C, C ++, subscribe to our website newsletter. So that you will get information about our upcoming new posts soon.

' src=

Jeetu Sahu is A Web Developer | Computer Engineer | Passionate about Coding, Competitive Programming, and Blogging

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Save my name, email, and website in this browser for the next time I comment.

Learn C++

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.

guest

Next: Invalid Dereference , Previous: Pointer Dereference , Up: Pointers   [ Contents ][ Index ]

14.6 Null Pointers

A pointer value can be null , which means it does not point to any object. The cleanest way to get a null pointer is by writing NULL , a standard macro defined in stddef.h . You can also do it by casting 0 to the desired pointer type, as in (char *) 0 . (The cast operator performs explicit type conversion; See Explicit Type Conversion .)

You can store a null pointer in any lvalue whose data type is a pointer type:

These two, if consecutive, can be combined into a declaration with initializer,

You can also explicitly cast NULL to the specific pointer type you want—it makes no difference.

To test whether a pointer is null, compare it with zero or NULL , as shown here:

Since testing a pointer for not being null is basic and frequent, all but beginners in C will understand the conditional without need for != NULL :

Dot Net Tutorials

Null Pointer in C

Back to: C Tutorials For Beginners and Professionals

Null Pointer in C Language with Examples

In this article, I will discuss Null Pointer in C Language with Examples. Please read our previous articles discussing Pointer to Constant in C Language with Examples.

What is a Null Pointer?

In C programming, a null pointer is a pointer that does not point to any valid memory location. It’s a special type of pointer used to indicate that it is not intended to point to an accessible memory location. Using a null pointer is essential for error handling and to avoid undefined behavior caused by uninitialized or dangling pointers. A null pointer is a special reserved value defined in a stddef header file. 

If we do not have any address which is to be assigned to the pointer, then it is known as a null pointer. When a NULL value is assigned to the pointer, it is considered a Null pointer. So, A null pointer is a pointer that points to nothing. Some uses of the null pointer are as follows:

  • Used to initialize a pointer variable when that pointer variable isn’t assigned any valid memory address yet.
  • Used to pass a null pointer to a function argument when we don’t want to pass any valid memory address.
  • Used to check for a 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.

Characteristics of a Null Pointer in C Language:

  • Initialization: A null pointer is typically initialized using the macro NULL, defined in several standard libraries, like <stddef.h>, <stdio.h>, <stdlib.h>, and others.
  • Comparison: A null pointer can be compared against other pointers. It is often used in conditions to check whether a pointer is valid.
  • Assignment: Any pointer can be assigned NULL.
  • Dereferencing: Dereferencing a null pointer leads to undefined behavior, often resulting in a runtime error or a program crash.

Null Pointer in C Language:

The pointer variable, initialized with the null value, is called the Null Pointer. Null Pointer doesn’t point to any memory location until we are not assigning the address. The size of the Null pointer is also 2 bytes, according to the DOS Compiler.

Null Pointer in C Language with Examples

Example Usage of Null Pointers

Here’s a simple example demonstrating the use of null pointers:

When to Use Null Pointers in C Language?

  • Initialization: Initialize pointers to NULL when they are declared but not yet assigned to a specific memory address. This prevents them from becoming dangling pointers.
  • After free: Set pointers to NULL after freeing dynamically allocated memory to prevent dangling pointers.
  • Error Handling: Return NULL from functions to indicate an error when the function is supposed to return a pointer.
  • End of Data Structures: In linked lists, trees, and similar data structures, null pointers often signify the end of the structure or an empty node.
  • Conditional Checks: Check whether a pointer is NULL before dereferencing it to ensure that it points to valid memory.

Example: Initializing and Checking a Null Pointer

In this example, ptr is initialized to NULL and then checked. The program will print “The pointer is null.”

Example: Using Null Pointers in Function Return

A common use case for null pointers is in functions that return pointers. A null pointer can signal an error or a special condition.

Here, allocateMemory returns NULL if memory allocation fails. The main function checks the returned pointer and prints a message accordingly.

Example: Null Pointers in Linked Lists

Null pointers are frequently used in data structures like linked lists to mark the end of the list.

In this example, head is a null pointer indicating that the linked list is initially empty.

Key Points:

  • A null pointer does not point to any valid memory location.
  • It’s a good practice to initialize pointers to NULL until they are assigned a valid address.
  • Always check if a pointer is null before dereferencing it to avoid runtime errors.
  • Null pointers are a key part of many data structures and algorithms in C.

Null Pointer use Cases in C Language:

When we do not assign any memory address to the pointer variable..

In the below example, we declare the pointer variable *ptr, but it does not contain the address of any variable. The dereferencing of the uninitialized pointer variable will show the compile-time error as it does not point to any variable. The following C program shows some unpredictable results and causes the program to crash. Therefore, we can say that keeping an uninitialized pointer in a program can cause the program to crash.

How do we avoid the above problem?

We can avoid the problem in C Programming Language by using a Null pointer. A null pointer points to the 0th memory location, a reserved memory that cannot be dereferenced. In the below example, we create a pointer *ptr and assign a NULL value to the pointer, which means that it does not point to any variable. After creating a pointer variable, we add the condition in which we check whether the value of a pointer is null or not.

When we use the malloc() function?

In the below example, we use the built-in malloc() function to allocate the memory. If the malloc() function is unable to allocate the memory, then it returns a NULL pointer. Therefore, it is necessary to add the condition to check whether the value of a pointer is null. If the value of a pointer is not null, it means that the memory is allocated.

Note: It is always a good programming practice to assign a Null value to the pointer when we do not know the exact address of memory.

Applications of Null Pointer

Following are the applications of a Null pointer:

  • It is used to initialize the pointer variable when the pointer does not point to a valid memory address.
  • It is used to perform error handling with pointers before dereferencing the pointers.
  • It is passed as a function argument and returned from a function when we do not want to pass the actual memory address.

In the next article, I will discuss Void Pointer in C Language with Examples. In this article, I try to explain Null Pointers in C Language with Examples . I hope you enjoy this Null Pointer in C Language with Examples article. I would like to have your feedback. Please post your feedback, questions, or comments about this article.

dotnettutorials 1280x720

About the Author: Pranaya Rout

Pranaya Rout has published more than 3,000 articles in his 11-year career. Pranaya Rout has very good experience with Microsoft Technologies, Including C#, VB, ASP.NET MVC, ASP.NET Web API, EF, EF Core, ADO.NET, LINQ, SQL Server, MYSQL, Oracle, ASP.NET Core, Cloud Computing, Microservices, Design Patterns and still learning new technologies.

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Trending Articles on Technical and Non Technical topics

  • 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

Samual Sam

Learning faster. Every day.

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

DEV Community

DEV Community

AbdulKarim

Posted on Oct 29, 2023

How C-Pointers Works: A Step-by-Step Beginner's Tutorial

In this comprehensive C Pointers tutorial, my primary goal is to guide you through the fundamentals of C pointers from the ground up. By the end of this tutorial, you will have gained an in-depth understanding of the following fundamental topics:

  • What is a Pointer?
  • How Data is Stored in Memory?
  • Storing Memory Addresses using Pointers

Accessing Data through Pointers

  • Pointer Arithmetic
  • Pointer to Pointer (Double Pointers)
  • Passing Pointers as Function Arguments

Arrays of Pointers

Null pointers, prerequisite:.

To grasp pointers effectively, you should be comfortable with basic C programming concepts, including variables, data types, functions, loops, and conditional statements. This familiarity with C programming forms the foundation for understanding how pointers work within the language. Once you have a solid grasp of these fundamental concepts, you can confidently delve into the intricacies of C pointers.

What is a pointer?

A pointer serves as a reference that holds the memory location of another variable. This memory address allows us to access the value stored at that location in the memory. You can think of a pointer as a way to reference or point to the location where data is stored in your computer's memory

Pointers can be a challenging concept for beginners to grasp, but in this tutorial, I'll explain them using real-life analogies to make the concept clearer. However, Before delving into pointers and their workings, it's important to understand the concept of a memory address.

A memory address is a unique identifier that points to a specific location in a computer's memory. Think of it like a street address for data stored in your computer's RAM (Random Access Memory). Just as a street address tells you where a particular house is located in the physical world, a memory address tells the computer where a specific piece of information or data is stored in its memory.

Take a look at the image below for a better understanding:

Block of memory

In this illustration, each block represents one byte of memory. It's important to note that every byte of memory has a unique address. To make it easier to understand, I've represented the addresses in decimal notation, but computers actually store these addresses using hexadecimal values. Hexadecimal is a base-16 numbering system commonly used in computing to represent memory addresses and other low-level data. It's essential to be aware of this representation when working with memory-related concepts in computer programming

How data is stored in the memory:

Every piece of data in your computer, whether it's a number, a character, or a program instruction, is stored at a specific memory address. The amount of space reserved for each data type can vary, and it is typically measured in bytes (where 1 byte equals 8 bits, with each bit representing either 0 or 1). The specific sizes of data types also depend on the computer architecture you are using. For instance, on most 64-bit Linux machines, you'll find the following typical sizes for common data types: char = 1 byte int = 4 bytes float = 4 bytes double = 8 bytes These sizes define how much memory each data type occupies and are crucial for memory management and efficient data representation in computer systems.

You can use the sizeof operator to determine the size of data types on your computer. example:

In this example: sizeof(char) returns the size of the char data type in bytes. sizeof(int) returns the size of the int data type in bytes. sizeof(float) returns the size of the float data type in bytes. sizeof(double) returns the size of the double data type in bytes. When you run this code, it will print the sizes of these data types on your specific computer, allowing you to see the actual sizes used by your system.

When you declare a variable, the computer allocates a specific amount of memory space corresponding to the chosen data type. For instance, when you declare a variable of type char, the computer reserves 1 byte of memory because the size of the 'char' data type is conventionally 1 byte.

address of char n

In this example, we declare a variable n of type char without assigning it a specific value. The memory address allocated for the n variable is 106 . This address, 106 , is where the computer will store the char variable n, but since we haven't assigned it a value yet, the content of this memory location may initially contain an unpredictable or uninitialized value.

When we assign the value 'C' to the variable n, the character 'C' is stored in the memory location associated with the variable n. When we assign the value 'C' to the variable n, the character 'C' is stored in the memory location associated with the variable n.

address of cahr n = c

As mentioned earlier, a byte can only store numerical values. When we store the letter 'C' in a byte, the byte actually holds the ASCII code for 'C,' which is 67. In computer memory, characters are represented using their corresponding ASCII codes. So, in memory, the character 'C' is stored as the numerical value 67. Here's how it looks in memory

Ascii code of c

Since integers are typically stored within four bytes of memory, let's consider the same example with an int variable. In this scenario, the memory structure would appear as follows:

add. of int t

In this example, the memory address where the variable t is stored is 121. An int variable like “t” typically uses four consecutive memory addresses, such as 121, 122, 123, and 124. The starting address, in this case, 121, represents the location of the first byte of the int, and the subsequent addresses sequentially represent the following bytes that collectively store the complete int value.

If you want to know the memory address of a variable in a program, you can use the 'address of' unary operator, often denoted as the '&' operator. This operator allows you to access the specific memory location where a variable is stored.

When you run the following program on your computer: It will provide you with specific memory addresses for the variables c and n. However, each time you rerun the program, it might allocate new memory addresses for these variables. It's important to understand that while you can determine the memory address of a variable using the & operator, the exact memory location where a variable is stored is typically managed by the system and the compiler. As a programmer, you cannot directly control or assign a specific memory location for a variable. Instead, memory allocation and management are tasks handled by the system and the compiler.

Storing memory address using pointers

As mentioned earlier, a pointer is a variable that stores the memory address of another variable. This memory address allows us to access the value stored at that location in memory. You can think of a pointer as a way to reference or point to the location where data is stored in your computer's memory.

Now, let's begin by declaring and initializing pointers. This step is essential because it sets up the pointer to hold a specific memory address, enabling us to interact with the data stored at that location.

Declaring Pointers: To declare a pointer, you specify the data type it points to, followed by an asterisk (*), and then the pointer's name. For example:

Here, we've declared a pointer named ptr that can point to integers.

Memory of Declaring an integer pointer

The size of pointers on 64-bit systems is usually 8 bytes (64 bits). To determine the pointer size on your system, you can use the sizeof operator:

Initializing Pointers: Once you've declared a pointer, you typically initialize it with the memory address it should point to. Once again, To obtain the memory address of a variable, you can employ the address-of operator (&). For instance:

In this program:

We declare an integer variable x and initialize it with the value 10. This line creates a variable x in memory and assigns the value 10 to it.

ptr

We declare an integer pointer ptr using the int *ptr syntax. This line tells the compiler that ptr will be used to store the memory address of an integer variable.

pointrt to ptr

We initialize the pointer ptr with the memory address of the variable x . This is achieved with the line ptr = &x; . The & operator retrieves the memory address of x, and this address is stored in the pointer ptr .

address of variable x

Dereferencing Pointers: To access the data that a pointer is pointing to, you need to dereference the pointer. Dereferencing a pointer means accessing the value stored at the memory address that the pointer points to. In C, you can think of pointers as variables that store memory addresses rather than actual values. To get the actual value (data) stored at that memory address, you need to dereference the pointer.

Dereferencing is done using the asterisk (*) operator. Here's an example:

It looks like this in the memory: int x = 10; variable 'x' stores the value 10:

var X

int *ptr = &x; Now, the pointer 'ptr' point to the address of 'x':

Pointer to X

int value = *ptr; Dereference 'ptr' to get the value stored at the address it points to:

pointer value is 10

Reading and Modifying Data: Pointers allow you to not only read but also modify data indirectly:

Note: The asterisk is a versatile symbol with different meanings depending on where it's used in your C program, for example: Declaration: When used during variable declaration, the asterisk (*) indicates that a variable is a pointer to a specific data type. For example: int *ptr; declares 'ptr' as a pointer to an integer.

Dereferencing: Inside your code, the asterisk (*) in front of a pointer variable is used to access the value stored at the memory address pointed to by the pointer. For example: int value = *ptr; retrieves the value at the address 'ptr' points to.

Pointer Arithmetic:

Pointer arithmetic is the practice of performing mathematical operations on pointers in C. This allows you to navigate through arrays, structures, and dynamically allocated memory. You can increment or decrement pointers, add or subtract integers from them, and compare them. It's a powerful tool for efficient data manipulation, but it should be used carefully to avoid memory-related issues.

Incrementing a Pointer:

Now, this program is how it looks in the memory: int arr[4] = {10, 20, 30, 40};

int arr

This behavior is a key aspect of pointer arithmetic. When you add an integer to a pointer, it moves to the memory location of the element at the specified index, allowing you to efficiently access and manipulate elements within the array. It's worth noting that you can use pointer arithmetic to access elements in any position within the array, making it a powerful technique for working with arrays of data. Now, let's print the memory addresses of the elements in the array from our previous program.

If you observe the last two digits of the first address is 40, and the second one is 44. You might be wondering why it's not 40 and 41. This is because we're working with an integer array, and in most systems, the size of an int data type is 4 bytes. Therefore, the addresses are incremented in steps of 4. The first address shows 40, the second 44, and the third one 48

Decrementing a Pointer Decrement (--) a pointer variable, which makes it point to the previous element in an array. For example, ptr-- moves it to the previous one. For example:

Explanation:

We have an integer array arr with 5 elements, and we initialize a pointer ptr to point to the fourth element (value 40) using &arr[3].

Then, we decrement the pointer ptr by one with the statement ptr--. This moves the pointer to the previous memory location, which now points to the third element (value 30).

Finally, we print the value pointed to by the decremented pointer using *ptr, which gives us the value 30.

In this program, we demonstrate how decrementing a pointer moves it to the previous memory location in the array, allowing you to access and manipulate the previous element.

Pointer to pointer

Pointers to pointers, or double pointers, are variables that store the address of another pointer. In essence, they add another level of indirection. These are commonly used when you need to modify the pointer itself or work with multi-dimensional arrays.

To declare and initialize a pointer to a pointer, you need to add an extra asterisk (*) compared to a regular pointer. Let's go through an example:

In this example, ptr2 is a pointer to a pointer. It points to the memory location where the address of x is stored (which is ptr1 ).

pointer to poiter

The below program will show you how to print the value of x through pointer to pointer

In this program, we first explain that it prints the value of x using a regular variable, a pointer, and a pointer to a pointer. We then print the memory addresses of x , ptr1 , and ptr2 .

Passing Pointers as Function Arguments:

In C, you can pass pointers as function arguments. This allows you to manipulate the original data directly, as opposed to working with a copy of the data, as you would with regular variables. Here's how it works:

How to Declare and Define Functions that Take Pointer Arguments: In your function declaration and definition, you specify that you're passing a pointer by using the * operator after the data type. For example:

In the above function, we declare ptr as a pointer to an integer. This means it can store the memory address of an integer variable.

Why Would You Pass Pointers to Functions?

Passing pointers to functions allows you to:

  • Modify the original data directly within the function.
  • Avoid making a copy of the data, which can be more memory-efficient.
  • Share data between different parts of your program efficiently.

This concept is especially important when working with large data structures or when you need to return multiple values from a function.

Call by Value vs. Call by Reference:

Understanding how data is passed to functions is crucial when working with pointers. there are two common ways that data can be passed to functions: call by value and call by reference.

Call by Value:

When you pass data by value, a copy of the original data is created inside the function. Any modifications to this copy do not affect the original data outside of the function. This is the default behavior for most data types when you don't use pointers.

Call by Reference (Using Pointers):

When you pass data by reference, you're actually passing a pointer to the original data's memory location. This means any changes made within the function will directly affect the original data outside the function. This is achieved by passing pointers as function arguments, making it call by reference. Using pointers as function arguments allows you to achieve call by reference behavior, which is particularly useful when you want to modify the original data inside a function and have those changes reflected outside the function.

Let's dive into some code examples to illustrate how pointers work as function arguments. We'll start with a simple example to demonstrate passing a pointer to a function and modifying the original data.

Consider this example:

In this code, we define a function modifyValue that takes a pointer to an integer. We pass the address of the variable num to this function, and it doubles the value stored in num directly.

This is a simple demonstration of passing a pointer to modify a variable's value. Pointers allow you to work with the original data efficiently.

An array of pointers is essentially an array where each element is a pointer. These pointers can point to different data types (int, char, etc.), providing flexibility and efficiency in managing memory.

How to Declare an Array of Pointers? To declare an array of pointers, you specify the type of data the pointers will point to, followed by square brackets to indicate it's an array, and then the variable name. For example:

Initializing an Array of Pointers You can initialize an array of pointers to each element to point to a specific value, For example:

How to Access Elements Through an Array of Pointers? To access elements through an array of pointers, you can use the pointer notation. For example:

This program demonstrates how to access and print the values pointed to by the pointers in the array.

A NULL pointer is a pointer that lacks a reference to a valid memory location. It's typically used to indicate that a pointer doesn't have a specific memory address assigned, often serving as a placeholder or default value for pointers.

Here's a code example that demonstrates the use of a NULL pointer:

In this example, we declare a pointer ptr and explicitly initialize it with the value NULL. We then use an if statement to check if the pointer is NULL. Since it is, the program will print "The pointer is NULL." This illustrates how NULL pointers are commonly used to check if a pointer has been initialized or assigned a valid memory address.

conclusion:

You've embarked on a comprehensive journey through the intricacies of C pointers. You've learned how pointers store memory addresses, enable data access, facilitate pointer arithmetic, and how they can be used with arrays and functions. Additionally, you've explored the significance of NULL pointers.

By completing this tutorial, you've equipped yourself with a robust understanding of pointers in C. You can now confidently navigate memory, manipulate data efficiently, and harness the power of pointers in your programming projects. These skills will be invaluable as you advance in your coding endeavors. Congratulations on your accomplishment, and keep coding with confidence!

Reference: C - Pointers - Tutorials Point

Pointers in C: A One-Stop Solution for Using C Pointers - simplilearn

Top comments (3)

pic

Templates let you quickly answer FAQs or store snippets for re-use.

imperiald profile image

  • Joined Jan 7, 2024

Love your way to write articles, could you add an article for, .o files, .h files, lists and makefile? Thank you in advance!

cocomelonjuice profile image

  • Joined Nov 4, 2023

Great post. Thank you so much for this.

koderkareem profile image

Thank you for your kind words! I'm thrilled to hear that you enjoyed the article. Your feedback means a lot to me. If you have any questions or if there's a specific topic you'd like to see in future posts, feel free to let me know. Thanks again for your support

Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink .

Hide child comments as well

For further actions, you may consider blocking this person and/or reporting abuse

nickytonline profile image

Form and Function: How I Lost My Submit Button & Got It Back

Nick Taylor - Apr 2

riddhesh profile image

CI/CD Pipeline for React Native

Riddhesh - Mar 15

evotik profile image

5 Open-Source Next.js Projects Rocking 2024 (Learn the Patterns!) 🚀

Evotik - Apr 5

theyasirr profile image

Maximizing Value: A Guide to Cost Optimization in Microsoft Azure

Yasir Rehman - Mar 27

DEV Community

We're a place where coders share, stay up-to-date and grow their careers.

explain null pointer assignment

Null Pointer Assignment Errors Explained

by Embarcadero USA Oct 19, 1993

Article originally contributed by Borland Staff

  • Language Feature
  • Code Snippet
  • Free Licenses

Learn What A Null Pointer Constant (nullptr) Is In Modern C++

explain null pointer assignment

C++ is an amazing programming language. Variables and memory usage are important in programming, and how we handle these are improved in every C++ standard. One of the great features is null pointer constants in modern C++ which was introduced with the C++11 standard. In this post, we explain what a null pointer constant (nullptr ) is with very simple examples. You can  learn C++  and follow along with our examples with any professional IDE and compiler that supports C++11, C++14, C++17 or above CLANG standards.

What is a pointer in modern C++?

Pointers  are variables that hold addresses. The asterisk character ‘ * ’ is used to define pointers. It is used before the variable name. Pointers are some of the strongest aspects of the C & C++ programming languages. They allow you to reach any kind of type (including very large-sized bitmaps or videos or other data) without copying the whole data which means they can be very fast to use. If you still don’t know how to use pointers, we explain them in the following article.

How To Use Pointers In C Programming and C++

What is a Null pointer constant (nullptr) in modern C++?

The value (contents) of a pointer type is normally an address value, a positive integer number that indicates where in the computer’s memory some data can be found. If there is no address to point to (no pointer value), you can set this value to NULL. In some cases, 0 is used. In C++, some examples show that these are not enough in some scenarios so there needs a new pointer constant that can be used for features of modern C++ like templates, or as a parameter of a function.

The  nullptr  keyword is a null pointer constant which is a prvalue of type  std::nullptr_t . that denotes the pointer literal. C++11 introduced nullptr , the null pointer constant, to remove the ambiguity between 0 and a null pointer. Although the old style NULL macro exists, it is insufficient because it cannot be distinguished from the integer 0 in a call to a function that has one overload with an int parameter and another with a char* parameter.

Therefore, nullptr is now a reserved word. The integer 0 will not be implicitly converted to any pointer type. The null pointer can only be converted to any pointer type. The null pointer cannot be used in an arithmetic expression, assigned to an integral value, or compared to an integral value. If you want to know more details about nullptr , it is explained well in the   Null pointer constant Proposal document .

Here is the syntax for nullptr .

here is an example how you can use this constant.

It can be used as a null pointer constant parameter of a function as below.

Is there an example of how to use the nullptr null pointer constant in modern C++?

Here is an example of nullptr , the null pointer constant in modern C++ that is used as a function parameter.

In the example above we may use NULL or 0 as a parameter too. The example below shows that you cannot use NULL or 0 in template usage – the nullptr is the only solution here.

Learn What A Null Pointer Constant nullptr Is In Modern C++ The C++ Builder Logo

C++ Builder  is the easiest and fastest C and C++ IDE for building simple or professional applications on the Windows, MacOS, iOS & Android operating systems. It is also easy for beginners to learn with its wide range of samples, tutorials, help files, and LSP support for code. RAD Studio’s C++ Builder version comes with the award-winning VCL framework for high-performance native Windows apps and the powerful FireMonkey (FMX) framework for cross-platform UIs.

explain null pointer assignment

Oh hi there 👋 It’s nice to meet you.

Sign up to receive awesome c++ content in your inbox, every day..

We don’t spam! Read our privacy policy for more info.

Check your inbox or spam folder to confirm your subscription.

explain null pointer assignment

About author

Yilmaz yoru, related posts, learn how to use clamp (std::clamp) in modern c++ 17 and beyond, what is the priority queue (std::priority_queue) in modern c++, what is the stack (std::stack) in modern c++, what is the queue (std::queue) in modern c++.

  • Reduce development time and get to market faster with RAD Studio, Delphi, or C++Builder. Design. Code. Compile. Deploy. Start Free Trial Free C++Builder Community Edition

RAD Studio Guide For Managers

Something Fresh

What people reading, ascii art: fun code spinning donut in 3d text form in c++, how to set up dev-c++ for your first project.

explain null pointer assignment

Top C++ Compilers for Windows in 2020

Unicode strings in c++ on windows, how to program arduino with c++, newest questions tagged c++builder – stack overflow.

  • Are there any compiler switches that affect how Variants are implemented? App A runs, but App B crashes
  • Using Indy HTTP under C++Builder to download file located behind a proxy
  • Keeping user customization in CoolBar/ToolBar at restart

Newest questions tagged c++ – Stack Overflow

  • How to support multiple SIMD architectures in one C++ application?
  • C++ passing by reference or by value confusion with inline creation of class
  • C++, CodeZinger; Convert String to Uppercase [closed]

explain null pointer assignment

LearnCPlusPlus.org is a C++ tutorial and learning platform for Windows developers using C++ to build Windows applications. It focuses on tools that allow rapid development and programming of both Win32 and Win64 applications. Additionally, it supports deploying apps to iOS.

© Copyright 2020 Embarcadero

  • Download C++Builder
  • Download Dev-C++
  • Learn Delphi
  • Embarcadero Blogs
  • DelphiFeeds

Basic Programs

  • Hello World
  • Taking Input from User
  • Find ASCII Value of Character
  • Using gets() function
  • Switch Case
  • Checking for Vowel
  • Reversing Case of Character
  • Swapping Two Numbers
  • Largest and Smallest using Global Declaration
  • Basic for Loop
  • Basic while Loop
  • Basic do-while Loop
  • Nested for Loops
  • Program to find Factorial of number
  • Fibonacci Series Program
  • Palindrome Program
  • Program to find Sum of Digits
  • Program to reverse a String
  • Program to find Average of n Numbers
  • Armstrong Number
  • Checking input number for Odd or Even
  • Print Factors of a Number
  • Find sum of n Numbers
  • Print first n Prime Numbers
  • Find Largest among n Numbers
  • Exponential without pow() method
  • Find whether number is int or float
  • Print Multiplication Table of input Number
  • Reverse an Array
  • Insert Element to Array
  • Delete Element from Array
  • Largest and Smallest Element in Array
  • Sum of N Numbers using Arrays
  • Sort Array Elements
  • Remove Duplicate Elements
  • Sparse Matrix
  • Square Matrix
  • Determinant of 2x2 matrix
  • Normal and Trace of Square Matrix
  • Addition and Subtraction of Matrices
  • Matrix Mulitplication
  • Simple Program
  • Memory Management
  • Array of Pointers
  • Pointer Increment and Decrement
  • Pointer Comparison
  • Pointer to a Pointer
  • Concatenate Strings using Pointer
  • Reverse a String using Pointer
  • Pointer to a Function
  • Null Pointer
  • isgraph() and isprint()
  • Removing Whitespaces
  • gets() and strlen()
  • strlen() and sizeof()
  • Frequency of characters in string
  • Count Number of Vowels
  • Adding Two Numbers
  • Fibonacci Series
  • Sum of First N Numbers
  • Sum of Digits
  • Largest Array Element
  • Prime or Composite
  • LCM of Two Numbers
  • GCD of Two Numbers
  • Reverse a String

Files and Streams

  • List Files in Directory
  • Size of File
  • Write in File
  • Reverse Content of File
  • Copy File to Another File

Important Concepts

  • Largest of three numbers
  • Second largest among three numbers
  • Adding two numbers using pointers
  • Sum of first and last digit
  • Area and Circumference of Circle
  • Area of Triangle
  • Basic Arithmetic Operations
  • Conversion between Number System
  • Celsius to Fahrenheit
  • Simple Interest
  • Greatest Common Divisor(GCD)
  • Roots of Quadratic Roots
  • Identifying a Perfect Square
  • Calculate nPr and nCr

Miscellaneous

  • Windows Shutdown
  • Without Main Function
  • Menu Driven Program
  • Changing Text Background Color
  • Current Date and Time

Using Null Pointer Program

NULL is a macro in C, defined in the <stdio.h> header file, and it represent a null pointer constant. Conceptually, when a pointer has that Null value it is not pointing anywhere.

If you declare a pointer in C, and don't assign it a value, it will be assigned a garbage value by the C compiler, and that can lead to errors.

Void pointer is a specific pointer type. void * which is a pointer that points to some data location in storage, which doesn't have any specific type.

Don't confuse the void * pointer with a NULL pointer.

NULL pointer is a value whereas, Void pointer is a type.

Below is a program to define a NULL pointer.

Program Output:

C program example for Null Pointer

Use Null Pointer to mark end of Pointer Array in C

Now let's see a program in which we will use the NULL pointer in a practical usecase.

We will create an array with string values ( char * ), and we will keep the last value of the array as NULL. We will also define a search() function to search for name in the array.

Inside the search() function, while searching for a value in the array, we will use NULL pointer to identify the end of the array.

So let's see the code,

Peter is in the list. Scarlett not found.

This is a simple program to give you an idea of how you can use the NULL pointer. But there is so much more that you can do. You can ask the user to input the names for the array. And then the user can also search for names. So you just have to customize the program a little to make it support user input.

  • ← Prev
  • Next →

  C Tutorial

  c mcq tests.

  • C Data Types
  • C Operators
  • C Input and Output
  • C Control Flow
  • C Functions
  • C Preprocessors
  • C File Handling
  • C Cheatsheet
  • C Interview Questions
  • Pointer Arithmetics in C with Examples
  • Applications of Pointers in C
  • Passing Pointers to Functions in C
  • C - Pointer to Pointer (Double Pointer)
  • Chain of Pointers in C with Examples
  • Function Pointer in C
  • How to declare a pointer to a function?
  • Pointer to an Array | Array Pointer
  • Difference between constant pointer, pointers to constant, and constant pointers to constants
  • Pointer vs Array in C
  • NULL Pointer in C
  • Dangling, Void , Null and Wild Pointers in C
  • Near, Far and Huge Pointers in C
  • restrict keyword in C

Pointers are one of the core components of the C programming language. A pointer can be used to store the memory address of other variables, functions, or even other pointers. The use of pointers allows low-level memory access, dynamic memory allocation, and many other functionality in C.

In this article, we will discuss C pointers in detail, their types, uses, advantages, and disadvantages with examples.

What is a Pointer in C?

A pointer is defined as a derived data type that can store the address of other C variables or a memory location. We can access and manipulate the data stored in that memory location using pointers.

As the pointers in C store the memory addresses, their size is independent of the type of data they are pointing to. This size of pointers in C only depends on the system architecture.

Syntax of C Pointers

The syntax of pointers is similar to the variable declaration in C, but we use the ( * ) dereferencing operator in the pointer declaration.

  • ptr is the name of the pointer.
  • datatype is the type of data it is pointing to.

The above syntax is used to define a pointer to a variable. We can also define pointers to functions, structures, etc.

How to Use Pointers?

The use of pointers in C can be divided into three steps:

  • Pointer Declaration
  • Pointer Initialization
  • Pointer Dereferencing

1. Pointer Declaration

In pointer declaration, we only declare the pointer but do not initialize it. To declare a pointer, we use the ( * ) dereference operator before its name.

The pointer declared here will point to some random memory address as it is not initialized. Such pointers are called wild pointers.

2. Pointer Initialization

Pointer initialization is the process where we assign some initial value to the pointer variable. We generally use the ( & ) addressof operator to get the memory address of a variable and then store it in the pointer variable.

We can also declare and initialize the pointer in a single step. This method is called pointer definition as the pointer is declared and initialized at the same time.

Note: It is recommended that the pointers should always be initialized to some value before starting using it. Otherwise, it may lead to number of errors.

3. Pointer Dereferencing

Dereferencing a pointer is the process of accessing the value stored in the memory address specified in the pointer. We use the same ( * ) dereferencing operator that we used in the pointer declaration.

dereferencing a pointer in c

Dereferencing a Pointer in C

C Pointer Example

Types of pointers in c.

Pointers in C can be classified into many different types based on the parameter on which we are defining their types. If we consider the type of variable stored in the memory location pointed by the pointer, then the pointers can be classified into the following types:

1. Integer Pointers

As the name suggests, these are the pointers that point to the integer values.

These pointers are pronounced as Pointer to Integer.

Similarly, a pointer can point to any primitive data type. It can point also point to derived data types such as arrays and user-defined data types such as structures.

2. Array Pointer

Pointers and Array are closely related to each other. Even the array name is the pointer to its first element. They are also known as Pointer to Arrays . We can create a pointer to an array using the given syntax.

Pointer to Arrays exhibits some interesting properties which we discussed later in this article.

3. Structure Pointer

The pointer pointing to the structure type is called Structure Pointer or Pointer to Structure. It can be declared in the same way as we declare the other primitive data types.

In C, structure pointers are used in data structures such as linked lists, trees, etc.

4. Function Pointers

Function pointers point to the functions. They are different from the rest of the pointers in the sense that instead of pointing to the data, they point to the code. Let’s consider a function prototype – int func (int, char) , the function pointer for this function will be

Note: The syntax of the function pointers changes according to the function prototype.

5. Double Pointers

In C language, we can define a pointer that stores the memory address of another pointer. Such pointers are called double-pointers or pointers-to-pointer . Instead of pointing to a data value, they point to another pointer.

Dereferencing Double Pointer

Note: In C, we can create multi-level pointers with any number of levels such as – ***ptr3, ****ptr4, ******ptr5 and so on.

6. NULL Pointer

The Null Pointers are those pointers that do not point to any memory location. They can be created by assigning a NULL value to the pointer. A pointer of any type can be assigned the NULL value.

It is said to be good practice to assign NULL to the pointers currently not in use.

7. Void Pointer

The Void pointers in C are the pointers of type void. It means that they do not have any associated data type. They are also called generic pointers as they can point to any type and can be typecasted to any type.

One of the main properties of void pointers is that they cannot be dereferenced.

8. Wild Pointers

The Wild Pointers are pointers that have not been initialized with something yet. These types of C-pointers can cause problems in our programs and can eventually cause them to crash. If values is updated using wild pointers, they could cause data abort or data corruption.

9. Constant Pointers

In constant pointers, the memory address stored inside the pointer is constant and cannot be modified once it is defined. It will always point to the same memory address.

10. Pointer to Constant

The pointers pointing to a constant value that cannot be modified are called pointers to a constant. Here we can only access the data pointed by the pointer, but cannot modify it. Although, we can change the address stored in the pointer to constant.

Other Types of Pointers in C:

There are also the following types of pointers available to use in C apart from those specified above:

  • Far pointer : A far pointer is typically 32-bit that can access memory outside the current segment.
  • Dangling pointer : A pointer pointing to a memory location that has been deleted (or freed) is called a dangling pointer.
  • Huge pointer : A huge pointer is 32-bit long containing segment address and offset address.
  • Complex pointer: Pointers with multiple levels of indirection.
  • Near pointer : Near pointer is used to store 16-bit addresses means within the current segment on a 16-bit machine.
  • Normalized pointer: It is a 32-bit pointer, which has as much of its value in the segment register as possible.
  • File Pointer: The pointer to a FILE data type is called a stream pointer or a file pointer.

Size of Pointers in C

The size of the pointers in C is equal for every pointer type. The size of the pointer does not depend on the type it is pointing to. It only depends on the operating system and CPU architecture. The size of pointers in C is 

  • 8 bytes for a 64-bit System
  • 4 bytes for a 32-bit System

The reason for the same size is that the pointers store the memory addresses, no matter what type they are. As the space required to store the addresses of the different memory locations is the same, the memory required by one pointer type will be equal to the memory required by other pointer types.

How to find the size of pointers in C?

We can find the size of pointers using the sizeof operator as shown in the following program:

Example: C Program to find the size of different pointer types.

As we can see, no matter what the type of pointer it is, the size of each and every pointer is the same.

Now, one may wonder that if the size of all the pointers is the same, then why do we need to declare the pointer type in the declaration? The type declaration is needed in the pointer for dereferencing and pointer arithmetic purposes.

C Pointer Arithmetic

The Pointer Arithmetic refers to the legal or valid arithmetic operations that can be performed on a pointer. It is slightly different from the ones that we generally use for mathematical calculations as only a limited set of operations can be performed on pointers. These operations include:

  • Increment in a Pointer
  • Decrement in a Pointer
  • Addition of integer to a pointer
  • Subtraction of integer to a pointer
  • Subtracting two pointers of the same type
  • Comparison of pointers of the same type.
  • Assignment of pointers of the same type.

C Pointers and Arrays

In C programming language, pointers and arrays are closely related. An array name acts like a pointer constant. The value of this pointer constant is the address of the first element. For example, if we have an array named val then val and &val[0] can be used interchangeably.

If we assign this value to a non-constant pointer of the same type, then we can access the elements of the array using this pointer.

Example 1: Accessing Array Elements using Pointer with Array Subscript

relationship between array and pointer

Not only that, as the array elements are stored continuously, we can pointer arithmetic operations such as increment, decrement, addition, and subtraction of integers on pointer to move between array elements.

Example 2: Accessing Array Elements using Pointer Arithmetic

accessing array elements using pointer arithmetic

This concept is not limited to the one-dimensional array, we can refer to a multidimensional array element as well using pointers.

To know more about pointers to an array, refer to this article – Pointer to an Array

Uses of Pointers in C

The C pointer is a very powerful tool that is widely used in C programming to perform various useful operations. It is used to achieve the following functionalities in C:

  • Pass Arguments by Reference
  • Accessing Array Elements
  • Return Multiple Values from Function
  • Dynamic Memory Allocation
  • Implementing Data Structures
  • In System-Level Programming where memory addresses are useful.
  • In locating the exact value at some memory location.
  • To avoid compiler confusion for the same variable name.
  • To use in Control Tables.

Advantages of Pointers

Following are the major advantages of pointers in C:

  • Pointers are used for dynamic memory allocation and deallocation.
  • An Array or a structure can be accessed efficiently with pointers
  • Pointers are useful for accessing memory locations.
  • Pointers are used to form complex data structures such as linked lists, graphs, trees, etc.
  • Pointers reduce the length of the program and its execution time as well.

Disadvantages of Pointers

Pointers are vulnerable to errors and have following disadvantages:

  • Memory corruption can occur if an incorrect value is provided to pointers.
  • Pointers are a little bit complex to understand.
  • Pointers are majorly responsible for memory leaks in C .
  • Pointers are comparatively slower than variables in C.
  • Uninitialized pointers might cause a segmentation fault.

In conclusion, pointers in C are very capable tools and provide C language with its distinguishing features, such as low-level memory access, referencing, etc. But as powerful as they are, they should be used with responsibility as they are one of the most vulnerable parts of the language.

FAQs on Pointers in C

Q1. define pointers..

Pointers are the variables that can store the memory address of another variable.

Q2. What is the difference between a constant pointer and a pointer to a constant?

A constant pointer points to the fixed memory location, i.e. we cannot change the memory address stored inside the constant pointer. On the other hand, the pointer to a constant point to the memory with a constant value.

Q3. What is pointer to pointer?

A pointer to a pointer (also known as a double pointer) stores the address of another pointer.

Q4. Does pointer size depends on its type?

No, the pointer size does not depend upon its type. It only depends on the operating system and CPU architecture.

Q5. What are the differences between an array and a pointer?

The following table list the differences between an array and a pointer : Pointer Array A pointer is a derived data type that can store the address of other variables. An array is a homogeneous collection of items of any type such as int, char, etc. Pointers are allocated at run time. Arrays are allocated at runtime. The pointer is a single variable. An array is a collection of variables of the same type. Dynamic in Nature Static in Nature.

Q6. Why do we need to specify the type in the pointer declaration?

Type specification in pointer declaration helps the compiler in dereferencing and pointer arithmetic operations.
  • Quiz on Pointer Basics
  • Quiz on Advanced Pointer

Please Login to comment...

Similar reads.

  • CBSE Exam Format Changed for Class 11-12: Focus On Concept Application Questions
  • 10 Best Waze Alternatives in 2024 (Free)
  • 10 Best Squarespace Alternatives in 2024 (Free)
  • Top 10 Owler Alternatives & Competitors in 2024
  • 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

 alt=

What kind of Experience do you want to share?

Javatpoint Logo

  • 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.

JavaTpoint

  • Send your Feedback to [email protected]

Help Others, Please Share

facebook

Learn Latest Tutorials

Splunk tutorial

Transact-SQL

Tumblr tutorial

Reinforcement Learning

R Programming tutorial

R Programming

RxJS tutorial

React Native

Python Design Patterns

Python Design Patterns

Python Pillow tutorial

Python Pillow

Python Turtle tutorial

Python Turtle

Keras tutorial

Preparation

Aptitude

Verbal Ability

Interview Questions

Interview Questions

Company Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Artificial Intelligence

AWS Tutorial

Cloud Computing

Hadoop tutorial

Data Science

Angular 7 Tutorial

Machine Learning

DevOps Tutorial

B.Tech / MCA

DBMS tutorial

Data Structures

DAA tutorial

Operating System

Computer Network tutorial

Computer Network

Compiler Design tutorial

Compiler Design

Computer Organization and Architecture

Computer Organization

Discrete Mathematics Tutorial

Discrete Mathematics

Ethical Hacking

Ethical Hacking

Computer Graphics Tutorial

Computer Graphics

Software Engineering

Software Engineering

html tutorial

Web Technology

Cyber Security tutorial

Cyber Security

Automata Tutorial

C Programming

C++ tutorial

Control System

Data Mining Tutorial

Data Mining

Data Warehouse Tutorial

Data Warehouse

RSS Feed

COMMENTS

  1. c

    A null pointer assignment error, or many other errors, can be assigned to this issue and example. In simpler architecture or programming environments, It can refer to any code which unintentionally ends up creating nulls as pointers, or creates a bug that in anyway halts the execution, like overwriting a byte in the return stack, overwriting ...

  2. NULL Pointer in C

    Syntax of Null Pointer Declaration in C type pointer_name = NULL; type pointer_name = 0;. We just have to assign the NULL value. Strictly speaking, NULL expands to an implementation-defined null pointer constant which is defined in many header files such as "stdio.h", "stddef.h", "stdlib.h" etc. Uses of NULL Pointer in C

  3. NULL Pointer In C [Explained With Examples]

    NULL is a constant whose value is zero (0). We can create a NULL Pointer by assigning NULL or zero (0) to the pointer variable. Syntax -: pointer_name -: Pointer name you can keep anything according to you. NULL -: Here NULL is a keyword which we assign to pointer variable to make NULL Pointer. Example -:

  4. 12.8

    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:

  5. c

    C implementations can define NULL either as ((void*)0) the outer parentheses are necessary) or as 0, or in any of several other forms. C++, which is a different language, has different requirements for null pointer constants, and C++ implementations commonly define NULL as 0. The point of having NULL define by the implementation is that you don ...

  6. NULL Pointer in C++

    We can create a NULL pointer of any type by simply assigning the value NULL to the pointer as shown: int* ptrName = NULL; // before C++11. int* ptrName = nullptr. int* ptrName = 0; // by assigning the value 0. 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 ...

  7. Null Pointers (GNU C Language Manual)

    14.6 Null Pointers. A pointer value can be null, which means it does not point to any object. The cleanest way to get a null pointer is by writing NULL, a standard macro defined in stddef.h. You can also do it by casting 0 to the desired pointer type, as in (char *) 0. (The cast operator performs explicit type conversion; See Explicit Type ...

  8. Null Pointer in C Language with Examples

    A null pointer points to the 0th memory location, a reserved memory that cannot be dereferenced. In the below example, we create a pointer *ptr and assign a NULL value to the pointer, which means that it does not point to any variable. After creating a pointer variable, we add the condition in which we check whether the value of a pointer is ...

  9. Null Pointer Assignment Errors Explained

    Although it would be possible that a wild pointer would overwrite the key values, it would not indicate a null pointer. In the tiny memory model, DS = CS = SS. Therefore, using a null pointer will overwrite the beginning of the code segment. 5. Can anything else generate a Null Pointer Assignment error?

  10. Dangling, Void , Null and Wild Pointers in C

    A null pointer stores a defined value, but one that is defined by the environment to not be a valid address for any member or object. NULL vs Void Pointer - Null pointer is a value, while void pointer is a type. Wild pointer in C. A pointer that has not been initialized to anything (not even NULL) is known as a wild pointer. The pointer may ...

  11. NULL pointer in C

    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.

  12. How C-Pointers Works: A Step-by-Step Beginner's Tutorial

    NULL Pointers. A NULL pointer is a pointer that lacks a reference to a valid memory location. It's typically used to indicate that a pointer doesn't have a specific memory address assigned, often serving as a placeholder or default value for pointers. Here's a code example that demonstrates the use of a NULL pointer:

  13. NULL Pointer in C Programming with Examples

    In exp. "char *cp = 0". cp is a NULL pointer! . In exp. "float *fp = 0". fp is a NULL pointer! We observed in above program, we saw how assigning ZERO '0' to pointer to any type, made it a NULL Pointer. This is a source code convention. Internally, however, the value for NULL pointer actually be something different and compiler takes care ...

  14. Null Pointer Assignment Errors Explained

    Although it would be possible that a wild pointer would overwrite the key values, it would not indicate a null pointer. In the tiny memory model, DS = CS = SS. Therefore, using a null pointer will overwrite the beginning of the code segment. 5. Can anything else generate a Null Pointer Assignment error?

  15. Learn What A Null Pointer Constant (nullptr) Is In Modern C++

    The nullptr keyword is a null pointer constant which is a prvalue of type std::nullptr_t. that denotes the pointer literal. C++11 introduced nullptr, the null pointer constant, to remove the ambiguity between 0 and a null pointer. Although the old style NULL macro exists, it is insufficient because it cannot be distinguished from the integer 0 ...

  16. NULL Pointer in C with example

    C language Pointer Tutorial...! 👇👇👇https://www.youtube.com/playlist?list=PLqleLpAMfxGC_39XKLj10U_k_n2_V2VEmPlease Subscribe our Channel...!Learn Coding 🙏...

  17. Using Null Pointer in Programs in C

    Using Null Pointer Program. NULL is a macro in C, defined in the <stdio.h> header file, and it represent a null pointer constant. Conceptually, when a pointer has that Null value it is not pointing anywhere. If you declare a pointer in C, and don't assign it a value, it will be assigned a garbage value by the C compiler, and that can lead to ...

  18. C Pointers

    A pointer of any type can be assigned the NULL value. Syntax. data_type * pointer_name = NULL; or pointer_name = NULL. It is said to be good practice to assign NULL to the pointers currently not in use. 7. Void Pointer. The Void pointers in C are the pointers of type void. It means that they do not have any associated data type. They are also ...

  19. Null Pointer in C

    What is a Null Pointer? A Null Pointer is a pointer that does not point to any memory location. It stores the base address of the segment. The null pointer basically stores the Null value while void is the type of the pointer. A null pointer is a special reserved value which is defined in a stddef header file.

  20. Assignment-operator and null pointer in C++

    a is type of XY and s is a pointer of this class that points to null. How can I program the assignment-operator so that if s is a null pointer, that a.p=0? c++; Share. Improve this question. ... the null pointer check is unnecessary. References cannot be null in C++, only pointers can be.

  21. C++ pointer assignment

    Now we have two variables x and y: int *p = &x; int *q = &y; There are declared another two variables, pointer p which points to variable x and contains its address and pointer q which points to variable y and contains its address: x = 35; y = 46; Here you assign values to the variables, this is clear: p = q;