pointer assignment format

• C++ Language
• Ascii Codes
• Boolean Operations
• Numerical Bases

Introduction

Basics of c++.

• Structure of a program
• Variables and types
• Basic Input/Output

Program structure

• Statements and flow control
• Overloads and templates
• Name visibility

Compound data types

• Character sequences
• Dynamic memory
• Data structures
• Other data types
• Classes (I)
• Classes (II)
• Special members
• Friendship and inheritance
• Polymorphism

Other language features

• Type conversions
• Preprocessor directives

Standard library

• Input/output with files

Address-of operator (&)

Dereference operator (*)

• & is the address-of operator , and can be read simply as "address of"
• * is the dereference operator , and can be read as "value pointed to by"

Declaring pointers

Pointers and arrays, pointer initialization, pointer arithmetics.

Pointers and const

Pointers and string literals.

Pointers to pointers

• c is of type char** and a value of 8092
• *c is of type char* and a value of 7230
• **c is of type char and a value of 'z'

void pointers

Invalid pointers and null pointers, pointers to functions.

Learn C++ practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, certification courses.

Created with over a decade of experience and thousands of feedback.

Introduction to C++

• Getting Started With C++
• Your First C++ Program
• C++ Comments

C++ Fundamentals

• C++ Keywords and Identifiers
• C++ Variables, Literals and Constants
• C++ Data Types
• C++ Type Modifiers
• C++ Constants
• C++ Basic Input/Output
• C++ Operators

Flow Control

• C++ Relational and Logical Operators
• C++ if, if...else and Nested if...else
• C++ for Loop
• C++ while and do...while Loop
• C++ break Statement
• C++ continue Statement
• C++ goto Statement
• C++ switch..case Statement
• C++ Ternary Operator
• C++ Functions
• C++ Programming Default Arguments
• C++ Function Overloading
• C++ Inline Functions
• C++ Recursion

Arrays and Strings

• C++ Array to Function
• C++ Multidimensional Arrays
• C++ String Class

Pointers and References

• C++ Pointers

C++ Pointers and Arrays

• C++ References: Using Pointers
• C++ Call by Reference: Using pointers
• C++ Memory Management: new and delete

Structures and Enumerations

• C++ Structures
• C++ Structure and Function
• C++ Pointers to Structure
• C++ Enumeration

Object Oriented Programming

• C++ Classes and Objects
• C++ Constructors
• C++ Constructor Overloading
• C++ Destructors
• C++ Access Modifiers
• C++ Encapsulation
• C++ friend Function and friend Classes

Inheritance & Polymorphism

• C++ Inheritance
• C++ Public, Protected and Private Inheritance
• C++ Multiple, Multilevel and Hierarchical Inheritance
• C++ Function Overriding
• C++ Virtual Functions
• C++ Abstract Class and Pure Virtual Function

STL - Vector, Queue & Stack

• C++ Standard Template Library
• C++ STL Containers
• C++ std::array
• C++ Vectors
• C++ Forward List
• C++ Priority Queue

STL - Map & Set

• C++ Multimap
• C++ Multiset
• C++ Unordered Map
• C++ Unordered Set
• C++ Unordered Multiset
• C++ Unordered Multimap

STL - Iterators & Algorithms

• C++ Iterators
• C++ Algorithm
• C++ Functor

Additional Topics

• C++ Exceptions Handling
• C++ File Handling
• C++ Ranged for Loop
• C++ Nested Loop
• C++ Function Template
• C++ Class Templates
• C++ Type Conversion
• C++ Type Conversion Operators
• C++ Operator Overloading

Advanced Topics

• C++ Namespaces
• C++ Preprocessors and Macros
• C++ Storage Class
• C++ Bitwise Operators
• C++ Buffers
• C++ istream
• C++ ostream

C++ Tutorials

C++ Memory Management

C++ Pointer to Void

C++ Pass by Reference

In C++, pointers are variables that store the memory addresses of other variables.

• Address in C++

Every variable we declare in our program has an associated location in the memory, which we call the memory address of the variable.

If we have a variable var in our program, &var returns its memory address. For example,

Here, 0x at the beginning represents the address in the hexadecimal form.

Notice that the first address differs from the second by 4 bytes, and the second address differs from the third by 4 bytes.

The difference is because the size of an int is 4 bytes in a 64-bit system.

Note: You may not get the same results when you run the program. This is because the address depends on the environment in which the program runs.

Here is how we can declare pointers:

Here, we have declared a variable point_var which is a pointer to an int .

We can also declare pointers in the following way:

• Assigning Addresses to Pointers

Here is how we can assign addresses to pointers:

Here, 5 is assigned to the variable var . And the address of var is assigned to the point_var pointer with the code point_var = &var .

Note: It is a good practice to initialize pointers as soon as they are declared.

• Get the Value from the Address Using Pointers

To get the value pointed by a pointer, we use the * operator. For example:

In the above code, the address of var is assigned to point_var . We have used the *point_var to get the value stored in that address.

When * is used with pointers, it's called the dereference operator . It operates on a pointer and gives the value pointed by the address stored in the pointer. That is, *point_var = var .

Note: In C++, point_var and *point_var are completely different. We cannot do something like *point_var = &var; . Here, point_var is a pointer that stores the address of variable it points to while *point_var returns the value stored at the address pointed by point_var .

• Example 1: Working of C++ Pointers

• Changing Value Pointed by Pointers

If point_var points to the address of var , we can change the value of var by using *point_var .

For example,

Here, point_var and &var have the same address; the value of var will also be changed when *point_var is changed.

• Example 2: Changing Value Pointed by Pointers

Here point_var holds the address of var , and by dereferencing point_var with *point_var , we can access and modify the value stored at that address, which in turn affects the original variable var.

• Common Mistakes When Working with Pointers

Suppose we want a pointer point_var to point to the address of var . Then,

• How to represent an array using a pointer?
• How to use pointers with functions?
• How to use pointers with structures?
• C++Pass by Reference

Table of Contents

• Introduction

Sorry about that.

Our premium learning platform, created with over a decade of experience and thousands of feedbacks .

Learn and improve your coding skills like never before.

• Interactive Courses
• Certificates
• 2000+ Challenges

Related Tutorials

C++ Tutorial

• C++ Data Types
• C++ Input/Output

C++ Pointers

• C++ Interview Questions
• C++ Programs
• C++ Cheatsheet
• C++ Projects
• C++ Exception Handling
• C++ Memory Management

Pointers are symbolic representations of addresses. They enable programs to simulate call-by-reference as well as to create and manipulate dynamic data structures. Iterating over elements in arrays or other data structures is one of the main use of pointers. 

The address of the variable you’re working with is assigned to the pointer variable that points to the same data type (such as an int or string).

How to use a pointer?

• Define a pointer variable
• Assigning the address of a variable to a pointer using the unary operator (&) which returns the address of that variable.
• Accessing the value stored in the address using unary operator (*) which returns the value of the variable located at the address specified by its operand.

The reason we associate data type with a pointer is that it knows how many bytes the data is stored in . When we increment a pointer, we increase the pointer by the size of the data type to which it points. To master the use of pointers and their applications, explore the C++ Course for comprehensive lessons and hands-on examples.

References and Pointers

There are 3 ways to pass C++ arguments to a function:

• Call-By-Value
• Call-By-Reference with a Pointer Argument
• Call-By-Reference with a Reference Argument

In C++, by default arguments are passed by value and the changes made in the called function will not reflect in the passed variable. The changes are made into a clone made by the called function. If wish to modify the original copy directly (especially in passing huge object or array) and/or avoid the overhead of cloning, we use pass-by-reference. Pass-by-Reference with Reference Arguments does not require any clumsy syntax for referencing and dereferencing.

• Function pointers in C
• Pointer to a Function

Array Name as Pointers

An array name contains the address of the first element of the array which acts like a constant pointer. It means, the address stored in the array name can’t be changed. For example, if we have an array named val then val and &val[0] can be used interchangeably. 

 If pointer ptr is sent to a function as an argument, the array val can be accessed in a similar fashion. Pointer vs Array

Pointer Expressions and Pointer Arithmetic

A limited set of arithmetic operations can be performed on pointers which are:

• incremented ( ++ )
• decremented ( — )
• an integer may be added to a pointer ( + or += )
• an integer may be subtracted from a pointer ( – or -= )
• difference between two pointers (p1-p2)

( Note: Pointer arithmetic is meaningless unless performed on an array.) 

Advanced Pointer Notation

Consider pointer notation for the two-dimensional numeric arrays. consider the following declaration

In general, nums[ i ][ j ] is equivalent to *(*(nums+i)+j)  

Pointers and String literals

String literals are arrays containing null-terminated character sequences. String literals are arrays of type character plus terminating null-character, with each of the elements being of type const char (as characters of string can’t be modified).

This declares an array with the literal representation for “geek”, and then a pointer to its first element is assigned to ptr. If we imagine that “geek” is stored at the memory locations that start at address 1800, we can represent the previous declaration as: 

As pointers and arrays behave in the same way in expressions, ptr can be used to access the characters of a string literal. For example:

Here, both x and y contain k stored at 1803 (1800+3).

Pointers to pointers

In C++, we can create a pointer to a pointer that in turn may point to data or another pointer. The syntax simply requires the unary operator (*) for each level of indirection while declaring the pointer.

Here b points to a char that stores ‘g’ and c points to the pointer b.

Void Pointers

This is a special type of pointer available in C++ which represents the absence of type. Void pointers are pointers that point to a value that has no type (and thus also an undetermined length and undetermined dereferencing properties). This means that void pointers have great flexibility as they can point to any data type. There is a payoff for this flexibility. These pointers cannot be directly dereferenced. They have to be first transformed into some other pointer type that points to a concrete data type before being dereferenced. 

Invalid pointers

A pointer should point to a valid address but not necessarily to valid elements (like for arrays). These are called invalid pointers. Uninitialized pointers are also invalid pointers.

Here, ptr1 is uninitialized so it becomes an invalid pointer and ptr2 is out of bounds of arr so it also becomes an invalid pointer. (Note: invalid pointers do not necessarily raise compile errors)

NULL Pointers

A null pointer is a pointer that point nowhere and not just an invalid address. Following are 2 methods to assign a pointer as NULL;

Advantages of Pointers

• Pointers reduce the code and improve performance. They are used to retrieve strings, trees, arrays, structures, and functions.
• Pointers allow us to return multiple values from functions.
• In addition to this, pointers allow us to access a memory location in the computer’s memory.

Related Articles:

• Opaque Pointer
• Near, Far and huge Pointers
• Pointer Basics
• Advanced Pointer

Similar Reads

• cpp-pointer

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Pointers are the basis for every complex data structure used in programming.  While this is not a data structures course, a basic understanding of pointers should assist you when you begin to view code that is not your own and likely implements several different types of data structures.

If you were to obtain access to a well written program that is related to your area of study, you will make two observations.

• Everything is a user-defined TYPE.
• Everything uses pointers.

A pointer is a variable that contains to data at all, instead, it c ontains an address in memory of another variable (that stores something useful).

• Since a pointer is a variable (which is an object) it must also have a name.
• Pointers will be used to not only work with dynamic memory needs, but dynamic storage structures.
• Let's start simple first and let the focus of the bigger picture come to us through experience.

15.1 Pointers and Targets

Pointer Declaration

• The type of the pointer must be declared even though the pointer contains no data of that type.
• Instead, the pointer will store an address of a variable of that declared type.
• Still don't see a need for the type?  Each data type (INTEGER, REAL, CHARACTER, or defined type) has a different set of data requirements.  We only want to "point" to enough memory of the type we wish to reference.
• Pointers can point to user-defined types.

Pointers to Arrays

• Pointers may also point to an array.
• A pointer to an array is declared with a deferred-shape array, meaning that the rank of the array (number of dimensions) is specified but the actual extent of each dimension is not indicated.
• A pointer can point to any variable or array of the pointer's type as long as the variable has been declared to be a TARGET.
• A target is a data object whose address has been made available for use with pointers.
• I've never seen anything like this before either!  But such is the way of FORTRAN! :)
• The need for the TARGET attribute is based on the nature of FORTRAN compilers.
• When memory is no longer needed for a variable (because the program is done with it) the memory is collected and permitted to be used by another variable (or other action requiring some memory). 
• The optimizer of the compiler tries to identify variables that are no longer needed and free that memory unless an attribute like TARGET is listed and such a variable will be spared from the collection of unused (no longer used) variables.

15.1.1 Pointer Assignment Statements

A pointer can be associated with a given target by means of a pointer assignment .  A pointer assignment takes the form of:

Now the memory address of x has been stored in the pointer ptr .

Changing where a pointer points.

• It is possible to switch to what a pointer points.  This is what is variable about a pointer, the address to which it points!
• One pointer can also point the same place as another.  See above where r is reassigned to point to q ?

Does one pointer follow another?

15.1.2 Pointer Association Status (Are you a member of the Pointer Association?)

The association status of a pointer indicates whether or not the pointer currently points to a valid target. 

There are three states of association possible:

• Undefined - an uninitialized pointer
• Associated - a pointer assigned to valid target
• How does one disassociate a pointer from its target?
• NULLIFY(ptr)

A pointer can only be used to reference (or dereference) a target when it is associated with that target.  Any attempt to use a pointer when it is not associated with a target results in an error and the program aborts.

The ASSOCIATED Function

15.2 Using Pointers in Assignment Statements

Dereferencing Pointers and Assigning them to Other Pointers

• The pointer b does not point anywhere valid, how can you send a value to nowhere?

Another Example

DEV Community

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:

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.

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.

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

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:

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.

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.

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.

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 .

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:

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

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

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};

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

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)

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

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

• Joined Nov 4, 2023

Great post. Thank you so much for this.

• Email [email protected]
• Joined Jul 7, 2023

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

Some comments may only be visible to logged-in visitors. Sign in to view all comments.

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

A beginner's guide to the Stable-Diffusion-V1-4 model by Compvis on Huggingface

Mike Young - Nov 12

Arrow Functions => What's wrong with the regular ones?

Elchonon Klafter - Nov 11

Man, I love my keyboard !

Snoupix - Nov 11

Unit, Integration, and E2E Testing in One Example Using Jest

Mohamed Mayallo - Nov 14

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

C++ Tutorial

C++ functions, c++ classes, c++ data s tructures, c++ reference, c++ examples, c++ pointers, creating pointers.

You learned from the previous chapter, that we can get the memory address of a variable by using the & operator:

A pointer however, is a variable that stores the memory address as its value .

A pointer variable points to a data type (like int or string ) of the same type, and is created with the * operator. The address of the variable you're working with is assigned to the pointer:

Example explained

Create a pointer variable with the name ptr , that points to a string variable, by using the asterisk sign * ( string* ptr ). Note that the type of the pointer has to match the type of the variable you're working with.

Use the & operator to store the memory address of the variable called food , and assign it to the pointer.

Now, ptr holds the value of food 's memory address.

Tip: There are three ways to declare pointer variables, but the first way is preferred:

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.