C programming & data structure [arrays & pointers]

CProgramming Language
&
Data Structure
Prepared by: Mo’meN M. Ali
E-mail: momen.1993@live.com

References
• www.stackoverflow.com
• C Primer Plus 6th Edition
• Let Us C 5th Edition
• The C Programming Language 2nd Edition
• C Modern Approach 2nd Edition
• Data Structures and Algorithm Analysis in C 2nd Edition
Mo’meN M. Ali
C Programming Language

Review Programs are uploaded to this Git repo
https://github.com/Mo2meN-
Ali/x86/tree/master/Programming%20Course/1-
Arrays%20%26%20Pointers
Mo’meN M. Ali

Topics
• Arrays & Pointers.
• Character String & String Functions.
• Storage Classes, Linkage & Memory Management.
• File Input/Output.
• Structures & Other Data Formats.
• Bit Fiddling.
• The C Preprocessor & The C Library.
• Algorithm Analysis & ADT.
• Stacks & Queues.
• Trees.
Mo’meN M. Ali

Today You Will Learn About:
• Keyword: static.
• Operators: & * (unary).
• How to create and initialize arrays.
• Pointers.
• Writing functions that process arrays.
• Two-dimensional arrays.
Mo’meN M. Ali

Arrays
• An array is composed of a series of elements of one data type.
• An array declaration tells the compiler how many elements the array
contains and what the type is for these elements.
• To access elements in an array, you identify an individual element by using
its subscript number, also called its index,The numbering starts with 0.
Mo’meN M. Ali
/* some array declarations */
int main(void)
{
float candy[365]; /* array of 365 floats */
char code[12]; /* array of 12 chars */
int states[50]; /* array of 50 ints */
}

Mo’meN M. Ali
#include <stdio.h>
#define MONTHS 12
int main(void)
{
int days[MONTHS]= {31,28,31,30,31,30,31,31,30,31,30,31};
int index;
for (index = 0; index < MONTHS; index++)
printf("Month %d has %2d days.n", index +1, days[index]);
return 0;
}

Output
Month 1 has 31 days.
Mo’meN M. Ali

Entering Data into an Array
for ( i = 0 ; i <= 29 ; i++ )
{
printf ( "nEnter marks " ) ;
scanf ( "%d", &states[i] ) ;
}
Mo’meN M. Ali
Reading data from an array
for ( i = 0 ; i <= 29 ; i++ )
sum= sum + marks[i] ;

Mo’meN M. Ali
#include <stdio.h>
#define SIZE 4
int main(void)
{
int some_data[SIZE]= {1492, 1066};
int i;
printf("%2s%14sn", i, some_data[i]);
for (i = 0; i < SIZE; i++)
printf("%2d%14dn", i, some_data[i]);
return 0;
}

Output
i some_data[i]
0 1492
1 1066
2 0
3 0
Mo’meN M. Ali

Mo’meN M. Ali
#include <stdio.h>
int main(void)
{
const int days[]= {31,28,31,30,31,30,31,31,30,31};
int index;
for (index= 0; index < ( sizeof (days) / sizeof (days[0]) ); index++)
printf("Month %2d has %d days.n", index +1, days[index]);
return 0;
}

Output
Mo’meN M. Ali

What if you fail to initialize an array?
#include <stdio.h>
#define SIZE 4
int main(void)
{
int no_data[SIZE]; /* uninitialized array */
int i;
printf("%2s%14sn", "i", "no_data[i]");
for (i = 0; i < SIZE; i++)
printf("%2d%14dn", i, no_data[i]);
return 0;
}
Mo’meN M. Ali

Output (Your Results may vary)
i no_data[i]
0 0
1 4204937
2 4219854
3 2147348480
Mo’meN M. Ali

Array Bounds
• You have to make sure you use array indices that are within bounds; that
is, you have to make sure they have values valid for the array. For
instance, suppose you make the following declaration:
int doofi[20];
• Then it's your responsibility to make sure the program uses indices only in
the range 0 through 19, because the compiler won't check for you.
Mo’meN M. Ali

Mo’meN M. Ali
#include <stdio.h>
#define SIZE 4
int main(void)
{
int value1 = 44;
int arr[SIZE];
int value2 = 88;
int i;
printf("value1 = %d, value2 = %dn", value1, value2);
for (i = -1; i <= SIZE; i++)
arr[i] = 2 * i + 1;
for (i = -1; i < 7; i++)
printf("%2d %dn", i , arr[i]);
printf("value1 = %d, value2 = %dn", value1, value2);
return 0;
}

Output
value1 = 44, value2 = 88
-1 -1
0 1
1 3
2 5
3 7
4 9
5 5
6 1245120
value1 = -1, value2 = 9
Mo’meN M. Ali

Designated Initializers (C99)
• C99 has added a new capability designated initializers. This feature allows
you to pick and choose which elements are initialized. Suppose, for
example, that you just want to initialize the last element in an array. With
traditional C initialization syntax, you also have to initialize every element
preceding the last one:
int arr[6] = {0,0,0,0,0,212}; // traditional syntax
• With C99, you can use an index in brackets in the initialization list to specify
a particular element:
int arr[6] = {[5] = 212}; // initialize arr[5] to 212
Mo’meN M. Ali

Mo’meN M. Ali
// designate.c -- use designated initializers
#include <stdio.h>
#define MONTHS 12
int main(void)
{
int days[MONTHS] = {31,28, [4] = 31,30,31, [1] = 29};
int i;
for (i = 0; i < MONTHS; i++)
printf("%2d %dn", i + 1, days[i]);
return 0;
}

Output
1 31
2 29
3 0
4 0
5 31
6 30
7 31
8 0
9 0
10 0
11 0
12 0
Mo’meN M. Ali

Suppose you don’t specify the
array size?
int stuff[] = {1, [6] = 23}; // what happens?
int staff[] = {1, [6] = 4, 9, 10}; // what happens?
• The compiler will make the array big enough to accommodate the
initialization values. So stuff will have seven elements, numbered 0-6, and
staff will have two more elements, or 9.
Mo’meN M. Ali

Specifying an Array Size
#define SIZE 4
int arr[SIZE]; // symbolic integer constant
double lots[144]; // literal integer constant
int n = 5;
int m = 8;
float a1[5]; // yes
float a2[5*2 + 1]; // yes
float a3[sizeof(int) + 1]; // yes
float a4[-4]; // no, size must be > 0
float a5[0]; // no, size must be > 0
float a6[2.5]; // no, size must be an integer
float a7[(int)2.5]; // yes, typecast float to int constant
float a8[n]; // not allowed before C99
float a9[m]; // not allowed before C99
Mo’meN M. Ali

Exercise 1.0
30 Minutes
MO’MEN M. ALI

Multidimensional arrays
• A multidimensional array is an array which every element in it is an array.
float rain[5] [12]; // an array of 12 floats
• This tells us that each element is of type float[12]; that is, each of the five
elements of rain is, in itself, an array of 12 float values.
Mo’meN M. Ali

Initializing a two-dimensional array
#define MONTHS 12 // number of months in a year
#define YEARS 5 // number of years of data
const float rain[YEARS][MONTHS] = {
{4.3,4.3,4.3,3.0,2.0,1.2,0.2,0.2,0.4,2.4,3.5,6.6}, // Row 0 (rain[0])
{8.5,8.2,1.2,1.6,2.4,0.0,5.2,0.9,0.3,0.9,1.4,7.3}, // Row 1 (rain[1])
{9.1,8.5,6.7,4.3,2.1,0.8,0.2,0.2,1.1,2.3,6.1,8.4}, // Row 2 (rain[2])
{7.2,9.9,8.4,3.3,1.2,0.8,0.4,0.0,0.6,1.7,4.3,6.2}, // Row 3 (rain[3])
{7.6,5.6,3.8,2.8,3.8,0.2,0.0,0.0,0.0,1.3,2.6,5.2} // Row 4 (rain[4])
};
Review Program: rain
Mo’meN M. Ali

Pointers And Arrays
• Pointers offer an efficient way to deal with arrays. Indeed.
• Array notation is simply a disguised use of pointers.
1. date == &date[0]; // name of array is the address of the first element
2. dates +2 == &date[2] /* same address */
3. *(dates + 2) == dates[2] /* same value */
4. *(dates +2) /* value of the 3rd element of dates */
5. *dates +2 /* 2 added to the value of the 1st element */
Mo’meN M. Ali

Mo’meN M. Ali
#include <stdio.h>
#define SIZE 4
int main(void)
{
short dates [SIZE];
short * pti;
short index;
double bills[SIZE];
double * ptf;
pti = dates; // assign address of array to pointer
ptf = bills;
printf("%23s %15sn", "short", "double");
for (index = 0; index < SIZE; index ++)
printf("pointers + %d: %10p %10pn", index, pti + index, ptf + index);
return 0;
}

Output
short double
pointers + 0: 0x7fff5fbff8dc 0x7fff5fbff8a0
pointers + 1: 0x7fff5fbff8de 0x7fff5fbff8a8
pointers + 2: 0x7fff5fbff8e0 0x7fff5fbff8b0
pointers + 3: 0x7fff5fbff8e2 0x7fff5fbff8b8
Mo’meN M. Ali

Mo’meN M. Ali
/* day_mon3.c -- uses pointer notation */
#include <stdio.h>
#define MONTHS 12
int main(void)
{
int days[MONTHS] = {31,28,31,30,31,30,31,31,30,31,30,31};
int index;
for (index = 0; index < MONTHS; index++)
printf("Month %2d has %d days.n",
index +1, *(days + index)); // same as days[index]
return 0;
}

Functions, Arrays, and Pointers
• Suppose you want to write a function that operates on an array. For example,
suppose you want a function that returns the sum of the elements of an
array. Suppose marbles is the name of an array of int. What would the
function call look like? A reasonable guess would be this:
total = sum(marbles); // possible function call
• What would the prototype be? Remember, the name of an array is the
address of its first element,
int sum(int * ar); // corresponding prototype
Mo’meN M. Ali

Mo’meN M. Ali
int sum(int * ar) // corresponding definition
{
int i;
int total = 0;
for( i = 0; i < 10; i++) // assume 10 elements
total += ar[i]; // ar[i] the same as *(ar + i)
return total;
}
int sum(int * ar, int n) // more general approach
{
int i;
int total = 0;
for( i = 0; i < n; i++) // use n elements
total += ar[i]; // ar[i] the same as *(ar + i)
return total;
}

Using Pointer Parameters
• A function working on an array needs to know where to start and stop.
• Another way to describe the array is by passing two pointers, with the first
indicating where the array starts (as before) and the second where the array
ends.
• Now, the function can alter the value of the pointer itself, making it point to
each array element in turn.
Mo’meN M. Ali

Arrays as Arguments
• Because the name of an array is the address of the first element, an actual
argument of an array name requires that the matching formal argument be a
pointer. Also, C interprets int ar[] to mean the same as int * ar.
• All four of the following prototypes are equivalent:
int sum(int *ar, int n);
int sum(int *, int);
int sum(int ar[], int n);
int sum(int [], int);
Review Program: Array as arguments
Mo’meN M. Ali

Pointer Operations
Review Program: PointerOperations
• Assignment— You can assign an address to a pointer. The assigned value can be, for
example, an array name, a variable preceded by address operator ( & ), or another second
pointer.
• Value finding (dereferencing)— The * operator gives the value stored in the pointed-to
location. Therefore, *ptr1 is initially 100 , the value stored at location 0x7fff5fbff8d0 .
• Taking a pointer address— Like all variables, a pointer variable has an address and a value.
The & operator tells you where the pointer itself is stored.
• Adding an integer to a pointer— You can use the + operator to add an integer to a pointer
or a pointer to an integer. In either case, the integer is multiplied by the number of bytes in
the pointed-to type, and the result is added to the original address. This makes ptr1 + 4 the
same as &urn[4] .
Mo’meN M. Ali

• Incrementing a pointer— Incrementing a pointer to an array element makes it move to the
next element of the array. Therefore, ptr1++ increases the numerical value of ptr1 by 4 (4
bytes per int on our system) and makes ptr1 point to urn[1].
• Subtracting an integer from a pointer— You can use the - operator to subtract an integer
from a pointer; the pointer has to be the first operand and the integer value the second
operand. The integer is multiplied by the number of bytes in the pointed-to type, and the
result is subtracted from the original address.
• Decrementing a pointer— Of course, you can also decrement a pointer. In this example,
decrementing ptr2 makes it point to the second array element instead of the third. Note
that you can use both the prefix and postfix forms of the increment and decrement
operators.
• Differencing— You can find the difference between two pointers. Normally, you do this for
two pointers to elements that are in the same array to find out how far apart the elements
are. The result is in the same units as the type size.
• Comparisons— You can use the relational operators to compare the values of two pointers,
provided the pointers are of the same type.
Mo’meN M. Ali

Using const with formal
parameters
• If a function is intent is that it not change the contents of the array, use the keyword
const when declaring the formal parameter in the prototype and in the function
definition.
Mo’meN M. Ali

Pointers to multidimensional
Arrays
• Since 2D-Arrays are Arrays of arrays, therefore we need a pointer-to-array instead of a
pointer-to-element.
int (* pz)[2]; // pz points to an array of 2 ints. (Can be used as 2D
// Array pointer).
int * pax[2]; // pax is an array of two pointers-to-int (Can no be used as 2D
// Array Pointer).
Mo’meN M. Ali

Pointer Compatibility
• The rules for assigning one pointer to another are tighter than the rules for numeric
types. For example, you can assign an int value to a double variable without using a
type conversion, but you can’t do the same for pointers to these two types:
int n= 5;
double x;
int * p1= &n;
double * pd= &x;
x= n; // implicit type conversion
pd= p1; // compile-time error
Mo’meN M. Ali

int * pt;
int (*pa)[3];
int ar1[2][3];
int ar2[3][2];
int **p2; // a pointer to a pointer
pt = &ar1[0][0]; // both pointer-to-int
pt = ar1[0]; // both pointer-to-int
pt = ar1; // not valid
pa = ar1; // both pointer-to-int[3]
pa = ar2; // not valid
p2 = &pt; // both pointer-to-int *
*p2 = ar2[0]; // both pointer-to-int
p2 = ar2; // not valid
Review Program: Pointers and 2D-Arrays
Mo’meN M. Ali

Functions and multidimensional
arrays
• If you want to write functions that process two-dimensional arrays, you need to
understand pointers well enough to make the proper declarations for function
arguments. In the function body itself, you can usually get by with array notation.
int junk[3][4] = { {2,4,5,8}, {3,5,6,9}, {12,10,8,6} };
int i, j;
int total = 0;
for (i = 0; i < 3 ; i++)
total += sum(junk[i], 4); // junk[i] -- one-dimensional array
Mo’meN M. Ali

Exercise 1.1
30 Minutes
MO’MEN M. ALI

Variable-length arrays (VLAs)
• You may have noticed that you can not use a variable size multidimensional array as an
argument, that is because you always have to use a constant columns. Well VLAs is the
C99 way to solve this problem. You can use VLAs to pass a variable length
multidimensional array.
int sum2d(int rows, int cols, int ar[rows][cols]); // array a VLA
int sum2d(int, int, int ar[*][*]); // array a VLA, names omitted
• rows and cols are two variable arguments that can be passed at run-time.
• rows and cols must be define before the array.
int sum2d(int ar[rows][cols], int rows, int cols); // invalid order
Review Program: Functions usingVLAs
Mo’meN M. Ali

More dimensions
• Everything we have said about two-dimensional arrays can be generalized
to three-dimensional arrays and further. You can declare a three-
dimensional array this way:
int box[10][20][30];
• You can visualize a one-dimensional array as a row of data, a two-
dimensional array as a table of data, and a three-dimensional array as a
stack of data tables. For example, you can visualize the box array as 10
two-dimensional arrays (each 20×30) stacked atop each other.
Mo’meN M. Ali

Compound Literals
MO’MEN M. ALI
Search Yourself

THANK YOUSEE YOU SOON
Mo’meN M. Ali

C programming & data structure [arrays & pointers]

Recommended

More Related Content

What's hot (20)

Viewers also liked (18)

Similar to C programming & data structure [arrays & pointers] (20)

More from MomenMostafa (9)

Recently uploaded (20)

C programming & data structure [arrays & pointers]