assign value to pointer array c

C Programming/Pointers and arrays

A pointer is a value that designates the address (i.e., the location in memory), of some value. Pointers are variables that hold a memory location.

There are four fundamental things you need to know about pointers:

• How to declare them (with the address operator ' & ': int *pointer = &variable; )
• How to assign to them ( pointer = NULL; )
• How to reference the value to which the pointer points (known as dereferencing , by using the dereferencing operator ' * ': value = *pointer; )
• How they relate to arrays (the vast majority of arrays in C are simple lists, also called "1 dimensional arrays", but we will briefly cover multi-dimensional arrays with some pointers in a later chapter ).

Pointers can reference any data type, even functions. We'll also discuss the relationship of pointers with text strings and the more advanced concept of function pointers.

• 1 Declaring pointers
• 2 Assigning values to pointers
• 3 Pointer dereferencing
• 4 Pointers and Arrays
• 5 Pointers in Function Arguments
• 6 Pointers and Text Strings
• 7.1 Practical use of function pointers in C
• 8 Examples of pointer constructs
• 10 External Links

Declaring pointers [ edit | edit source ]

Consider the following snippet of code which declares two pointers:

Lines 1-4 define a structure . Line 8 declares a variable that points to an int , and line 9 declares a variable that points to something with structure MyStruct. So to declare a variable as something that points to some type, rather than contains some type, the asterisk ( * ) is placed before the variable name.

In the following, line 1 declares var1 as a pointer to a long and var2 as a long and not a pointer to a long. In line 2, p3 is declared as a pointer to a pointer to an int.

Pointer types are often used as parameters to function calls. The following shows how to declare a function which uses a pointer as an argument. Since C passes function arguments by value, in order to allow a function to modify a value from the calling routine, a pointer to the value must be passed. Pointers to structures are also used as function arguments even when nothing in the struct will be modified in the function. This is done to avoid copying the complete contents of the structure onto the stack. More about pointers as function arguments later.

Assigning values to pointers [ edit | edit source ]

So far we've discussed how to declare pointers. The process of assigning values to pointers is next. To assign the address of a variable to a pointer, the & or 'address of' operator is used.

Here, pPointer will now reference myInt and pKeyboard will reference dvorak.

Pointers can also be assigned to reference dynamically allocated memory. The malloc() and calloc() functions are often used to do this.

The malloc function returns a pointer to dynamically allocated memory (or NULL if unsuccessful). The size of this memory will be appropriately sized to contain the MyStruct structure.

The following is an example showing one pointer being assigned to another and of a pointer being assigned a return value from a function.

When returning a pointer from a function, do not return a pointer that points to a value that is local to the function or that is a pointer to a function argument. Pointers to local variables become invalid when the function exits. In the above function, the value returned points to a static variable. Returning a pointer to dynamically allocated memory is also valid.

Pointer dereferencing [ edit | edit source ]

To access a value to which a pointer points, the * operator is used. Another operator, the -> operator is used in conjunction with pointers to structures. Here's a short example.

The expression bb->m_aNumber is entirely equivalent to (*bb).m_aNumber . They both access the m_aNumber element of the structure pointed to by bb . There is one more way of dereferencing a pointer, which will be discussed in the following section.

When dereferencing a pointer that points to an invalid memory location, an error often occurs which results in the program terminating. The error is often reported as a segmentation error. A common cause of this is failure to initialize a pointer before trying to dereference it.

C is known for giving you just enough rope to hang yourself, and pointer dereferencing is a prime example. You are quite free to write code that accesses memory outside that which you have explicitly requested from the system. And many times, that memory may appear as available to your program due to the vagaries of system memory allocation. However, even if 99 executions allow your program to run without fault, that 100th execution may be the time when your "memory pilfering" is caught by the system and the program fails. Be careful to ensure that your pointer offsets are within the bounds of allocated memory!

The declaration void *somePointer; is used to declare a pointer of some nonspecified type. You can assign a value to a void pointer, but you must cast the variable to point to some specified type before you can dereference it. Pointer arithmetic is also not valid with void * pointers.

Pointers and Arrays [ edit | edit source ]

Up to now, we've carefully been avoiding discussing arrays in the context of pointers. The interaction of pointers and arrays can be confusing but here are two fundamental statements about it:

• A variable declared as an array of some type acts as a pointer to that type. When used by itself, it points to the first element of the array.
• A pointer can be indexed like an array name.

The first case often is seen to occur when an array is passed as an argument to a function. The function declares the parameter as a pointer, but the actual argument may be the name of an array. The second case often occurs when accessing dynamically allocated memory.

Let's look at examples of each. In the following code, the call to calloc() effectively allocates an array of struct MyStruct items.

Pointers and array names can pretty much be used interchangeably; however, there are exceptions. You cannot assign a new pointer value to an array name. The array name will always point to the first element of the array. In the function returnSameIfAnyEquals , you could however assign a new value to workingArray, as it is just a pointer to the first element of workingArray. It is also valid for a function to return a pointer to one of the array elements from an array passed as an argument to a function. A function should never return a pointer to a local variable, even though the compiler will probably not complain.

When declaring parameters to functions, declaring an array variable without a size is equivalent to declaring a pointer. Often this is done to emphasize the fact that the pointer variable will be used in a manner equivalent to an array.

Now we're ready to discuss pointer arithmetic. You can add and subtract integer values to/from pointers. If myArray is declared to be some type of array, the expression *(myArray+j) , where j is an integer, is equivalent to myArray[j] . For instance, in the above example where we had the expression secondArray[i].otherNumber , we could have written that as (*(secondArray+i)).otherNumber or more simply (secondArray+i)->otherNumber .

Note that for addition and subtraction of integers and pointers, the value of the pointer is not adjusted by the integer amount, but is adjusted by the amount multiplied by the size of the type to which the pointer refers in bytes. (For example, pointer + x can be thought of as pointer + (x * sizeof(*type)) .)

One pointer may also be subtracted from another, provided they point to elements of the same array (or the position just beyond the end of the array). If you have a pointer that points to an element of an array, the index of the element is the result when the array name is subtracted from the pointer. Here's an example.

You may be wondering how pointers and multidimensional arrays interact. Let's look at this a bit in detail. Suppose A is declared as a two dimensional array of floats ( float A[D1][D2]; ) and that pf is declared a pointer to a float. If pf is initialized to point to A[0][0], then *(pf+1) is equivalent to A[0][1] and *(pf+D2) is equivalent to A[1][0]. The elements of the array are stored in row-major order.

Let's look at a slightly different problem. We want to have a two dimensional array, but we don't need to have all the rows the same length. What we do is declare an array of pointers. The second line below declares A as an array of pointers. Each pointer points to a float. Here's some applicable code:

We also note here something curious about array indexing. Suppose myArray is an array and i is an integer value. The expression myArray[i] is equivalent to i[myArray] . The first is equivalent to *(myArray+i) , and the second is equivalent to *(i+myArray) . These turn out to be the same, since the addition is commutative.

Pointers can be used with pre-increment or post-decrement, which is sometimes done within a loop, as in the following example. The increment and decrement applies to the pointer, not to the object to which the pointer refers. In other words, *pArray++ is equivalent to *(pArray++) .

Pointers in Function Arguments [ edit | edit source ]

Often we need to invoke a function with an argument that is itself a pointer. In many instances, the variable is itself a parameter for the current function and may be a pointer to some type of structure. The ampersand ( & ) character is not needed in this circumstance to obtain a pointer value, as the variable is itself a pointer. In the example below, the variable pStruct , a pointer, is a parameter to function FunctTwo , and is passed as an argument to FunctOne .

The second parameter to FunctOne is an int. Since in function FunctTwo , mValue is a pointer to an int, the pointer must first be dereferenced using the * operator, hence the second argument in the call is *mValue . The third parameter to function FunctOne is a pointer to a long. Since pAA is itself a pointer to a long, no ampersand is needed when it is used as the third argument to the function.

Pointers and Text Strings [ edit | edit source ]

Historically, text strings in C have been implemented as arrays of characters, with the last byte in the string being a zero, or the null character '\0'. Most C implementations come with a standard library of functions for manipulating strings. Many of the more commonly used functions expect the strings to be null terminated strings of characters. To use these functions requires the inclusion of the standard C header file "string.h".

A statically declared, initialized string would look similar to the following:

The variable myFormat can be viewed as an array of 21 characters. There is an implied null character ('\0') tacked on to the end of the string after the 'd' as the 21st item in the array. You can also initialize the individual characters of the array as follows:

An initialized array of strings would typically be done as follows:

The initialization of an especially long string can be split across lines of source code as follows.

The library functions that are used with strings are discussed in a later chapter.

Pointers to Functions [ edit | edit source ]

C also allows you to create pointers to functions. Pointers to functions syntax can get rather messy. As an example of this, consider the following functions:

Declaring a typedef to a function pointer generally clarifies the code. Here's an example that uses a function pointer, and a void * pointer to implement what's known as a callback. The DoSomethingNice function invokes a caller supplied function TalkJive with caller data. Note that DoSomethingNice really doesn't know anything about what dataPointer refers to.

Some versions of C may not require an ampersand preceding the TalkJive argument in the DoSomethingNice call. Some implementations may require specifically casting the argument to the MyFunctionType type, even though the function signature exacly matches that of the typedef.

Function pointers can be useful for implementing a form of polymorphism in C. First one declares a structure having as elements function pointers for the various operations to that can be specified polymorphically. A second base object structure containing a pointer to the previous structure is also declared. A class is defined by extending the second structure with the data specific for the class, and static variable of the type of the first structure, containing the addresses of the functions that are associated with the class. This type of polymorphism is used in the standard library when file I/O functions are called.

A similar mechanism can also be used for implementing a state machine in C. A structure is defined which contains function pointers for handling events that may occur within state, and for functions to be invoked upon entry to and exit from the state. An instance of this structure corresponds to a state. Each state is initialized with pointers to functions appropriate for the state. The current state of the state machine is in effect a pointer to one of these states. Changing the value of the current state pointer effectively changes the current state. When some event occurs, the appropriate function is called through a function pointer in the current state.

Practical use of function pointers in C [ edit | edit source ]

Function pointers are mainly used to reduce the complexity of switch statement. Example with switch statement:

Without using a switch statement:

Function pointers may be used to create a struct member function:

Use to implement this pointer (following code must be placed in library).

Examples of pointer constructs [ edit | edit source ]

Below are some example constructs which may aid in creating your pointer.

sizeof [ edit | edit source ]

The sizeof operator is often used to refer to the size of a static array declared earlier in the same function.

To find the end of an array (example from wikipedia:Buffer overflow ):

To iterate over every element of an array, use

Note that the sizeof operator only works on things defined earlier in the same function. The compiler replaces it with some fixed constant number. In this case, the buffer was declared as an array of 10 char's earlier in the same function, and the compiler replaces sizeof(buffer) with the number 10 at compile time (equivalent to us hard-coding 10 into the code in place of sizeof(buffer) ). The information about the length of buffer is not actually stored anywhere in memory (unless we keep track of it separately) and cannot be programmatically obtained at run time from the array/pointer itself.

Often a function needs to know the size of an array it was given -- an array defined in some other function. For example,

Unfortunately, (in C and C++) the length of the array cannot be obtained from an array passed in at run time, because (as mentioned above) the size of an array is not stored anywhere. The compiler always replaces sizeof with a constant. This sum() routine needs to handle more than just one constant length of an array.

There are some common ways to work around this fact:

• Write the function to require, for each array parameter, a "length" parameter (which has type "size_t"). (Typically we use sizeof at the point where this function is called).
• Use of a convention, such as a null-terminated string to mark the end of the array.
• Instead of passing raw arrays, pass a structure that includes the length of the array (such as ".length") as well as the array (or a pointer to the first element); similar to the string or vector classes in C++.

It's worth mentioning that sizeof operator has two variations: sizeof ( type ) (for instance: sizeof (int) or sizeof (struct some_structure) ) and sizeof expression (for instance: sizeof some_variable.some_field or sizeof 1 ).

External Links [ edit | edit source ]

• "Common Pointer Pitfalls" by Dave Marshall

• Book:C Programming

Navigation menu

• C Programming Tutorial
• C - Overview
• C - Environment Setup
• C - Program Structure
• C - Basic Syntax
• C - Data Types
• C - Variables
• C - Constants
• C - Storage Classes
• C - Operators
• C - Decision Making
• C - Functions
• C - Scope Rules
• C - Pointers
• C - Strings
• C - Structures
• C - Bit Fields
• C - Typedef
• C - Input & Output
• C - File I/O
• C - Preprocessors
• C - Header Files
• C - Type Casting
• C - Error Handling
• C - Recursion
• C - Variable Arguments
• C - Memory Management
• C - Command Line Arguments
• C Programming useful Resources
• C - Questions & Answers
• C - Quick Guide
• C - Useful Resources
• C - Discussion
• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Pointer to an Array in C

It is most likely that you would not understand this section until you are through with the chapter 'Pointers'.

Assuming you have some understanding of pointers in C, let us start: An array name is a constant pointer to the first element of the array. Therefore, in the declaration −

balance is a pointer to &balance[0], which is the address of the first element of the array balance. Thus, the following program fragment assigns p as the address of the first element of balance −

It is legal to use array names as constant pointers, and vice versa. Therefore, *(balance + 4) is a legitimate way of accessing the data at balance[4].

Once you store the address of the first element in 'p', you can access the array elements using *p, *(p+1), *(p+2) and so on. Given below is the example to show all the concepts discussed above −

When the above code is compiled and executed, it produces the following result −

In the above example, p is a pointer to double, which means it can store the address of a variable of double type. Once we have the address in p, *p will give us the value available at the address stored in p, as we have shown in the above example.

Kickstart Your Career

Get certified by completing the course

7.0 Pointers

7.1.0 pointer basics.

int i = 5; ip = &i;

ip = &i;

*ip = &i;

int i = 5; int *ip; ip = &i; // Point ip to the memory address of variable i. *ip = 10; // Change the contents of the variable ip points to to 10.

7.2.0 Pointers and Arrays - Pointer Arithmetic

int a[10]; int *pa = &a[0];

int a[10]; int *pa = a;

int a[10]; int *pa = &a[4];

int a[10]; int *pa = a+4; // Converts to &a[0] + 4 or &a[4]

int a[5] = {1,2,3,4,5}; int *pa = a; int i, total = 0; for(i = 0; i

int a[5] = {1,2,3,4,5}; int *pa = a; pa = pa+3; // Increments the pointer by 3 *pa = *pa+3 // WRONG: Increments the contents of the variable // pointed to by pa by 3

7.3.0 Pointers as function arguments

char function(char a[]); char function(char *a);

void function (char a[], int len) { int k; for(k = 0; k

C Functions

C structures, c pointers and arrays, pointers & arrays.

You can also use pointers to access arrays .

Consider the following array of integers:

You learned from the arrays chapter that you can loop through the array elements with a for loop:

Instead of printing the value of each array element, let's print the memory address of each array element:

Note that the last number of each of the elements' memory address is different, with an addition of 4.

It is because the size of an int type is typically 4 bytes, remember:

So from the "memory address example" above, you can see that the compiler reserves 4 bytes of memory for each array element, which means that the entire array takes up 16 bytes (4 * 4) of memory storage:

How Are Pointers Related to Arrays

Ok, so what's the relationship between pointers and arrays? Well, in C, the name of an array , is actually a pointer to the first element of the array.

Confused? Let's try to understand this better, and use our "memory address example" above again.

The memory address of the first element is the same as the name of the array :

This basically means that we can work with arrays through pointers!

How? Since myNumbers is a pointer to the first element in myNumbers, you can use the * operator to access it:

To access the rest of the elements in myNumbers, you can increment the pointer/array (+1, +2, etc):

Or loop through it:

It is also possible to change the value of array elements with pointers:

This way of working with arrays might seem a bit excessive. Especially with simple arrays like in the examples above. However, for large arrays, it can be much more efficient to access and manipulate arrays with pointers.

It is also considered faster and easier to access two-dimensional arrays with pointers.

And since strings are actually arrays, you can also use pointers to access strings .

For now, it's great that you know how this works. But like we specified in the previous chapter; pointers must be handled with care , since it is possible to overwrite other data stored in memory.

COLOR PICKER

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

[email protected]

Top Tutorials

Top references, top examples, get certified.

Advertisement

The Basics of C Programming

• Share Content on Facebook
• Share Content on LinkedIn
• Share Content on Flipboard
• Share Content on Reddit
• Share Content via Email

Using Pointers with Arrays

Arrays and pointers are intimately linked in C. To use arrays effectively, you have to know how to use pointers with them. Fully understanding the relationship between the two probably requires several days of study and experimentation, but it is well worth the effort.

Let's start with a simple example of arrays in C:

Enter this code and try to compile it. You will find that C will not compile it. If you want to copy a into b , you have to enter something like the following instead:

Or, to put it more succinctly:

Better yet, use the memcpy utility in string.h .

Arrays in C are unusual in that variables a and b are not, technically, arrays themselves. Instead they are permanent pointers to arrays. a and b permanently point to the first elements of their respective arrays -- they hold the addresses of a[0] and b[0] respectively. Since they are permanent pointers you cannot change their addresses. The statement a=b; therefore does not work.

Because a and b are pointers, you can do several interesting things with pointers and arrays. For example, the following code works:

The statement p=a; works because a is a pointer. Technically, a points to the address of the 0th element of the actual array. This element is an integer, so a is a pointer to a single integer. Therefore, declaring p as a pointer to an integer and setting it equal to a works. Another way to say exactly the same thing would be to replace p=a; with p=&a[0]; . Since a contains the address of a[0] , a and &a[0] mean the same thing.

Now that p is pointing at the 0th element of a , you can do some rather strange things with it. The a variable is a permanent pointer and can not be changed, but p is not subject to such restrictions. C actually encourages you to move it around using pointer arithmetic . For example, if you say p++; , the compiler knows that p points to an integer, so this statement increments p the appropriate number of bytes to move it to the next element of the array. If p were pointing to an array of 100-byte-long structures, p++; would move p over by 100 bytes. C takes care of the details of element size.

You can copy the array a into b using pointers as well. The following code can replace (for i=0; i<MAX; a [i] =b [i] , i++); :

You can abbreviate this code as follows:

And you can further abbreviate it to:

What if you go beyond the end of the array a or b with the pointers p or q ? C does not care -- it blithely goes along incrementing p and q , copying away over other variables with abandon. You need to be careful when indexing into arrays in C, because C assumes that you know what you are doing.

You can pass an array such as a or b to a function in two different ways. Imagine a function dump that accepts an array of integers as a parameter and prints the contents of the array to stdout. There are two ways to code dump :

The nia (number_in_array) variable is required so that the size of the array is known. Note that only a pointer to the array, rather than the contents of the array, is passed to the function. Also note that C functions can accept variable-size arrays as parameters.

Please copy/paste the following text to properly cite this HowStuffWorks.com article:

Learn C practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn c interactively, c introduction.

• Keywords & Identifier
• Variables & Constants
• C Data Types
• C Input/Output
• C Operators
• C Introduction Examples

C Flow Control

• C if...else
• C while Loop
• C break and continue
• C switch...case
• C Programming goto
• Control Flow Examples

C Functions

• C Programming Functions
• C User-defined Functions
• C Function Types
• C Recursion
• C Storage Class
• C Function Examples
• C Programming Arrays
• C Multi-dimensional Arrays
• C Arrays & Function
• C Programming Pointers
• C Pointers & Arrays
• C Pointers And Functions
• C Memory Allocation
• Array & Pointer Examples

C Programming Strings

• C Programming String
• C String Functions
• C String Examples

Structure And Union

• C Structure
• C Struct & Pointers
• C Struct & Function
• C struct Examples

C Programming Files

• C Files Input/Output
• C Files Examples

Additional Topics

• C Enumeration
• C Preprocessors
• C Standard Library
• C Programming Examples
• Calculate Average Using Arrays
• Find Largest Element in an Array

C Multidimensional Arrays

• Access Array Elements Using Pointer

Relationship Between Arrays and Pointers

• Store Information of Students Using Structure

An array is a variable that can store multiple values. For example, if you want to store 100 integers, you can create an array for it.

How to declare an array?

For example,

Here, we declared an array, mark , of floating-point type. And its size is 5. Meaning, it can hold 5 floating-point values.

It's important to note that the size and type of an array cannot be changed once it is declared.

Access Array Elements

You can access elements of an array by indices.

Suppose you declared an array mark as above. The first element is mark[0] , the second element is mark[1] and so on.

Few keynotes :

• Arrays have 0 as the first index, not 1. In this example, mark[0] is the first element.
• If the size of an array is n , to access the last element, the n-1 index is used. In this example, mark[4]
• Suppose the starting address of mark[0] is 2120d . Then, the address of the mark[1] will be 2124d . Similarly, the address of mark[2] will be 2128d and so on. This is because the size of a float is 4 bytes.

How to initialize an array?

It is possible to initialize an array during declaration. For example,

You can also initialize an array like this.

Here, we haven't specified the size. However, the compiler knows its size is 5 as we are initializing it with 5 elements.

Change Value of Array elements

Input and output array elements.

Here's how you can take input from the user and store it in an array element.

Here's how you can print an individual element of an array.

Example 1: Array Input/Output

Here, we have used a  for loop to take 5 inputs from the user and store them in an array. Then, using another  for loop, these elements are displayed on the screen.

Example 2: Calculate Average

Here, we have computed the average of n numbers entered by the user.

Access elements out of its bound!

Suppose you declared an array of 10 elements. Let's say,

You can access the array elements from testArray[0] to testArray[9] .

Now let's say if you try to access testArray[12] . The element is not available. This may cause unexpected output (undefined behavior). Sometimes you might get an error and some other time your program may run correctly.

Hence, you should never access elements of an array outside of its bound.

Multidimensional arrays

In this tutorial, you learned about arrays. These arrays are called one-dimensional arrays.

In the next tutorial, you will learn about multidimensional arrays (array of an array) .

Table of Contents

• C Arrays (Introduction)
• Declaring an Array
• Access array elements
• Initializing an array
• Change Value of Array Elements
• Array Input/Output
• Example: Calculate Average
• Array Elements Out of its Bound

Video: C Arrays

Sorry about that.

Related Tutorials

Pass arrays to a function in C

C Array and Pointer Examples

Dennis Kubes

• C Programming
• Assembly Language

19 August, 2012

Basics of Pointers and Arrays in C

Discussions of pointers and arrays in C seem to be a holy war. On one side you have the people who say pointers are not arrays and that everybody must know that. On the other you have the people who say arrays are treated as pointers and so there shouldn’t be a distinction, it just confuses people. Turns out both sides are right.

Arrays are not pointers and pointers are not arrays. Pointers in C hold a single address in memory. Arrays are contiguous blocks of memory that hold multiple like kind objects. Check out my previous post on Memory Addresses in C for a deeper explanation. Where the confusion comes in is that, for the most part, arrays are treated like pointers in C.

Array Notation vs Pointer Notation

When we say that arrays are treated like pointers in C, we mean the following:

• The array variable holds the address of the first element in the array. It isn’t a pointer but it does act like a constant pointer that cannot be changed.
• Programs often interact with arrays using pointer notation instead of array notation.

Let’s look at some code:

We declare an int array with 5 ints and assign the array numbers variable to our int pointer, ptr1. The numbers variable holds the address of the first element in the array. Assigning it to ptr1 numbers is treated as an pointer. We then get the value of the first element in the array using array notation.

In the second example we get the address of the first element in the array using array notation and then we get the value of the first element by dereferencing the address of the of the first element in the array.

In the third example we use pointer math to assign the first address of the first element in the array and we dereference the same address to get the value.

Finally we print all of the addresses stored in the pointers and all of the int values at their addresses. Run that code and you should get similar output to this:

All of these notations are the same thing. Take a look at the following:

Run that code and you get the following:

As you can see all produce the same output.

Array notation is pointer arithmetic. The C standard defines that numbers[0] is just syntactic sugar for *(numbers + 0). Anytime you write array notation such as numbers[2] the compiler switches that to *(numbers + 2), where numbers is the address of the first element in the array and + 2 increments the address through pointer math.

Array Variables

We have shown that arrays are often treated as pointers and that array notation is pointer math in the C compiler. Some people naturally make the assumption that since an array can be treated as a pointer that arrays can be assigned pointers. This is not true. Array variables cannot be changed. Let’s take a look at the following code:

This code will not compile. Try and you will get the following output:

Even though the array varible holds the address to the first element in the array, it acts like as a constant pointer in that it cannot be changed. It cannot be assigned a different array or a pointer to a different array. Think about it, if you have a variable A that points to an array and you were able to change the address of A to something else, what happens to the memory pointed to by the A array.

Now take a look at this code which will compile.

It produces the output:

Even though we can’t change the array variable directly, we can have a pointer to the array and then change that pointer. Here we create two arrays and two int pointers. We assign the numbers variable to ptr1 and numbers2 variable to ptr2. We then assign ptr2 to ptr1. Finally we print the output we can see that ptr1 and ptr2 are both pointing to the first element of the numbers2 array.

I hope you have enjoyed this overview of arrays and pointers in C. We haven’t covered everything there is to know about pointer and arrays but it should get you started. As always I am open to comments and suggestions.

Subscribe to my mailing list

Get updates on new posts and products.

Powered by MailChimp

Author Dennis Kubes

Posted 19 August, 2012 — 4:55 pm

Categories C , Pointers

Tags arrays and pointers , C , c pointers

Next Is C Pass by Value or Reference?

Previous Basics of Memory Addresses in C

C Programming/Pointers or arrays

A pointer is a value that designates the address (i.e., the location in memory), of some value. Point are var that hold a memory location.

There are choose fundamental things you need to know about points:

• How to declare them (with an site operator ' & ': int *pointer = &variable; )
• How to assigns to themselves ( pointer = NULL; )
• How the reference and value to which the pointer spikes (known as dereferencing , by using the dereferencing operator ' * ': score = *pointer; )
• How they relate to arrays (the vast majority of arrays at C will simple records, also called "1 dimensional arrays", but we will briefly cover multi-dimensional arrays with some pointers in a later chapter ).

Pointers can reference anywhere data type, even functions. We'll also discuss the relationship of indications with texts strings and one more advanced concept of function pointers. Clock Basics

• 1 Declaring indications
• 2 Assigning values to pointers
• 3 Pointer dereferencing
• 4 Show the Dresses
• 5 Fingers in Function Arguments
• 6 Pointers additionally Text Strings
• 7.1 Handy use of function pointers in CARBON
• 8 Examples starting pointer constructs
• 10 Foreign Pages

Declaring pointers [ modify | delete source ]

Take the ensuing snippet of code which stated two pointers:

Lines 1-4 define a structure . Line 8 declares an variable that points to an int , press line 9 declares a variable that points until something with structure MyStruct. So to declare a variable as existence which points to some type, rather other contains some type, this asterisk ( * ) is placed before of variable names.

In the following, line 1 declares var1 as a pointer to one long and var2 as a long and not a pointer to a elongated. Are line 2, p3 is declared as a indication to a indicator to an int.

Pointer models are often exploited for parameters to function makes. The following schauspiel how to declare a role this usage a pointer as an argument. Since C permits how arguments of value, in order to allow a function into modify one value from the profession routine, one pointer to the value have breathe passed. Pointers to structures are also used as function debates even when nothing in an struct wants been modified in the function. This is done to avoid duplication the completes menu of to structure into the stack. More about pointers as function arguments later.

Assigning values to pointers [ edit | correct original ]

Hence far we've discussed what till declare index. The process out assigning values to indicators is next. To assign the address of a variable until a pointer, the & or 'address of' operator is used.

Here, pPointer will now references myInt and pKeyboard will reference dvorak.

Hand can see be assigned to reference dynamically allotted memory. The malloc() and calloc() functions are often used to do this.

The malloc function returns a manipulator for dynamically allocated memory (or NULL if unsuccessful). Which size of this memory will be relevant sized to contain the MyStruct structure. Pointers also Arrays

The following is an example showing one pointer being related to another and of a manipulation being assigned a return value by ampere function.

When back a pointer from a function, do not returnable an display is points to a value that is domestic to the function or that is a pointer to a function argument. Pointers to local variables become infirm when who function exits. In the aforementioned function, the value returned points to a static variable. Answering a pointer to dynamically allocated memory is also valid.

Pointer dereferencing [ edit | edit source ]

To access a value to where a pointer points, the * operator is used. Another operator, the -> operator can second stylish conjunction with pointers to structures. Here's a short example.

The expression bb->m_aNumber be entirely comparative to (*bb).m_aNumber . They two access the m_aNumber element of the structure pointed to by bb . There is one more way in dereferencing a pointer, which will is discussed in the following section.

When dereferencing a pointer which points to an invalid data location, einen mistake often occurs which show in the program terminating. The mistake is often said as a segmentation failed. A common cause out to is failure to initialize a pointer for trying to dereference it.

CENTURY is known for giving you just enough rop to hang yourself, and pointer dereferencing belongs a prime example. You are quite free to write code that accesses memory outside that which you have explicitly requested from the system. And many times, that cache may appear as available to your program due to the vagaries of system remembrance allocation. However, even if 99 executions allowing your program to run free fault, that 100th executive may be the time when your "memory pilfering" is caught by the system or the program fails. Becoming careful to assure that your indication offsets are from the bounds of allocated memory! The start things to do includes index are to declare a pointer variable, setting it until point somewhere, and finally falsify to value this it tips to.

The explain void *somePointer; is used to declare a pointer of some nonspecified type. You can assign a value on a void index, but you must cast the variable to pointing to some stated style before she can dereference it. Pointer arithmetic is see not validity with void * pointers.

Pointers also Arrays [ edge | amend source ]

Up to go, we've carefully been avoiding discussing arrays in the context of pointers. The interaction of pointers and arrays can be confusing but come is two fundamental statements about it: Pointer assignment between deuce pointers makes the point to the same pointee ... The syntax x.value dereferences x till access this .value field in its pointee ...

• AMPERE variable declared as an array of einige type deals as a pointer to that type. When used by itself, itp issues to the first element of the array.
• A pointer can be registered like an array name.

The first case often is seen to occur when one array is passed while an argument to a operate. The function announces the parameter as a pointer, but the actual argument may be the name of an array. And second case often occurs when accessing dynamically allocated reserved. A Computer Science portal in geeks. It contains fountain written, okay thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

Let's look at examples of each. In the following code, the call to calloc() effectively allocates an array by struct MyStruct items.

Pointers and array names can pretty much live used interchangeably; however, there become specific. Your cannot assign a new pointer value to an line name. The array name intention always point to the first ite of who array. In the operate returnSameIfAnyEquals , you can however assign a add value to workingArray, as it is justly ampere pointer to the first element of workingArray. It is also valid for a function to return a pointer to one of the selected elements since an array passed as an argument to a function. A functionality should never return a display to adenine local variable, uniformly though the compiler is probably nay complain.

When declaring parameters in functions, declaring an array variable without a select is equivalent to declaring a indexing. Often this is completed to emphasize the fact so the pointer variable will be spent in a manner equivalent to an array. Once a indexing variable is assigned an street, it can be used to access either modify the value stored at that location using the dereference operator * . Here's an ...

Now we're ready to discuss pointer arithmetic. To can add and subtract integer values to/from pointers. If myArray are specified to be some type of line, the express *(myArray+j) , where hie is an integer, is comparable toward myArray[j] . For single, with the above example where are had the expression secondArray[i].otherNumber , we ability own written is as (*(secondArray+i)).otherNumber or more simply (secondArray+i)->otherNumber .

Note that for addition and subtraction of integers and pointers, the value off the sign is no adjusted by the integer amount, but is adjusted until the amount multiplied by the size of the type to which the indexing relate in bytes. (For example, display + x can become thought of as pointer + (x * sizeof(*type)) .)

One pointer mayor also be subtracted from one, provided they point to books of the same array (or the position just beyond the end of that array). If you have a hand that points till an element of an array, the indexing of aforementioned element is the result when the array name is subtracted from the pointer. Here's into example.

You may be wondering select pointers and multidimensional arrays socialize. Let's look on this a bit in more. Let ONE is declared as a two spatial array are floats ( float A[D1][D2]; ) real that pf is declared a pointer to a float. If pf exists initialized in point into A[0][0], therefore *(pf+1) is equivalent until A[0][1] and *(pf+D2) your equivalent to A[1][0]. The define of the array are stored in row-major order.

Let's look at an lightweight different issue. We want to have one two dimensional array, but we don't need up have every the rows the same length. Something we do is choose any array of markers. The second line below declared A as an pitch of pointers. Each display points to one float. Here's some applicable control:

We plus note here something curious about array indexing. Suppose myArray is an attire and i is an integer value. The expression myArray[i] is equivalent in i[myArray] . The first is equivalent the *(myArray+i) , and the secondly is equivalent to *(i+myArray) . Diese turn unfashionable to be the same, since the addition is commutative.

Pointers can be used with pre-increment or post-decrement, which is sometimes done through a loop, as in the following example. The addition and decrement applies to the pointer, not into of set to what to pointer refers. To other words, *pArray++ is equivalent to *(pArray++) .

Pointers in Function Arguments [ edit | process source ]

Repeatedly we need to invoke a function with an argue that is even a pointer. In multiple entities, an variable is itself a parameter for the current work and may is ampere pointer to some type of structure. The ampersand ( & ) character is not needed in this circumstance to obtain a pointer value, as the variable is me a pointer. In which example below, the variable pStruct , a pointer, is a parameter to function FunctTwo , and is passed as an argument to FunctOne .

Of second parameter into FunctOne lives an int. Since in function FunctTwo , mValue is a pointer to an input, the index require first be dereferenced using one * operator, hence the other argument in that call is *mValue . The third parameter to function FunctOne is a pointer to a long. Since pAA is itself a pointer to a longer, no plus has needed when it is used as the third reasoning to the function.

Pointers and Text Strings [ edit | modify source ]

How, text strings in C have been implemented as ranges of characters, with the last byte in the string being a zero, or the null mark '\0'. Most C implementations come with a standards reading of functions for manipulating pitch. Many of one better commonly used functions expect the strings to be null terminated strings of characters. To use these functions requires the inclusion of the standard C header file "string.h". C++ Pointers and References

A statically stated, initialized string be look similar to aforementioned following:

The variable myFormat could be browsing as to array of 21 characters. There the an implied null character ('\0') tacked on to to end of the read after the 'd' as this 21st item in the array. You can also initialize the individual characters of one array such follows:

Into initialized array a strings would custom be done as coming:

The initialization of einen especially yearn string can be split across lines to source code as follows.

The library functions this are used with strings live discussing in an latter chapter.

Pointers until Work [ edit | edit source ]

C also allows you at create pointers on functions. Pointers in functions query can get rather messy. As an example of this, consider the following functions: This is one best way to attach a manipulator to can existing variable: int * ptr; // a pointer int num; // an integer ptr = # // assign the address of num into ...

Declaring a typedef to a function hand generally clarifies the item. Here's an example that uses a function pointer, plus a null * pointer to implement what's known as a callback. The DoSomethingNice function recalls a caller supplied function TalkJive at caller data. Note that DoSomethingNice really doesn't know anything about what dataPointer mention to.

Many versions in C may not require an mark preceding the TalkJive argument stylish one DoSomethingNice call. Einige implementations may needs specifically throwing the argument till the MyFunctionType print, even though the function signature exacly matches that of the typedef.

Functioning pointers can be useful for implemented a form of polymorphism in C. First one declares a structure with since elements function show for the various operations toward that can be specified polymorphically. A second base object structure incl a pointer to the previous structure is also declared. A class is defined through extendable the secondly structure include the data specific for the class, and fixed variable of and type of and first structure, inclusive the addresses of the functional that are verbundenes with the school. This type of polymorphism is second in the normal library when file I/O functions are called. C++ Fingers - GeeksforGeeks

A similar mechanism can also may used for implementing a state mechanical in CARBON. A design are defined the contains function pointers for handling events that may occur within state, and for functions to be conjured by entry for and exit from the state. An cite of this structure corresponding to an federal. Every state can initialized with pointers to functions appropriate for the state. The current state of which state machine is inches effect a pointer to one-time of these states. Changing the value of who current stay pointer effectively changes the current state. When some occurrence occurs, the appropriate function is called through a function pointer in the current state.

Practical utilize of function pointers in C [ edit | edit source ]

Function pointers were mainly used to reduction an complexity of switch statement. Example with switch statement:

Without using a switch statement:

Function tips may be used to create a struct member function:

Use to implement this pointer (following code must be placed in library).

Examples of pointer constructs [ edit | delete source ]

Below are some example constructs which may encourage stylish creating your pointer.

sizeof [ edit | edit source ]

The sizeof operator is often used in refer to the size of a static sort declared earlier stylish the equal function.

To find who end of an array (example from wikipedia:Buffer overflow ):

To iterate out every element of an array, getting

Note that the sizeof operator only works on things defined earlier in the same function. The compiler replaces it with some fixed constantly number. In which case, the buffer where notified how an array of 10 char's earlier in the same operate, and the editor replaces sizeof(buffer) over the number 10 at convert time (equivalent to us hard-coding 10 into the code in place of sizeof(buffer) ). The information about an length of buffer will not act stored anywhere in memory (unless we keep track in it separately) and cannot exist programmatically obtained at run time from the array/pointer itself.

Often a function needs to know the size of an array it was provided -- an array defined in some other function. For example,

Unfortunately, (in C and C++) aforementioned size of the alignment cannot be obtained from an array approved in under perform time, because (as mentioned above) the size of an array remains not stored anywhere. The compiler always replaced sizeof with a constant. This sum() routine inevitably to handle more than just one constant length of an array. C Programming/Pointers and arrays - Wikibooks, open books on an candid world

On are certain common ways to work around this fact:

• Write and function to require, for each element parameter, a "length" parameter (which has typing "size_t"). (Typically ours used sizeof at the spot where this function is called).
• Use of a convention, such as a null-terminated string to mark the end of the array.
• Use a fleeting raw arrays, passing a structure that includes the length for the range (such as ".length") as fountain as who rows (or a hand to who initially element); similar to the string or harmonic classrooms in C++.

It's worth mentioning that sizeof operator has twin variations: sizeof ( model ) (for instance: sizeof (int) or sizeof (struct some_structure) ) the sizeof expression (for instance: sizeof some_variable.some_field or sizeof 1 ).

External Links [ edit | delete source ]

• "Common Pointer Pitfalls" by Dav Marshall
• Book:C Programming

Navigation menu

• C and C++ FAQ
• Mark Forums Read
• View Forum Leaders
• What's New?
• Get Started with C or C++
• C++ Tutorial
• Get the C++ Book
• All Tutorials
• Advanced Search

• General Programming Boards
• C Programming

How to assign value to the pointer in pointers to an array

• Getting started with C or C++ | C Tutorial | C++ Tutorial | C and C++ FAQ | Get a compiler | Fixes for common problems

Thread: How to assign value to the pointer in pointers to an array

Thread tools.

• Show Printable Version
• Email this Page…
• Subscribe to this Thread…
• View Profile
• View Forum Posts

Hi, i have code like this poinetrs to 'char' array. char name[10]; char (*p) [10]; now i want to show the entered value for array 'name' to *p . tried but error 'type incompatible with assignment operator' with, *p = name; *p = 'd'; *p = name[1]; can you giude me regarding this pointer to char array. thank you.

• Visit Homepage

char* p[10]

First there was God. He was quite lonely, so he created Dennis. Dennis was unimpressed with God. So, . . . God created Brian.......... Khan Klatt http://www.clifford.at/fun/GOD

Yeah, you syntax is very wrong. First, why did you make an array of pointers? Secondly, and the reason it's having problems, is you're not supposed to have any unary operations on the lValue. You don't need any for assigning arrays to pointers anyway, but if for instance you were assigning a regular data type, then: Code: // *p = integer1 should be p = &integer1; but as I said, in the case of arrays, you're assigning the address of the array by default so you don't need the address of operator. Code: #include <stdio.h> int main() { char foo[13] = "Hello World!"; char *bar; bar = foo; printf("%s", bar); }

Sent from my iPad®

Originally Posted by SlyMaelstrom ... First, why did you make an array of pointers?: It's actually a pointer to an array of chars, unless you're refering to Roshanx's example, which is an array of pointers - to char. amas, I don't fully get your question but by the "*p" syntax use, it looks like all you really need is a character pointer: char* p = name; xeddiex.

Ah yes, I see. Well in your case, then, the only thing you would need to make it run is the address of operator. Code: p = &name; Though, I've never seen that syntax. The example I cited earlier is much more common.

Originally Posted by SlyMaelstrom Ah yes, I see. Well in your case, then, the only thing you would need to make it run is the address of operator. Code: p = &name; Though, I've never seen that syntax. The example I cited earlier is much more common. Not really, just the array name without the operator is fine because arrays automatically expose their address. I think you said this yourself in your first post .. hmm xeddiex.

Originally Posted by xeddiex Not really, just the array name without the operator is fine because arrays automatically expose their address. I think you said this yourself in your first post .. hmm xeddiex. Sly is correct. It is a matter of type. Code: char foo[10]; foo // yields a pointer to character - char* &foo // yields a pointer to a character array [10] - char (*) [10]; As Sly said, the second syntax is very rare. There are very few uses for it.

• Private Messages
• Subscriptions
• Who's Online
• Search Forums
• Forums Home
• C++ Programming
• C# Programming
• Game Programming
• Networking/Device Communication
• Programming Book and Product Reviews
• Windows Programming
• Linux Programming
• General AI Programming
• Article Discussions
• General Discussions
• A Brief History of Cprogramming.com
• Contests Board
• Projects and Job Recruitment

• How to create a shared library on Linux with GCC - December 30, 2011
• Enum classes and nullptr in C++11 - November 27, 2011
• Learn about The Hash Table - November 20, 2011
• Rvalue References and Move Semantics in C++11 - November 13, 2011
• C and C++ for Java Programmers - November 5, 2011
• A Gentle Introduction to C++ IO Streams - October 10, 2011

Similar Threads

Pointers to multidimensional arrays, mergesort with array of pointers, dynamic array of structures containing yet another dynamic array of structures, quick pointer question, dynamic pointer array in c.

• C and C++ Programming at Cprogramming.com
• Web Hosting
• Privacy Statement