Pointers in C

Dive into the world of Pointers in C, a crucial concept in computer programming that can often feel challenging to understand. In this comprehensive guide, you will be introduced to the basics of Pointers in C, their importance, different types, and syntax. Delve deeper into the inner workings of Pointers with functions, exploring how to use them effectively and the benefits of incorporating them within your programming journey. Additionally, unpack the concept of array of pointers, their creation, initialization, and how to use them for dynamic memory allocation. Grasp the fundamental idea of dereference pointers and the intriguing pointer-to-pointer concept. Lastly, discover the essentials of pointer arithmetic, including comparisons and the art of array manipulation. By the end of this guide, you will have a solid understanding of Pointers in C, enhancing your programming skills and ultimately improving your problem-solving capabilities.

Get started Sign up for free
Pointers in C Pointers in C

Create learning materials about Pointers in C with our free learning app!

  • Instand access to millions of learning materials
  • Flashcards, notes, mock-exams and more
  • Everything you need to ace your exams
Create a free account

Millions of flashcards designed to help you ace your studies

Sign up for free

Convert documents into flashcards for free with AI!

Table of contents

    Pointers in C Explained

    Pointers in C are a fundamental concept in computer programming that allows you to manage memory efficiently and perform operations on variables and data. Essentially, a pointer is a variable that stores the memory address of another variable or function. A pointer gives you direct access to the memory address, which can be incredibly useful for manipulating data and working with complex data structures like arrays, structures, and linked lists.

    A pointer is a variable that stores the memory address of another variable or function.

    Importance of Pointers in C Programming

    Pointers play a vital role in many aspects of C programming. They provide several advantages, such as:

    • Efficient memory management.
    • Dynamic memory allocation.
    • Passing pointers to functions for efficient and flexible data manipulation.
    • Working with complex data structures like arrays, structures, and linked lists.
    • Reducing the amount of redundant code by providing indirect access to data.

    Understanding pointers is crucial for mastering C programming, as they enable you to perform advanced operations and achieve more flexibility and power with your code.

    Syntax and Declaration of Pointers in C

    To work with pointers, you'll first need to know how to declare them in your C code. The declaration of a pointer looks like this:

      data_type *pointer_name;

    Where data_type is the type of data the pointer will point to, such as int, float, orchar, and pointer_name is the name of the pointer variable.

    Here is an example of declaring an integer pointer:

      int *intPointer;

    To assign a memory address to a pointer, you'll use the address-of operator (&), like so:

      int x = 10;
      int *intPointer;
      intPointer = x

    In this example, intPointer points to the memory address where the integer variable x is stored.

    Different Types of Pointers in C

    There are several different types of pointers in C, depending on the data type and the use case. Here are some common pointer types:

    Pointer TypeDescription
    Null pointerA special type of pointer that points to nothing or has a value of NULL. It's used to indicate that the pointer is not pointing to any valid memory location.
    Void pointerA generic type of pointer that can point to any data type. It provides more flexibility, but it must be explicitly type-casted before using it with other data types.
    Array pointerA pointer that points to the first element of an array. You can manipulate array elements using pointer arithmetic, enabling more efficient code.
    Function pointerA pointer that points to a function. It's used to store the memory address of a function, allowing for more dynamic and flexible execution of functions.
    Structure pointerA pointer that points to a structure. It helps to access the structure's members, allowing for efficient manipulation of complex data structures.

    Understanding the different types of pointers in C is essential for using them effectively and writing efficient, flexible, and dynamic code.

    Working with Pointers and Functions in C

    Pointers can be used to increase the efficiency and flexibility of functions in C programming. There are two main ways to use pointers with functions:

    1. Passing pointers as function arguments
    2. Returning pointers from functions

    Using pointers in conjunction with functions can lead to more effective memory management, reduced redundant code, and improved performance.

    Function Pointers in C

    Function pointers are special types of pointers that store the address of a function. Function pointers in C can be used for the following purposes:

    • Calling functions dynamically by their memory addresses
    • Implementing callbacks
    • Storing functions in data structures, such as arrays or structures

    To declare a function pointer, you need to specify the function's return type and the pointer's name, followed by the argument types in parentheses:

      returnType (*pointerName)(argumentType1, argumentType2, ...);

    For example, let's create a function pointer for a function that takes two integer arguments and returns an integer:

      int (*functionPointer)(int, int);

    To assign the address of a function to the function pointer, use the following syntax:

      functionPointer = &functionName

    Once the function pointer is assigned, you can use it to call the function by its memory address:

      int result = functionPointer(arg1, arg2);

    Function pointers provide flexibility in C programming, allowing you to write more versatile and dynamic code.

    Passing Pointers as Function Arguments in C

    Pointers can be passed as function arguments, which enables you to directly manipulate the data stored in memory. This is particularly powerful when working with large data structures, as passing pointers reduces the overhead of copying large amounts of data when using functions. It allows you to:

    • Alter the original data directly
    • Share complex data structures among multiple functions
    • Reduce the amount of required data copying

    To pass a pointer as a function argument, you need to declare the function with a pointer parameter:

      returnType functionName(dataType *pointerParameter);

    For example, here's how you would implement a function to swap the values of two integer variables using pointers:

      void swap(int *a, int *b) {
        int temp;
        temp = *a;
        *a = *b;
        *b = temp;

    When calling the function, you need to pass the address of the variables:

      int x = 10, y = 20;
      swap(&x, &y);

    After calling the swap function, the values of x and y will be swapped.

    Returning Pointers from Functions in C

    Functions in C can also return pointers, which can be useful for returning memory addresses of dynamically allocated data. Returning pointers from a function allows you to:

    • Create and return data structures dynamically
    • Share dynamically allocated memory across multiple functions
    • Return large data structures without copying entire contents
    • Return specific memory locations for efficient data manipulation

    To return a pointer from a function in C, you need to declare the function with a pointer return type:

      dataType *functionName(arguments);

    For example, here's a function that takes two integers and returns a pointer to the maximum value:

      int *max(int *a, int *b) {
        return (*a > *b) ? a : b;

    When calling this function, you need to pass the pointers to the variables:

      int x = 5, y = 10;
      int *maxValue = max(&x, &y);

    After calling the max function, the pointer maxValue will point to the maximum value, either x or y.

    Keep in mind that you should not return pointers to local variables, as their memory addresses can become invalid after the function terminates. To avoid this issue, you can return pointers to global variables, static local variables, or dynamically allocated memory.

    Array of Pointers in C

    An array of pointers is an advanced C programming concept that stores a collection of pointers, with each pointer pointing to a specific memory location, such as a variable or an element of another array. Creating and initializing an array of pointers offers various benefits, such as more efficient memory utilization and the ability to access elements of different-sized arrays without explicit knowledge of their dimensions.

    To create an array of pointers, you first need to declare the array with the appropriate data type as follows:

      data_type *array_of_pointers[array_size];

    Where data_type is the type of the data, such as int, float or char, and array_size represents the size of the array.

    For example, suppose you want to create an array of 5 integer pointers:

      int *array_of_intPointers[5];

    Once the array of pointers is declared, you can initialize it by assigning memory addresses to each of its elements. You can do this using a loop or by assigning each pointer individually:

      int arr1[] = {1, 2, 3};
      int arr2[] = {4, 5, 6, 7};
      int arr3[] = {8, 9, 10, 11, 12};
      int *array_of_intPointers[] = {arr1, arr2, arr3};

    In this example, the elements of the array_of_intPointers array point to the arrays arr1, arr2, and arr3.

    Advantages of Using Array of Pointers

    There are several benefits to using arrays of pointers in C programming, including:

    • Efficient memory management: Arrays of pointers allow you to store a collection of pointers, instead of copying the entire data set. This results in more efficient use of memory.
    • Dynamic array size: Array of pointers allows you to work with different-sized arrays without needing to know their dimensions.
    • Accessing array elements indirectly: By using arrays of pointers, you can access elements in another array, alter the order of elements, or remove an element without changing the original structure.
    • Easier manipulation of multidimensional arrays: Using arrays of pointers can simplify the manipulation of multidimensional arrays by only changing the pointer values, instead of moving the entire data set.
    • More flexibility: Arrays of pointers can point to different data types, structures, or even functions, enabling more versatile and dynamic programming.

    Accessing Elements of an Array Using Pointers in C

    By using pointers, you can efficiently access and manipulate elements within an array. To access the elements of an array using pointers, you need to perform pointer arithmetic or use the array notation with pointers. Here's how you can access elements of an array using pointers:

      int arr[] = {1, 2, 3, 4, 5};
      int *arr_ptr;
      int i;
      arr_ptr = arr; // Assign the address of the first element of the array to the pointer
      for (i = 0; i < 5; i++) {
        printf("Element %d = %d\n", i, *(arr_ptr + i));

    In the example above, the pointer arr_ptr is initially assigned the address of the first element in the arr array. Then, by using pointer arithmetic, you can access each element of the array via the pointer.

    Dynamic Memory Allocation for Arrays in C

    Dynamic memory allocation allows you to create arrays at runtime and resize them as needed. In C, you can use the memory allocation functions malloc, calloc, and realloc to dynamically allocate memory for arrays, and free to deallocate the memory. Here's a summary of these functions:

    mallocAllocates memory of the specified size in bytes and returns a pointer to the first byte of the memory block.
    callocAllocates memory for an array of the specified number of elements with the specified size and initializes all elements to zero.
    reallocResizes the memory block pointed to by a given pointer, preserving the existing data.
    freeDeallocates the memory block pointed to by a given pointer.

    To create an array using dynamic memory allocation, follow these steps:

    1. Declare a pointer to the desired data type.
    2. Use one of the memory allocation functions to allocate memory for the array.
    3. Verify that the allocated memory is not NULL.
    4. Access and manipulate the array elements using the pointer and pointer arithmetic.
    5. Release the allocated memory using the free function when it is no longer needed.

    Here's an example of allocating an integer array of size 10:

      int *arr;
      int array_size = 10;
      arr = (int *)malloc(array_size * sizeof(int));
      if (arr != NULL) {
        // Access and manipulate the array elements here
      } else {
        printf("Memory allocation failed");
      // Deallocate memory when no longer needed

    Using dynamic memory allocation for arrays in C helps you create more flexible and efficient programs by allocating memory at runtime as needed. It also allows you to resize arrays, increasing the program's adaptability, and reducing the memory footprint.

    Dereference Pointer in C

    Dereferencing a pointer in C refers to the process of obtaining the value stored at the memory address pointed to by the pointer. Simply put, it means accessing the actual data that the pointer is pointing to. This is an essential operation for manipulating data structures and memory efficiently in C programming. Dereferencing a pointer can be performed using the dereference operator *. Understanding the concept of dereferencing a pointer and using it correctly is crucial for working with pointers in C.

    How to Dereference a Pointer in C

    To dereference a pointer in C, you need to use the dereference operator * followed by the pointer variable. The syntax for dereferencing a pointer looks like this:


    Here is an example to illustrate the process of dereferencing a pointer:

      int x = 10;
      int *ptr = &x
      int value = *ptr;

    In the example above:

    1. An integer variable x is assigned a value of 10.
    2. A pointer variable ptr is assigned the memory address of x using the address-of operator &.
    3. An integer variable value is assigned the value stored at the memory address pointed to by ptr through dereferencing the pointer using the dereference operator *.

    As a result, the variable value contains the value 10, which is the same as the value stored at the memory address pointed to by ptr.

    Pointer to Pointer Concept in C

    A pointer to a pointer is an advanced concept in C programming that allows you to have pointers pointing to other pointers. The primary purpose of a pointer to a pointer is to manage complex data structures like arrays of pointers, linked lists, and multi-level dynamic memory allocation. To declare a pointer to a pointer, you need to use the dereference operator * twice, as follows:

      data_type **pointer_to_pointer_variable;

    For example, to declare an integer pointer to a pointer, you would write:

      int **int_ptr_ptr;

    A pointer to a pointer can store the address of another pointer variable, which in turn points to a memory location containing a value. It essentially provides an indirect way of accessing the actual data stored at a memory address, using two levels of indirection.

    Dereferencing Multilevel Pointers in C

    When working with multilevel pointers like pointer-to-pointer variables, dereferencing becomes slightly more complicated. Here's how you can dereference a pointer to a pointer:


    For example, suppose we have the following code:

      int x = 5;
      int *ptr = &x
      int **ptr_ptr = &ptr

    In this example, x is an integer variable containing the value 5. The pointer variable ptr contains the memory address of x. The pointer-to-pointer variable ptr_ptr contains the memory address of ptr. To access the value of x from ptr_ptr, we need to perform a double dereference as follows:

      int value = **ptr_ptr;

    After executing the above line of code, the value of the variable value will be 5, which is the same as the value stored at the memory address pointed to by ptr.

    Understanding how to correctly manage and dereference multilevel pointers is essential for writing efficient, flexible, and dynamic C code, as it enables you to work with complex data structures and relationships between memory addresses.

    Pointer Arithmetic in C

    Pointer arithmetic in C involves performing various operations, such as addition, subtraction, and comparison, directly on pointers. Understanding pointer arithmetic is vital for efficient data manipulation and memory management in C programming, particularly when working with arrays and data structures like linked lists.

    Basics of Pointer Arithmetic in C

    Pointer arithmetic in C allows you to perform calculations on pointer variables by modifying the memory address they are pointing to. This can enable you to access different memory locations and traverse through data structures like arrays. Some of the basic operations you can perform using pointer arithmetic are:

    • Addition
    • Subtraction
    • Pointer comparisons

    When performing pointer arithmetic, it is essential to remember that the operations are performed based on the size of the data type the pointer is pointing to, not merely the memory address. This concept is crucial to avoid incorrect calculations or access to invalid memory locations.

    Adding and Subtracting Pointers in C

    In C, you can add or subtract integers from pointers to move the pointer to a different memory address. The operations are performed based on the size of the pointed data type. Here are some examples of addition and subtraction operations on pointers:

      int arr[] = {1, 2, 3, 4, 5};
      int *ptr = arr;
      ptr = ptr + 2; // Move the pointer two integers forward in memory
      ptr = ptr - 1; // Move the pointer one integer backward in memory

    When you add or subtract from a pointer, the pointer is moved by the size of the data type it is pointing to multiplied by the integer value being added or subtracted.

    It's important to note that adding or subtracting two pointers directly is not allowed in C programming, as it results in an undefined behaviour.

    Pointer Comparisons in C

    Comparing pointers in C allows you to determine the relative positions of two memory addresses or check if two pointers are pointing to the same location. You can use standard comparison operators like ==, !=, <, >, <=, and >= for comparing pointers. Some common use cases for pointer comparisons are:

    • Checking if two pointers point to the same memory address
    • Determining the position of one pointer relative to another
    • Validating if a pointer is pointing to a valid memory location or NULL

    Here's an example of comparing pointers in C:

      int arr[] = {1, 2, 3, 4, 5};
      int *ptr1 = &arr[0];
      int *ptr2 = &arr[1];
      if (ptr1 == ptr2) {
        printf("The pointers are pointing to the same memory location");
      } else if  (ptr1 < ptr2) {
        printf("ptr1 is pointing to an earlier position in memory");
      } else {
        printf("ptr1 is pointing to a later position in memory");

    Use of Pointer Arithmetic in Array Manipulation

    Pointer arithmetic is particularly useful for efficient manipulation of arrays in C programming. By using pointer arithmetic, you can:

    • Access array elements without using an index
    • Change the order of array elements without moving the actual data
    • Perform operations on a range of array elements with less code

    Here's an example of how pointer arithmetic can be used to traverse an array:

      int arr[] = {1, 2, 3, 4, 5};
      int *ptr;
      int i;
      for (ptr = arr; ptr < arr + 5; ptr++) {
        printf("Element = %d\n", *ptr);

    In this example, the pointer ptr is used to traverse the array instead of an index variable. The value of each element is accessed through dereferencing the pointer during each iteration.

    Understanding and efficiently applying pointer arithmetic in C programming is crucial for working with pointers, optimizing memory management, and manipulating complex data structures such as arrays.

    Pointers in C - Key takeaways

    • Pointers in C store memory addresses of variables or functions and play a crucial role in efficient memory management and dynamic memory allocation.

    • Pointers can be used with functions to increase efficiency by passing pointers as arguments or returning pointers from function calls.

    • Array of pointers in C allows efficient manipulation of multidimensional arrays through indirect access to elements and dynamic memory allocation.

    • Dereference pointers in C provides access to the actual data stored in the memory address pointed to by the pointer, enabling efficient data manipulation.

    • Pointer arithmetic in C, including addition, subtraction, and pointer comparisons, allows efficient access and manipulation of array elements and memory addresses.

    Frequently Asked Questions about Pointers in C
    What is a pointer in C?
    A pointer in C is a variable that holds a memory address as its value, usually referring to another variable or data structure. It allows for efficient manipulation of data and dynamic memory allocation. Pointers enable programmers to access memory locations directly, providing more control and flexibility when working with data structures. Additionally, they facilitate the creation of complex data structures such as linked lists and trees by storing references to their elements.
    How do pointers work in C?
    Pointers in C are variables that store the memory addresses of other variables or data elements. They enable the direct manipulation of memory locations, allowing efficient and flexible data handling. To work with pointers, you can use pointer arithmetic and various operators, such as the address-of (&) operator to get a memory address, and the dereference (*) operator to access or modify the value stored at a pointer's address. Pointers are commonly used for accessing arrays, passing function arguments by reference, and creating dynamic data structures.
    How do you declare a pointer in C?
    To declare a pointer in C, you must specify the data type of the variable it will point to, followed by an asterisk (*) and the pointer variable name. For example, to declare a pointer to an integer, you would write: `int *pointer_name;`.
    How can one dereference a pointer in C?
    To dereference a pointer in C, you use the asterisk (*) operator, which retrieves the value stored at the memory address held by the pointer. Simply place the asterisk before the pointer variable, like this: `int value = *pointer;`. This operation will obtain the value from the memory location that the pointer points to.
    How can one initialise a pointer in C?
    To initialise a pointer in C, you need to declare the pointer variable with its data type followed by an asterisk (*) and assign the address of the existing variable using the '&' (address-of) operator. For example: ```c int main() { int num = 10; int *ptr = # return 0; } ``` In this example, `ptr` is an integer pointer, initialised to the address of the integer variable `num`.

    Test your knowledge with multiple choice flashcards

    What is the process of obtaining the value stored at the memory address pointed to by a pointer in C called?

    What are the three main purposes of function pointers in C?

    What are the advantages of using arrays of pointers in C programming?


    Discover learning materials with the free StudySmarter app

    Sign up for free
    About StudySmarter

    StudySmarter is a globally recognized educational technology company, offering a holistic learning platform designed for students of all ages and educational levels. Our platform provides learning support for a wide range of subjects, including STEM, Social Sciences, and Languages and also helps students to successfully master various tests and exams worldwide, such as GCSE, A Level, SAT, ACT, Abitur, and more. We offer an extensive library of learning materials, including interactive flashcards, comprehensive textbook solutions, and detailed explanations. The cutting-edge technology and tools we provide help students create their own learning materials. StudySmarter’s content is not only expert-verified but also regularly updated to ensure accuracy and relevance.

    Learn more
    StudySmarter Editorial Team

    Team Computer Science Teachers

    • 17 minutes reading time
    • Checked by StudySmarter Editorial Team
    Save Explanation Save Explanation

    Study anywhere. Anytime.Across all devices.

    Sign-up for free

    Sign up to highlight and take notes. It’s 100% free.

    Join over 22 million students in learning with our StudySmarter App

    The first learning app that truly has everything you need to ace your exams in one place

    • Flashcards & Quizzes
    • AI Study Assistant
    • Study Planner
    • Mock-Exams
    • Smart Note-Taking
    Join over 22 million students in learning with our StudySmarter App
    Sign up with Email

    Get unlimited access with a free StudySmarter account.

    • Instant access to millions of learning materials.
    • Flashcards, notes, mock-exams, AI tools and more.
    • Everything you need to ace your exams.
    Second Popup Banner