c int array assignment

Integer Array in C – How to Declare Int Arrays with C Programming

In this article, you will learn how to work with arrays in C.

I will first explain how to declare and initialize arrays.

Then, I will also go over how to access and change items in an array in C with the help of code examples along the way.

Let's get into it!

What Is An Array in C Programming?

An array is a data structure that stores multiple values in a single variable and in a sequential order that is easily accessible.

Arrays in C are a collection of values that store items of the same data type – an integer array holds only elements of the type int , a float array holds only elements of the type float , and so on.

How to Declare an Integer Array in C Programming

The general syntax for declaring an array in C looks as you can see it in the code snippet below:

Let's take the following example:

Let's break it down:

I first defined the data type of the array, int .
I then specified the name, my_numbers , followed by a pair of opening and closing square brackets, [] .
Inside the square brackets, I defined the size ( 5 ), meaning the array can hold 5 integer values.
Finally, I ended the statement with a semicolon ( ; ).

Once you have set the array type and size during declaration, the array can't hold items of another type.

The array is also fixed in size, meaning you cannot add or remove items.

How to Initialize an Integer Array in C Programming

There are a couple of ways you can initialize an integer array in C.

The first way is to initialize the array during declaration and insert the values inside a pair of opening and closing curly braces, {} .

The general syntax to do that looks like this:

Let's take the array I declared in the previous section that can hold five integers and initialize it with some values:

In the example above, I placed five comma-separated values inside curly braces, and assigned those values to my_numbers through the assignment operator ( = ).

Something to note here is that when you specify the size of the array, you can assign less number of elements, like so:

Although the size of the array is 5 , I only placed three values inside it.

The array can hold two more items, and those remaining two positions have a default value of 0 .

Another way to initialize an array is to not specify the size, like so:

Even though I did not set the size of the array, the compiler knows its size because it knows the number of items stored inside it.

How to Access Items in an Integer Array in C Programming

To access an element in an array, you have to specify the index of the element in square brackets after the array name.

The syntax to access an element looks like this:

In C and programming in general, an array index always starts at 0 , becuase in computer science, counting starts from 0 .

So, the first item in an array has an index of 0 , the second item has an index of 1 , the third item has an index of 2 , and so on.

Taking the same array from the previous section, here is how you would access the first element, that is, 10 :

Keep in mind that the last element in an array has an index of array_size -1 – it is always one less than the size of the array. So, in an array that holds five elements, the index of the last element is 4 .

If in an array of five items, you try to access the last element by using an index of 5 , the program will run, but the element is not available, and you will get undefined behavior:

How to Change Items in an Integer Array in C Programming

To change the value of a specific element, specify its index number and, with the assignment operator, = , assign a new value:

In the example above, I changed the first item in the array from 10 to 11 .

And there you have it! You now know the basics of working with arrays in C.

To learn more about C, give this C beginner's handbook a read to become familiar with the basics of the language.

Thanks for reading, and happy coding!

C Fundamentals

C Variables, Constants and Literals
C Data Types
C Input Output (I/O)
C Programming Operators

C Flow Control

C if...else Statement
C while and do...while Loop
C break and continue
C switch Statement
C goto Statement
C Functions
C User-defined functions
Types of User-defined Functions in C Programming
C Recursion
C Storage Class

C Programming Arrays

C Multidimensional Arrays

Pass arrays to a function in C

C Programming Pointers

Relationship Between Arrays and Pointers

C Pass Addresses and Pointers
C Dynamic Memory Allocation
C Array and Pointer Examples
C Programming Strings
String Manipulations In C Programming Using Library Functions
String Examples in C Programming

C Structure and Union

C structs and Pointers
C Structure and Function

C Programming Files

C File Handling

C Files Examples

C Additional Topics

C Keywords and Identifiers
C Precedence And Associativity Of Operators
C Bitwise Operators
C Preprocessor and Macros
C Standard Library Functions

C Tutorials

Find Largest Element in an Array
Calculate Average Using Arrays
Access Array Elements Using Pointer
Add Two Matrices Using Multi-dimensional Arrays

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

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.

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

Arrays in C

C - Properties of Array
C - Multi-Dimensional Arrays
C - Passing Arrays to Function
C - Return Array from Function
C - Variable Length Arrays
Pointers in C
C - Pointers
C - Pointers and Arrays
C - Applications of Pointers
C - Pointer Arithmetics
C - Array of Pointers
C - Pointer to Pointer
C - Passing Pointers to Functions
C - Return Pointer from Functions
C - Function Pointers
C - Pointer to an Array
C - Pointers to Structures
C - Chain of Pointers
C - Pointer vs Array
C - Character Pointers and Functions
C - NULL Pointer
C - void Pointer
C - Dangling Pointers
C - Dereference Pointer
C - Near, Far and Huge Pointers
C - Initialization of Pointer Arrays
C - Pointers vs. Multi-dimensional Arrays
Strings in C
C - Strings
C - Array of Strings
C - Special Characters
C Structures and Unions
C - Structures
C - Structures and Functions
C - Arrays of Structures
C - Self-Referential Structures
C - Lookup Tables
C - Dot (.) Operator
C - Enumeration (or enum)
C - Structure Padding and Packing
C - Nested Structures
C - Anonymous Structure and Union
C - Bit Fields
C - Typedef
File Handling in C
C - Input & Output
C - File I/O (File Handling)
C Preprocessors
C - Preprocessors
C - Pragmas
C - Preprocessor Operators
C - Header Files
Memory Management in C
C - Memory Management
C - Memory Address
C - Storage Classes
Miscellaneous Topics
C - Error Handling
C - Variable Arguments
C - Command Execution
C - Math Functions
C - Static Keyword
C - Random Number Generation
C - Command Line Arguments
C Programming Resources
C - Questions & Answers
C - Quick Guide
C - Cheat Sheet
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

Arrays in C are a kind of data structure that can store a fixed-size sequential collection of elements of the same data type . Arrays are used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.

What is an Array in C?

An array in C is a collection of data items of similar data type. One or more values same data type, which may be primary data types (int, float, char), or user-defined types such as struct or pointers can be stored in an array. In C, the type of elements in the array should match with the data type of the array itself.

The size of the array, also called the length of the array, must be specified in the declaration itself. Once declared, the size of a C array cannot be changed. When an array is declared, the compiler allocates a continuous block of memory required to store the declared number of elements.

Why Do We Use Arrays in C?

Arrays are used to store and manipulate the similar type of data.

Suppose we want to store the marks of 10 students and find the average. We declare 10 different variables to store 10 different values as follows −

These variables will be scattered in the memory with no relation between them. Importantly, if we want to extend the problem of finding the average of 100 (or more) students, then it becomes impractical to declare so many individual variables.

Arrays offer a compact and memory-efficient solution. Since the elements in an array are stored in adjacent locations, we can easily access any element in relation to the current element. As each element has an index, it can be directly manipulated.

Example: Use of an Array in C

To go back to the problem of storing the marks of 10 students and find the average, the solution with the use of array would be −

Run the code and check its output −

Array elements are stored in contiguous memory locations. Each element is identified by an index starting with "0". The lowest address corresponds to the first element and the highest address to the last element.

Declaration of an Array in C

To declare an array in C, you need to specify the type of the elements and the number of elements to be stored in it.

Syntax to Declare an Array

The "size" must be an integer constant greater than zero and its "type" can be any valid C data type. There are different ways in which an array is declared in C.

Declaring an Uninitialized Array

In such type of declaration, the uninitialized elements in the array may show certain random garbage values.

Example: Declaring an Array in C

In the following example, we are declaring an array of 5 integers and printing the indexes and values of all array elements −

Initialization of an Array in C

At the time of declaring an array, you can initialize it by providing the set of comma-separated values enclosed within the curly braces {}.

Syntax to Initialize an Array

If a set of comma-separated sequence values put inside curly brackets is assigned in the declaration, the array is created with each element initialized with their corresponding value.

Example to Initialize an Array

The following example demonstrates the initialization of an integer array:

Example of Initializing all Array Elements to 0

To initialize all elements to 0, put it inside curly brackets

When you run this code, it will produce the following output −

Example of Partial Initialization of an Array

If the list of values is less than the size of the array, the rest of the elements are initialized with "0".

Example of Partial and Specific Elements Initialization

If an array is partially initialized, you can specify the element in the square brackets.

On execution, it will produce the following output −

Getting Size of an Array in C

The compiler allocates a continuous block of memory. The size of the allocated memory depends on the data type of the array.

Example 1: Size of Integer Array

If an integer array of 5 elements is declared, the array size in number of bytes would be "sizeof(int) x 5"

On execution, you will get the following output −

The sizeof operator returns the number of bytes occupied by the variable.

Example 2: Adjacent Address of Array Elements

The size of each int is 4 bytes. The compiler allocates adjacent locations to each element.

In this array, each element is of int type. Hence, the 0th element occupies the first 4 bytes 642016 to 19. The element at the next subscript occupies the next 4 bytes and so on.

Example 3: Array of Double Type

If we have the array type of double type, then the element at each subscript occupies 8 bytes

Example 4: Size of Character Array

The length of a "char" variable is 1 byte. Hence, a char array length will be equal to the array size.

Accessing Array Elements in C

Each element in an array is identified by a unique incrementing index, stating with "0". To access the element by its index, this is done by placing the index of the element within square brackets after the name of the array.

The elements of an array are accessed by specifying the index (offset) of the desired element within the square brackets after the array name. For example −

The above statement will take the 10th element from the array and assign the value to the "salary".

Example to Access Array Elements in C

The following example shows how to use all the three above-mentioned concepts viz. declaration, assignment, and accessing arrays.

On running this code, you will get the following output −

The index gives random access to the array elements. An array may consist of struct variables, pointers and even other arrays as its elements.

More on C Arrays

Arrays, being an important concept in C, need a lot more attention. The following important concepts related to arrays should be clear to a C programmer −

Sr.No	Concept & Description
1	C supports multidimensional arrays. The simplest form of an multidimensional array is the two-dimensional array.
2	You can pass to the function a pointer to an array by specifying the array's name without an index.
3	C allows a function to return an array.
4	You can generate a pointer to the first element of an array by simply specifying the array name, without any index.

C Functions

C structures, c reference.

Arrays are used to store multiple values in a single variable, instead of declaring separate variables for each value.

To create an array, define the data type (like int ) and specify the name of the array followed by square brackets [] .

To insert values to it, use a comma-separated list, inside curly braces:

We have now created a variable that holds an array of four integers.

Access the Elements of an Array

To access an array element, refer to its index number .

Array indexes start with 0 : [0] is the first element. [1] is the second element, etc.

This statement accesses the value of the first element [0] in myNumbers :

Change an Array Element

To change the value of a specific element, refer to the index number:

Loop Through an Array

You can loop through the array elements with the for loop.

The following example outputs all elements in the myNumbers array:

Set Array Size

Another common way to create arrays, is to specify the size of the array, and add elements later:

Using this method, you should know the number of array elements in advance, in order for the program to store enough memory.

You are not able to change the size of the array after creation.

C Exercises

Test yourself with exercises.

Create an array of type int called myNumbers .

Start the Exercise

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]

15.13 Structure Assignment

Assignment operating on a structure type copies the structure. The left and right operands must have the same type. Here is an example:

Notionally, assignment on a structure type works by copying each of the fields. Thus, if any of the fields has the const qualifier, that structure type does not allow assignment:

See Assignment Expressions .

When a structure type has a field which is an array, as here,

structure assigment such as r1 = r2 copies array fields’ contents just as it copies all the other fields.

This is the only way in C that you can operate on the whole contents of a array with one operation: when the array is contained in a struct . You can’t copy the contents of the data field as an array, because

would convert the array objects (as always) to pointers to the zeroth elements of the arrays (of type struct record * ), and the assignment would be invalid because the left operand is not an lvalue.

Stack Exchange Network

Stack Exchange network consists of 183 Q&A communities including Stack Overflow , the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Why does C not support direct array assignment?

In C you cannot assign arrays directly.

At first I thought this might because the C facilities were supposed to be implementable with a single or a few instructions and more complicated functionality was offloaded to standard library functions. After all using memcpy() is not that hard. However, one can directly assign structures/unions which can be arbitrarily sized, and can even contain arrays.

What is/was the reasoning for allowing structures/unions to be directly assigned but not arrays, if the former can contain arrays anyway? We can only assign arrays directly if they are wrapped in a structure/union, so my aforementioned hypothesis as to why this is the case is out.

Because language features are unimplemented by default . – Doc Brown Commented May 4, 2023 at 5:59

2 Answers 2

It is arguably a shortcoming, due to missing features around arrays, but one the original designers choose not to resolve. Add in the (over) emphasis on pointers and pointer arithmetic and keeping track of these things yourself as would be done in assembly.

Arrays in C don't really have sizes. Yes, you can int A[100]; ... sizeof(A) ... for a declared array, but once A is used in an expression, its type is immediately converted to pointer to element (here int* ) and the original array's size is lost. This is particularly evident with parameters where an array is passed.

There's not even a convenient built-in for length (e.g. say, lengthof ) that would work for arrays of any element size — instead we have to write something like (sizeof(A)/sizeof(*A)) .

A lot of code in C relies on use of pointers where length is kept by the program using other variables or knowledge rather than having the language keep track.

Often, declaring an array in a struct/union as a last member is secret code for variable length. See for example:

I can't say for sure but apparently resolving the short comings only for declared arrays but not for pointers seemed not all that useful. So, some larger built in length mechanism would have been required for general use with pointers.

Still, something could have been done, say by having some syntax that allows the user to specify a number of elements — like A = B[0:n] or A[0:n] = B or some other variant — but they simply stopped short of that, leaving it for memcpy and memmove . Let's also note that when you choose between memcpy and memmove , with the former you're saying that the source and destination do not overlap, whereas with memmove you're saying they might overlap so backwards copying of the elements may be better than forwards (and it will check at runtime).

So, the various problems:

pointer oriented rather than array oriented
no implicit size information on pointers
aliasing issues
fixed sized arrays are only useful in narrow contexts

I think punting to the standard library was pretty reasonable here, plus as you note for fixed sized arrays, we can wrap them in a struct/union..

C originally came from a predecessor language called B, made by Ken Thompson . In B, there were no types. Everything was a "word" (basically, an int ).

In B, arrays were just pointers to the first element. If you declared an array:

This would allocate 10 words on the stack (to be freed automatically when the function returned, thus auto ), and arr would be a pointer to the first one.

When the type system was added, Dennis Ritchie didn't want any existing code to break. This is why, for example, on early versions of C if you omitted the type it would default to int . It's also where pointer decay (array arguments to functions being just pointers) came from.

For this reason, arrays ended up being a second-class citizen in C for a long time. Because of the stability of the language, even the more modern C standards (like C23 which is supposed to come out this year) have to try to fix it without breaking anything, and this particular issue (copying arrays) is not really a priority, because you rarely actually want to copy an array (especially a large one).

Source: The Development of the C language

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Software Engineering Stack Exchange. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged c array unions struct or ask your own question .

The Overflow Blog
Looking under the hood at the tech stack that powers multimodal AI
Featured on Meta
User activation: Learnings and opportunities
Preventing unauthorized automated access to the network

Hot Network Questions

How to achieve 24t-38t front chainrings
PCB design references and roadmap
Can noun phrases have only one word?
Big bang and the horizon problem
How safe is the runastool.exe, any known issues?
"First et al.", many authors with same surname, and IEEE citations
How uncommon/problematic is a passport whose validity period (period between issue and expiry) is a non-whole number of years?
Writing in first person for fiction novel, how to portray her inner dialogue and drag it out to make a chapter long enough?
Returning to the US for 2 weeks after a short stay around 6 months prior with an ESTA but a poor entry interview - worried about visiting again
Can I have multiple guardians of faith?
Does General Relativity predict Mercury's orbital precession without other planets?
If directly exposed to the vacuum of space, what would be the effects on a womans reproductive system?
What are some limitations of this learning method?
Does it ever make sense to have a one-to-one obligatory relationship in a relational database?
Establishing Chirality For a 4D Person?
Superuser and Sudo not working on Debian 12
In The Martian, what does Mitch mean when he is talking to Teddy and says that the space program is not bigger than one person?
Why a relay frequently clicks when a battery is low?
How am I supposed to solder this tiny component with pads UNDER it?
Consequences of registering a PhD at german university?
How to translate the letter Q to Japanese?
Change of variable, u = y/x
Parameters of the sampling distribution of the sample proportion
How to assign a definition locally?

cppreference.com

Std:: array.







(C++20)

(C++20)
(C++11)





(C++20)




(C++17)
(C++11)
(C++11)






























Tables










array::cbegin
array::cend
array::crbegin
array::crend











operator!=operator<operator>operator<=operator>=operator<=> (C++11)(until C++20)(C++11)(until C++20)(C++11)(until C++20)(C++11)(until C++20)(C++11)(until C++20)(C++20)



(C++17)


< class T, N > struct array;		(since C++11)

std::array is a container that encapsulates fixed size arrays.

This container is an aggregate type with the same semantics as a struct holding a C-style array T [ N ] as its only non-static data member. Unlike a C-style array, it doesn't decay to T * automatically. As an aggregate type, it can be initialized with aggregate-initialization given at most N initializers that are convertible to T : std :: array < int , 3 > a = { 1 , 2 , 3 } ; .

The struct combines the performance and accessibility of a C-style array with the benefits of a standard container, such as knowing its own size, supporting assignment, random access iterators, etc.

std::array satisfies the requirements of Container and ReversibleContainer except that default-constructed array is not empty and that the complexity of swapping is linear, satisfies the requirements of ContiguousContainer , (since C++17) and partially satisfies the requirements of SequenceContainer .

There is a special case for a zero-length array ( N == 0 ). In that case, array. begin ( ) == array. end ( ) , which is some unique value. The effect of calling front ( ) or back ( ) on a zero-sized array is undefined.

An array can also be used as a tuple of N elements of the same type.

Iterator invalidation Template parameters Member types Member functions Implicitly-defined member functions Element access Iterators Capacity Operations Non-member functions Helper classes Deduction guides Example See also

[ edit ] Iterator invalidation

As a rule, iterators to an array are never invalidated throughout the lifetime of the array. One should take note, however, that during swap , the iterator will continue to point to the same array element, and will thus change its value.

[ edit ] Template parameters

T	-	element type Must be and .
N	-	the number of elements in the array or 0.

This section is incomplete
Reason: Complete the descriptions of template parameters.

[ edit ] Member types

Member type

Definition

value_type&

const value_type&

value_type*

const value_type*

and to	(until C++17)
and that is a to	(since C++17) (until C++20)
, , and to	(since C++20)

and to const value_type	(until C++17)
and that is a to const value_type	(since C++17) (until C++20)
, , and to const value_type	(since C++20)

[ edit ] Member functions


	initializes the array following the rules of (note that default initialization may result in indeterminate values for non-class ) (public member function)
	destroys every element of the array (public member function)
	overwrites every element of the array with the corresponding element of another array (public member function)

	access specified element with bounds checking (public member function)
	access specified element (public member function)
	access the first element (public member function)
	access the last element (public member function)
	direct access to the underlying contiguous storage (public member function)

cbegin	returns an iterator to the beginning (public member function)
cend	returns an iterator to the end (public member function)
crbegin	returns a reverse iterator to the beginning (public member function)
crend	returns a reverse iterator to the end (public member function)

	checks whether the container is empty (public member function)
	returns the number of elements (public member function)
	returns the maximum possible number of elements (public member function)

	fill the container with specified value (public member function)
	swaps the contents (public member function)

[ edit ] Non-member functions

operator!=operator<operator<=operator>operator>=operator<=> (C++11)(removed in C++20)(C++11)(removed in C++20)(C++11)(removed in C++20)(C++11)(removed in C++20)(C++11)(removed in C++20)(C++20)	lexicographically compares the values of two s (function template)
	accesses an element of an (function template)
	specializes the algorithm (function template)
	creates a object from a built-in array (function template)

[ edit ] Helper classes

	obtains the size of an (class template specialization)
	obtains the type of the elements of (class template specialization)

(since C++17)

[ edit ] Example

[ edit ] see also.

	dynamically-resizable, fixed capacity, inplace contiguous array (class template)
	dynamic contiguous array (class template)
	double-ended queue (class template)
	creates a object whose size and optionally element type are deduced from the arguments (function template)

Todo with reason
Recent changes
Offline version
What links here
Related changes
Upload file
Special pages
Printable version
Permanent link
Page information
In other languages
This page was last modified on 2 August 2024, at 22:20.
Privacy policy
About cppreference.com
Disclaimers

Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
OverflowAI GenAI features for Teams
OverflowAPI Train & fine-tune LLMs
Labs The future of collective knowledge sharing
About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Array Assignment [duplicate]

Let me explain with an example -

Is it because, array decays to a pointer when passed to a function foo(..) , assignment operation is possible. And in main , is it because they are of type int[] which invalidates the assignment operation. Doesn't a,b in both the cases mean the same ? Thanks.

When I do it in a function foo , it's assigning the b's starting element location to a . So, thinking in terms of it, what made the language developers not do the same in main() . Want to know the reason.

Same reason why sizeof(a) differs in those locations: I don't know :) – Tugrul Ates Commented Mar 11, 2011 at 22:36
Array to pointer conversion is tricky. Read this if you feel like it : c-faq.com/aryptr/index.html – fouronnes Commented Mar 11, 2011 at 22:40
2 Don't use arrays in C++, unless you have a very good reason to do so. std::vector<> will do almost everything you want. – David Thornley Commented Mar 11, 2011 at 22:51
@David Thornley - Just out of curiosity asked the question, which is a bit related to another post stackoverflow.com/questions/5278540/… – Mahesh Commented Mar 11, 2011 at 23:10
related FAQ – fredoverflow Commented Mar 12, 2011 at 9:34

3 Answers 3

You answered your own question.

Because these

have type of int[2] . But these

have type of int* .

You can copy pointers but cannot copy arrays.

1 also worth noting that the a = b inside the function does not affect the actual arrays outside the function. – Tim Commented Mar 11, 2011 at 22:41
By the way, to achieve copy semantics with arrays a possible solution is to wrap them in a struct or in a class: the default copy constructor & assignment operator will do the trick. But in that case you will probably want to use directly the std::array template. – Matteo Italia Commented Mar 11, 2011 at 22:41
@ybungalobill - When I do it in a function foo , it's assigning the b's starting element location to a . So, thinking in terms of it, what made the language developers not do the same in main() . Want to know the reason. Thanks. – Mahesh Commented Mar 11, 2011 at 22:42
@Matteo: even better: use std::vector. – Yakov Galka Commented Mar 11, 2011 at 22:43
1 @Mahesh: this syntax came from C, and C language developers though of C as a set of macros for assembly, so from their point of view these were just pointers. Note that in main no pointers are involved, so there is nothing to copy, while f receives pointers as parameters on the machine level. – Yakov Galka Commented Mar 11, 2011 at 22:46

The answer is in the concept "pass by value", which means that the called function receives copies of the arguments -- which are pointers to ints. So a and b are local copies of those pointers (which don't exist in the caller; they were the results of conversions from the arrays, that is, the addresses of their first elements). It would be no different if you wrote

Dennis Ritchie has acknowledged that the array syntax for parameters is a wart on the language, and was only there to ease conversion of B programs -- ancient history! It also had a deleterious effect on the design of C++, because arrays cannot be passed by value. This syntax is a constant source of confusion. So ... don't use it ; pretend it's not legal. If everyone does that, it can fade away and maybe in a few decades can be given proper semantics.

Update : For more information on call-by-value (the only form of call in C and Java; see my comments below), call-by-reference (added in C++), and other evaluation strategies, see http://en.wikipedia.org/wiki/Evaluation_strategy

pass by value isn't a correct term to use, when arrays are passed. Its pass by reference . – Mahesh Commented Mar 11, 2011 at 23:05
1 @Mahesh You're quite mistaken. It is possible for arrays, like anything else, to be passed either by reference or by value; the fact that you are not familiar with languages in which arrays can be passed by value does not mean that they can't be. If it weren't for the C array-parameters-are-pointers botch, it would be quite possible to pass small arrays on the stack, just as structs can be passed on the stack. This is quite obvious if you just think about it for a moment. – Jim Balter Commented Mar 12, 2011 at 0:02
@Mahesh P.S. It is common for people to be confused by the fact that references are passed by value in languages like Java, which is a pure pass-by-value system, or in C by passing pointers. Pass-reference-by-value is a quite different thing from pass-by-reference. For a detailed discussion of this point, see javadude.com/articles/passbyvalue.htm – Jim Balter Commented Mar 12, 2011 at 0:07

In the main function a and b are constant pointers actually they are the address of the first elements. They are like l-value. you cannot copy to l-value but you can change the value of the integers they point to.

In the foo function a and b are pointers. so you can change their values.

a and b are not constant pointers in the main function, they are arrays . Pointers and arrays are not the same thing. The immediately obvious difference is that the value of sizeof(a) and a+n are not what they would be if a were a pointer. – Jim Balter Commented Mar 11, 2011 at 23:07
Arrays are not pointers -- read the standard. and I have no idea what your equation is supposed to signify, but int a[2] is allocated on the stack and is destroyed when exiting the scope, whereas new int[] is on the heap ... and your second a is a array of pointers to int . – Jim Balter Commented Mar 12, 2011 at 7:46
Arrays are constant pointers. "int a[2]" is the same as "int const * a[] = new int[2]". and regarding sizeof, it's because the compiler keeps track of all array and deals within itdifferently – Bander Commented Mar 12, 2011 at 8:19
@jim, just to clarify . I know that int a[] will be allocated in stack whereas int const * a[] = new int[2] will be in heap .. that's an essential concept in c++ ... i was just trying to simplify the reason . anyway thinks – Bander Commented Mar 12, 2011 at 17:22

Not the answer you're looking for? Browse other questions tagged c++ arrays or ask your own question .

The Overflow Blog
Looking under the hood at the tech stack that powers multimodal AI
Featured on Meta
User activation: Learnings and opportunities
Preventing unauthorized automated access to the network
What does a new user need in a homepage experience on Stack Overflow?
Announcing the new Staging Ground Reviewer Stats Widget

Hot Network Questions

Emergency belt repair
What's "jam" mean in "The room reeled and he jammed his head down" (as well as the sentence itself)?
Is it possible to monitor the current drawn by a computer from an outlet on the computer?
Does it ever make sense to have a one-to-one obligatory relationship in a relational database?
How much would you trust a pre-sales inspection from a "captured" mechanic?
corresponding author not as the last author in physics or engineering
Hungarian Immigration wrote a code on my passport
Smallest prime q such that concatenation (p+q)"q is a prime
Would a material that could absorb 99.5% of light be able to protect someone from Night Vision?
Consequences of registering a PhD at german university?
Can I have multiple guardians of faith?
Writing in first person for fiction novel, how to portray her inner dialogue and drag it out to make a chapter long enough?
Why believe in the existence of large cardinals rather than just their consistency?
Can noun phrases have only one word?
Can a 20A circuit mix 15A and 20A receptacles, when a 20A is intended for occassional space heater use?
Big bang and the horizon problem
How do exchange mail enabled security groups handle emails to multiple groups with overlapping members?
"First et al.", many authors with same surname, and IEEE citations
How can "chemical-free" surface cleaners work?
string quartet + chamber orchestra + symphonic orchestra. Why?
Is "Canada's nation's capital" a mistake?
Does the collapse axiom predict non-physical states in the case of measurement of continuous-spectrum quantities?
CC BY-SA 2.5 License marked as denied license in the FOOSA tool after upgrading to React Native 0.74 version
Enter a personal identification number

C Data Types
C Operators
C Input and Output
C Control Flow
C Functions
C Preprocessors
C File Handling
C Cheatsheet
C Interview Questions

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

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

What is a Pointer in C?

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

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

Syntax of C Pointers

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

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

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

How to Use Pointers?

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

Pointer Declaration
Pointer Initialization
Pointer Dereferencing

1. Pointer Declaration

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

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

2. Pointer Initialization

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

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

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

3. Pointer Dereferencing

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

Dereferencing a Pointer in C

C Pointer Example

Types of pointers in c.

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

1. Integer Pointers

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

These pointers are pronounced as Pointer to Integer.

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

2. Array Pointer

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

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

3. Structure Pointer

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

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

4. Function Pointers

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

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

5. Double Pointers

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

Dereferencing Double Pointer

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

6. NULL Pointer

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

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

7. Void Pointer

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

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

8. Wild Pointers

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

9. Constant Pointers

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

10. Pointer to Constant

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

Other Types of Pointers in C:

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

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

Size of Pointers in C

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

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

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

How to find the size of pointers in C?

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

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

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

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

C Pointer Arithmetic

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

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

C Pointers and Arrays

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

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

Example 1: Accessing Array Elements using Pointer with Array Subscript

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

Example 2: Accessing Array Elements using Pointer Arithmetic

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

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

Uses of Pointers in C

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

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

Advantages of Pointers

Following are the major advantages of pointers in C:

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

Disadvantages of Pointers

Pointers are vulnerable to errors and have following disadvantages:

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

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

FAQs on Pointers in C

Q1. define pointers..

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

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

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

Q3. What is pointer to pointer?

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

Q4. Does pointer size depends on its type?

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

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

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

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

Type specification in pointer declaration helps the compiler in dereferencing and pointer arithmetic operations.

Quiz on Pointer Basics
Quiz on Advanced Pointer

Please Login to comment...

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

IMAGES

Array in C Programming: Here's How to Declare and Initialize Them?
C# Arrray: An Introductory Guide for Getting Started
C Arrays
Initialize An Array With User Input
An Easy Guide to Understand the C++ Array [Updated]
Arrays in C++

VIDEO

C Programming Tutorial
A2 Class Recording: Array Assignment Solving (Part 1)
Chapter 7 IT Series part 1
C++/C programming tutorial 6: Array
C Array Lab Assignment: Data Structure
Array

COMMENTS

C array declaration and assignment?
Why does C++ support memberwise assignment of arrays within structs, but not generally? Arrays are not pointers. x here does refer to an array, though in many circumstances this "decays" (is implicitly converted) to a pointer to its first element. Likewise, y too is the name of an array, not a pointer. You can do array assignment within structs:
Integer Array in C
The general syntax for declaring an array in C looks as you can see it in the code snippet below: data_type array_name[array_size]; Let's take the following example: int my_numbers[5]; Let's break it down: I first defined the data type of the array, int. I then specified the name, my_numbers, followed by a pair of opening and closing square ...
C Arrays (With Examples)
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.. Declare an Array Few keynotes:
How do you assign all elements of an array at once?
There is a difference between initialization and assignment. What you want to do is not initialization, but assignment. But such assignment to array is not possible in C++. Here is what you can do: #include <algorithm>. int array [] = {1,3,34,5,6}; int newarr [] = {34,2,4,5,6}; std::ranges::copy(newarr, array); // C++20.
C Arrays
Initialization in C is the process to assign some initial value to the variable. When the array is declared or allocated memory, the elements of the array contain some garbage value. ... Consider the following C-function in which a[n] and b[m] are two sorted integer arrays and c[n + m] be another integer array. C/C++ Code void xyz(int a[], int ...
Arrays in C
An array in C is a collection of data items of similar data type. One or more values same data type, which may be primary data types (int, float, char), or user-defined types such as struct or pointers can be stored in an array. In C, the type of elements in the array should match with the data type of the array itself.
Array declaration
Arrays of constant known size can use array initializers to provide their initial values: int a [5]={1, 2, 3};// declares int [5] initialized to 1,2,3,0,0char str []="abc";// declares char [4] initialized to 'a','b','c','\0'. In function parameter lists, additional syntax elements are allowed within the array declarators: the keyword static and ...
Array initialization
Initialization from strings. String literal (optionally enclosed in braces) may be used as the initializer for an array of matching type: . ordinary string literals and UTF-8 string literals (since C11) can initialize arrays of any character type (char, signed char, unsigned char) ; L-prefixed wide string literals can be used to initialize arrays of any type compatible with (ignoring cv ...
C Arrays
Arrays. Arrays are used to store multiple values in a single variable, instead of declaring separate variables for each value. To create an array, define the data type (like int) and specify the name of the array followed by square brackets []. To insert values to it, use a comma-separated list, inside curly braces: We have now created a ...
Different ways to Initialize all members of an array to the same value in C
Below are some of the different ways in which all elements of an array can be initialized to the same value: Initializer List: To initialize an array in C with the same value, the naive way is to provide an initializer list. We use this with small arrays. int num[5] = {1, 1, 1, 1, 1}; This will initialize the num array with value 1 at all index.
Structure Assignment (GNU C Language Manual)
structure assigment such as r1 = r2 copies array fields' contents just as it copies all the other fields. This is the only way in C that you can operate on the whole contents of a array with one operation: when the array is contained in a struct. You can't copy the contents of the data field as an array, because.
Why does C not support direct array assignment?
5. In C you cannot assign arrays directly. At first I thought this might because the C facilities were supposed to be implementable with a single or a few instructions and more complicated functionality was offloaded to standard library functions. After all using memcpy() is not that hard.
Dynamic Array in C
A Dynamic Array is allocated memory at runtime and its size can be changed later in the program. We can create a dynamic array in C by using the following methods: Using malloc () Function. Using calloc () Function. Resizing Array Using realloc () Function. Using Variable Length Arrays (VLAs) Using Flexible Array Members.
Array declaration
A declaration of the form T a[N];, declares a as an array object that consists of N contiguously allocated objects of type T. The elements of an array are numbered 0 , …, N -1, and may be accessed with the subscript operator [], as in a[0], …, a[N -1]. Arrays can be constructed from any fundamental type (except void), pointers, pointers to ...
Multidimensional Arrays in C
where, type: Type of data to be stored in each element. arr_name: Name assigned to the array. m: Number of rows. n: Number of columns. For example, we can declare a two-dimensional integer array with name 'arr' with 10 rows and 20 columns as:. int arr[10][20]; Initialization of 2D Arrays. We can initialize a 2D array by using a list of values enclosed inside '{ }' and separated by a ...
std::array
std::array is a container that encapsulates fixed size arrays.. This container is an aggregate type with the same semantics as a struct holding a C-style array T [N] as its only non-static data member. Unlike a C-style array, it doesn't decay to T * automatically. As an aggregate type, it can be initialized with aggregate-initialization given at most N initializers that are convertible to T ...
C++ Arrays
In C++, we can declare an array by simply specifying the data type first and then the name of an array with its size. data_type array_name[Size_of_array]; Example. int arr[5]; Here, int: It is the type of data to be stored in the array. We can also use other data types such as char, float, and double.
c++
a = b ; // At this point, how ever assignment operation is valid. int a[] = { 1,2 }; int b[] = { 3,4 }; foo( a, b ); a = b; // Why is this invalid here. return 0; Is it because, array decays to a pointer when passed to a function foo(..), assignment operation is possible. And in main, is it because they are of type int[] which invalidates the ...
C Pointers
Assignment of pointers of the same type. C // C program to illustrate Pointer Arithmetic #include <stdio.h> int main {// Declare an array int v [3] ... We are using the pointer to access the components of the array. int a[3] = {3, 4, 5 }; int *ptr = a; We have a pointer ptr that focuses to the 0th component of the array. ...

Integer Array in C – How to Declare Int Arrays with C Programming

What Is An Array in C Programming?

How to Declare an Integer Array in C Programming

How to Initialize an Integer Array in C Programming

How to Access Items in an Integer Array in C Programming

How to Change Items in an Integer Array in C Programming

Popular Tutorials

C Fundamentals

C Flow Control

C Programming Arrays

C Programming Pointers

C Structure and Union

C Programming Files

C Additional Topics

C Tutorials

How to declare an array?

Access Array Elements

Few keynotes :

How to initialize an array?

Change Value of Array elements

Example 1: Array Input/Output

Example 2: Calculate Average

Access elements out of its bound!

Multidimensional arrays

Table of Contents

Video: C Arrays

Related Tutorials

Arrays in C

What is an Array in C?

Why Do We Use Arrays in C?

Example: Use of an Array in C

Declaration of an Array in C

Syntax to Declare an Array

Declaring an Uninitialized Array

Example: Declaring an Array in C

Initialization of an Array in C

Syntax to Initialize an Array

Example to Initialize an Array

Example of Initializing all Array Elements to 0

Example of Partial Initialization of an Array

Example of Partial and Specific Elements Initialization

Getting Size of an Array in C

Example 1: Size of Integer Array

Example 2: Adjacent Address of Array Elements

Example 3: Array of Double Type

Example 4: Size of Character Array

Accessing Array Elements in C

Example to Access Array Elements in C

More on C Arrays

C Functions

Access the Elements of an Array

Change an Array Element

Loop Through an Array

Set Array Size

C Exercises

COLOR PICKER

Contact Sales

Report Error

Top Tutorials

15.13 Structure Assignment

Stack Exchange Network

2 Answers 2

Your Answer

Sign up or log in

Not the answer you're looking for? Browse other questions tagged c array unions struct or ask your own question .

Hot Network Questions

cppreference.com

[ edit ] Iterator invalidation

[ edit ] Template parameters

[ edit ] Member types

[ edit ] Member functions

[ edit ] Non-member functions

[ edit ] Helper classes

[ edit ] Example

Collectives™ on Stack Overflow

Array Assignment [duplicate]

3 Answers 3

Not the answer you're looking for? Browse other questions tagged c++ arrays or ask your own question .

Hot Network Questions

What is a Pointer in C?