Computer Programming

Using

Course Code: CoSc 1012

Aderaw Semma
May-2025
 Chapter V
Arrays, Strings and Pointers in C++

2
 Objectives
Learn about arrays

Declare and manipulate data into arrays

Learn about “array index out of bounds”

Learn about the restrictions on array processing

Pass an array as a parameter to a function

 Use the pointer data type and pointer variables

Declare and manipulate pointer variables

 Learn about the address of operator and the dereferencing

operator

 Discover dynamic variables 3

 Outlines
Arrays, Strings and Pointers
 Array representation
 One dimensional array
 N – dimensional array
 Pointer
 Array and pointer
 String representation and manipulation
 String and pointers
 Dynamic Memory Management

4
 I. Array Introduction
An array is a collection of a fixed number of components all of
the same data type. C++ provides a data structure, the array,
which stores a fixed-size sequential collection of elements of the
same type.

An array is 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.

Instead of declaring individual variables, such as number0,

number1, ..., and number99, you declare one array variable
such as numbers and use numbers[0], numbers[1], and ...,
5
numbers[99] to represent individual variables.
 Cont…
A specific element in an array is accessed by an index. All
arrays consist of contiguous memory locations. The lowest
address corresponds to the first element and the highest
address to the last element.

Just as an apartment building

is known by 1 address but many

apartment numbers, an array has

one name but can use integer

indices to access individual elements

6
 Cont…
Informal Definition: Ordered collection of variables of the same
type

Collection is referred to with one name

Individual elements referred to by an offset/index from the start

of the array [in C++, first element is at index 0]

Syntax for declaring a one-dimensional array:

intExp: any constant expression that evaluates to a positive

integer
7
 Cont…
indexExp: called the index

An expression with a nonnegative integer value

Value of the index is the position of the item in the array

[]: array subscripting operator

Array index always starts at 0

Basic operations on a one-dimensional array:

Initializing  Inputting data  Outputting data stored in an

array  Finding the largest and/or smallest element etc…

Each operation requires ability to step through elements of the

array– Easily accomplished by a loop 8
 Cont…
Formal Def: A statically-sized, contiguously allocated collection
of homogenous data elements

Collection of homogenous data elements – Multiple variables of

the same data type

Contiguously allocated in memory – One right after the next

Statically-sized – Size of the collection must be a constant and

can’t be changed after initial declaration/allocation

Collection is referred to with one name

Individual elements referred to by an offset/index from the start

of the array [in C++, first element is at index 0] 9
 Array Declaration
The general form for declaring a one-dimensional array is:
datatype arayname[intexpr];

In which intExp is any constant expression that evaluates to a

positive integer. Also, intExp specifies the number of
components in the array. Example: int num[5];

The above statement declares an array num of five components.

Each component is of type int.

The components are num[0], num[1],

num[2], num[3], and num[4]. The

figure illustrates the array num. 10

 Array initialization
we can initialize C++ array elements either one by one or
using a single statement as follows: double balance[5] =
{1000.0, 2.0, 3.4, 17.0, 50.0};

The number of values between braces { } cannot be larger

than the number of elements that we declare for the array
between square brackets [ ].

Following is an example to assign a single element of the

array: If you omit the size of the array, an array just big
enough to hold the initialization is created. Therefore, if you
write: double balance[] = {1000.0, 2.0, 3.4, 17.0, 50.0};
11
 Cont…
You will create exactly the same array as you did in the
previous example. balance[4] = 50.0; The above statement
assigns element number 5th in the array a value of 50.0. Array
with 4 th index will be the 5 th value, i.e., last element because
all arrays have 0 as the index of their first element which is also
called base index. Following is the pictorial representation of
the same array we discussed above:

N.B. Other Ways to Declare Arrays Example

12
 Accessing array elements
An element is accessed by indexing the array name. This is
done by placing the index of the element within square
brackets after the name of the array.

For example: double salary = balance[9]; The above statement

will take 10th element from the array and assign the value to
salary variable.

13
 Cont…
Assume a 5-element int array – int x[5] = {8,5,3,9,6};

When you access x[2], the CPU calculates where that item is in
memory by taking the start address of x (i.e. 100) and adding
the product of the index, 2, times the size of the data type (i.e.
int = 4 bytes)
 x[2] => int. @ address 100 + 2*4 = 108
 x[3] => int. @ address 100 + 3*4 = 112
 x[i] @ start address of array + i * (size of array type)
C++ does not stop you from attempting to access an element
beyond the end of the array – x[6] => int. @ address 100 +
6*4 = 124 (Garbage!!) 14
 Cont…
Compiler must be able to figure out how much memory to
allocate at compiletime

Given the declaration:

int list[100]; //array of size 100
int i;
Use a for loop to access array elements:
for (i = 0; i < 100; i++) //Line 1
cin >> list[i]; //Line 2 15
 Cont…
Index of an array is in bounds <= ARRAY_SIZE-1 if the index
is >=0 and Otherwise, the index is out of bounds
In C++, there is no guard against indices that are out of
bounds
Arrays can be initialized during declaration  Values are
placed between curly braces  Size determined by the number
of initial values in the braces
Example: double sales[] = {12.25, 32.50, 16.90, 23, 45.68};
Partial Initialization of Arrays During Declaration
The statement: int list[10] = {0}; Declares an array of 10
components and initializes all of them to zero
The statement: int list[10] = {8, 5, 12};Declares an array of
10 components and initializes list[0] to 8, list[1] to 5, list[2] to
12  All other components are initialized to 0 16
 Multidimensional Array
In the above sections you learned about one dimensional
array, that is, single variables specify array.

C++ allows programmer to create array of an array known as

multidimensional arrays. Here is the general form of a
multidimensional array declaration:

type name[size1][size2]...[sizeN];

For example, the following declaration creates a three

dimensional 5 . 10 . 4 integer array:

int threedim[5][10][4];
17
 Two-Dimensional Arrays:
The simplest form of the multidimensional array is the two-
dimensional array. A two-dimensional array is, in essence, a list
of one-dimensional arrays.

To declare a two-dimensional integer array of size x,y, you

would write something as follows:

type arrayName [ x ][ y ];

Where type can be any valid C++ data type and arrayName
will be a valid C++ identifier. A two dimensional array can be
think as a table, which will have x number of rows and y
number of columns. 18
 Cont…
Two-dimensional array : collection of a fixed number of
components (of the same type) arranged in two dimensions–
Sometimes called matrices or tables
Declaration syntax:
intExp1and intExp2are expressions with positive integer values
specifying the number of rows and columns in the array
Two-dimensional arrays can be initialized when they are
declared: Elements of each row are enclosed within braces
and separated by commas  All rows are enclosed within
braces For number arrays, unspecified elements are set to 0
Ways to process a two-dimensional array: Process entire
array Row processing : process a single row at a time
 Column processing : process a single column at a time
Each row and each column of a two-dimensional array is a one-
dimensional array To process, use algorithms similar to one dimensional arrays 19
 Cont…
Examples:
 To initialize row number 4 (fifth row) to 0:

To initialize the entire matrix to 0:

Use a nested loop to output the components of a two

dimensional array:

20
 Cont..
Array Input Examples:
To input into row number 4 (fifth row):

To input data into each component of matrix:

Example of Array Sum by Row: To find the sum of values of row

number 4:

21
 Cont…
Example of Array Sum by Column: To find the sum of values of
each individual column:

Example Largest Element in Each Row

22
 Cont…
Some Restrictions on Array Processing
Aggregate operation : any operation that manipulates the
entire array as a single unit Not allowed on arrays in C++
Example:

Solution:

23
 Cont…
Arrays as Parameters to Functions
Arrays are passed by reference only
Do not use symbol &when declaring an array as a formal
parameter
Size of the array is usually omitted  If provided, it is ignored
by the compiler • Example:
Can prevent a function from changing the actual parameter
when passed by reference  Use const in the declaration of
the formal parameter • Example:

N.B. Functions Cannot Return a Value of the Type Array

C++ does not allow functions to return a value of type array
24
 Cont…
Another Way to Declare a Two-Dimensional Array and Can use
typedef to define a two-dimensional array data type:

To declare an array of 20 rows and 10 columns:

tableType matrix;

25
 Cont…
Thus far arrays can be thought of 1-dimensional (linear) sets
 only indexed with 1 value (coordinate)

 char x[6] = {1,2,3,4,5,6};

We often want to view our data as 2-D, 3-D or higher

dimensional data

 Matrix data

 Images (2-D)

 Index w/ 2 coordinates

(row,col)
26
 Cont…
2D: Provide size along both dimensions (normally rows first
then columns)

 Access w/ 2 indices

 Declaration: int my_matrix[2][3];

 Access elements with appropriate indices

• my_matrix[0][1] evals to 3, my_matrix [1][2] evals to 2

27
 Cont…
A 2-dimensional array a, which contains three rows and four
columns can be shown as below:

Thus, every element in array a is identified by an element name

of the form a[i][j], where a is the name of the array, and i and j
are the subscripts that uniquely identify each element in a.
28
 Initializing Two-Dimensional
Arrays:
Multidimensional arrays may be initialized by specifying
bracketed values for each row. Following is an array with 3
rows and each row have 4 columns.
int a[3][4] = {
{0, 1, 2, 3} , /* initializers for row indexed by 0 */ 5
{4, 5, 6, 7} , /* initializers for row indexed by 1 */
{8, 9, 10, 11} /* initializers for row indexed by 2 */
};
The nested braces, which indicate the intended row, are
optional. The following initialization is equivalent to previous
example:
int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11}; 29
 Accessing Two-Dimensional
Array Elements:
An element in 2-dimensional array is accessed by using the
subscripts, i.e., row index and column index of the array. For
example: int val = a[2][3];

The above statement will take 4th element from the 3rd row of
the array. You can verify it in the above diagram.

30
 Cont…
#include <iostream>
using namespace std;
int main ()
{
// an array with 5 rows and 2 columns.
int a[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}};
// output each array element's value
for ( int i = 0; i < 5; i++ )
for ( int j = 0; j < 2; j++ )
{
cout << "a[" << i << "][" << j << "]: ";
cout << a[i][j]<< endl;
}
31
 Cont…
When the above code is compiled and executed, it produces
the following result:

As explained above, you can have arrays with any number of
dimensions, although it is likely that most of the arrays you
32
 N-dimensional Array
collection of a fixed number of elements arranged in n
dimensions (n >= 1)
Declaration syntax:

To access a component:

33
 Multi dimension Array
Declaration
2D: Provide size along both dimensions (normally rows first
then columns)
Access 2 indices
Declaration: int my_matrix[2][3];
Access elements with appropriate indices
My_matrix[0][1] evaluates to 3, and my_matrix[1][2]
evaluates to 2
3D: Access data 3 indices
Declaration: unsigned char image[2][4][3];
Up to human to interpret meaning of dimensions
 Planes x Rows x Cols

 Rows x Cols x Planes

34
Cont…

35
 Linearization of
Multidimensional Arrays
In a computer, multidimensional arrays must still be stored in
memory which is addressed linearly (1-Dimensional)
C/C++ use a policy that lower dimensions are placed next to
each other followed by each higher level dimension

36
Cont…

37
 II. String Manipulation
There
using Arrays
are two types of strings commonly use in C++
programming language:

Strings that are objects of string class (The Standard C++

Library string class)

C-strings (C-style Strings) usually called character Arrays. In this

chapter we only discus about the second string type which is the
C-string. In C programming, only one type of string is available
and this is also supported in C++ programming. Hence it's
called C-strings. C-strings are the arrays of type char terminated
with null character, that is, ‘\0’ (ASCII value of null character is 0).
38
 Cont…
The statement: ch = '\0';
Stores the null character in ch, wherein ch is a char variable.
The null character plays an important role in processing
character arrays.
Because the collating sequence of the null character is 0, the
null character is less than any other character in the char data
set. The most commonly used term for character arrays is C-
strings.
However, there is a subtle difference between character arrays
and C-strings. Recall that a string is a sequence of zero or
more characters, and strings are enclosed in double quotation
marks. In C++, C-strings are null terminated; that is, the last
character in a C-string is always the null character.

39
 Cont…
A character array might not contain the null character, but the
last character in a C-string is always the null character.
As you will see, the null character should not appear anywhere
in the C-string except the last position. In addition, C-strings
are stored in (one dimensional) character arrays.
The following are examples of C-strings:
"John L. Johnson"
"Hello there."
From the definition of C-strings, it is clear that there is a
difference between 'A' and "A".
The first one is character A; the second is C-string A. Because
C-strings are null terminated, "A" represents two characters: 'A'
and '\0'. Similarly, the C-string "Hello" represents six
characters: 'H', 'e', 'l', 'l', 'o', and '\0'.
40
 Cont…
To store 'A', we need only one memory cell of type char; to
store "A", we need two memory cells of type char—one for 'A'
and one for '\0'. Similarly, to store the C-string "Hello" in
computer memory, we need six memory cells of type char.
Consider the following example
char str[] = "C++";
In the above code, str is a string and it holds 4 character.
Although, "C++" has 3 character, the null character \0 is added
to the end of the string automatically.
Other ways of defining the string:
char str[4] = "C++";
char str[] = {'C','+','+','\0'};
char str[4] = {'C','+','+','\0'};
Like arrays, it is not necessary to use all the space allocated for the
string. For example: char str[100] = "C++"; 41
 Cont…
The following declaration and initialization create a string
consisting of the word "Hello". To hold the null character at the
end of the array, the size of the character array containing the
string is one more than the number of characters in the word
"Hello."
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
If you follow the rule of array initialization, then you can write
the above statement as follows:
char greeting[] = "Hello";
Following is the memory presentation of above defined string
in C++:

42
 Cont…
Actually, you do not place the null character at the end of a
string constant. The C++ compiler automatically places the '\0'
at the end of the string when it initializes the array. Let us try
to print above-mentioned string:

43
 Cont…
C++ supports a wide range of functions that manipulate null-
terminated strings: C++ provides a set of functions that can be
used for C-string manipulation. The header file cstring
describes these functions.

44
 Cont…
To use these functions, the program must include the header
file cstring via the include statement. That is, the following
statement must be included in the program:

#include

45
 String Comparison
In C++, C-strings are compared character by character using
the system’s collating sequence. Let us assume that you use the
ASCII character set.
1. The C-string "Air" is less than the C-string "Boat" because the first
character of "Air" is less than the first character of "Boat".
2. The C-string "Air" is less than the C-string "An" because the first
characters of both strings are the same, but the second character 'i'
of "Air" is less than the second character 'n' of "An".
3. The C-string "Bill" is less than the C-string "Billy" because the first
four characters of "Bill" and "Billy" are the same, but the fifth
character of "Bill", which is '\0' (the null character), is less than the
fifth character of "Billy", which is 'y'. (Recall that C-strings in C++
are null terminated.)
4. The C-string "Hello" is less than "hello" because the first character
'H' of the C-string "Hello" is less than the first character 'h' of the C-
string "hello". 46
 Cont…
Example: C++ program to display a string entered by user.

47
 Cont…
Notice that, in second example only "programming" is
displayed instead of "Programming is fun". It is because The
extraction operator >> considers a space has a terminating
character. Consider the following example: which read and
display an entire line entered by user.

To read the text containing blank space, cin.get function can be used. This
function takes two arguments. First argument is the name of the string
(address of first element of string) and second argument is the maximum
48
size of the array.
 Passing Array to a Function
in C++ Programming
Arrays can be passed to a function as an argument. Consider
this example to pass one-dimensional array to a function:
Example: C++ Program to display marks of 5 students by
passing one-dimensional array to a function.

49
 Cont…
When an array is passed as an argument to a function, only the
name of an array is used as argument. The argument used
marks in the above code represents the memory address of first
element of array marks[5]. And the formal argument int m[5] in
function declaration decays to int* m;.

That's why, although the function is manipulated in the user-

defined function with different array name m[5], the original
array is manipulated. The C++ programming language handles
passing array to a function in this way to save memory and
time.
50
 Cont…
Passing Multidimensional Array to a Function: Multidimensional
array can be passed in similar way as one-dimensional array.
Consider this example to pass two dimensional array to a
function: Example: C++ Program to display the elements of
two dimensional array by passing it to a function.

Multidimensional array
with dimension more
than 2 can be passed in
similar way as two
dimensional array.

51
 III. POINTERS
In the later chapters, you learned that C++’s data types are
classified into three categories: simple, structured, and
pointers. Until now, only the first two data types are covered.
Now we will discusses the third data type called the pointer
data type. You will first learn how to declare pointer variables
(or pointers, for short) and manipulate the data to which they
point.

52
 Basic Concept of Pointers
In earlier chapters, variables have been explained as locations
in the computer's memory which can be accessed by their
identifier (their name).

This way, the program does not need to care about the physical
address of the data in memory; it simply uses the identifier
whenever it needs to refer to the variable.

For a C++ program, the memory of a computer is like a

succession of memory cells, each one byte in size, and each
with a unique address.

53
 Cont…
These single-byte memory cells are ordered in a way that
allows data representations larger than one byte to occupy
memory cells that have consecutive addresses.

When a variable is declared, the memory needed to store its

value is assigned a specific location in memory (its memory
address).

Generally, C++ programs do not actively decide the exact

memory addresses where its variables are stored. Fortunately,
that task is left to the environment where the program is run -
generally, an operating system that decides the particular
54
 Cont…
However, it may be useful for a program to be able to obtain
the address of a variable during runtime in order to access data
cells that are at a certain position relative to it. When you
declare a variable, the computer associates the variable name
with a particular location in memory and stores a value there.

55
 Pointer Variables and
Declaration
Pointers are the powerful feature of C++ programming, which
differs it from other popular programming languages like Java,
Visual Basic etc.

To understand pointers, you should have the knowledge of

address in computer memory. Computer memory is broken
down into bytes and each byte has its own address.

For example: In 1KB memory, there are 1024 bytes and each
byte is given an address (0 - 1023). As you know every
variable is a memory location and every memory location has
its address defined which can be accessed using ampersand
56
(&) operator which denotes an address in memory.
 Cont…
Consider the following, which will print the address of the
variables defined:

N.B. The 0x in the beginning represents the address is in

hexadecimal form. (You may not get the same result on your
57
 Cont…
What is pointer? Now you know about address in computer
memory, it is time to learn about pointers. Consider a normal
variable as in above example, these variables holds data.

But pointer variables or simply pointers are the special types of

variable that holds memory address instead of data.

A pointer is a variable whose value is the address of another

variable. Like any variable or constant, you must declare a
pointer before you can work with it.

The general syntax of a pointer variable declaration is:

type *var-name; 58
 Cont…
Here, type is the pointer's base type; it must be a valid C++
type and var-name is the name of the pointer variable.

The asterisk you used to declare a pointer is the same asterisk

that you use for multiplication. However, in this statement the
asterisk is being used to designate a variable as a pointer.

Following are the valid pointer declaration:

int *p;

OR,

int* p;
59
 Cont…
The statement above defines a pointer variable p. The pointer
p holds the memory address. The asterisk is a dereference
operator which means pointer to.

Here pointer p is a pointer to int, that is, it is pointing an

integer.

Note: In above statement p is a pointer variable that holds

address not *p. The *p is an expression. The content (value)
of the memory address pointer p holds is given by expression
*p.

60
 Cont…
Example: C++ Program to demonstrate the working of pointer.

61
 Cont…
The output of the above program is

62
 Explanation of Program:
When c = 5; the value 5 is stored in the address of variable c.

When pc = &c; the pointer pc holds the address of c and the

expression *pc contains the value of that address which is 5 in
this case.

When c = 11; the address that pointer pc holds is unchanged.

But the expression *pc is changed because now the address &c
(which is same as pc) contains 11.

When *pc = 2; the content in the address pc(which is equal to

&c) is changed from 11 to 2. Since the pointer pc and variable c
has address, value of c is changed to 2. 63
 Pointer Expression,
Operation and Arithmetic
As you understood pointer is an address which is a numeric
value; therefore, you can perform arithmetic operations on a
pointer just as you can a numeric value. There are four
arithmetic operators that can be used on pointers: ++, --, +,
and –

To understand pointer arithmetic, let us consider that ptr is an

integer pointer which points to the address 1000.

Assuming 32-bit integers, let us perform the following arithmetic

operation on the pointer:

ptr++ 64
 Cont…
The ptr will point to the location 1004 because each time ptr is
incremented, it will point to the next integer. This operation will
move the pointer to next memory location without impacting
actual value at the memory location.

If ptr points to a character whose address is 1000, then above

operation will point to the location 1001 because next
character will be available at 1001. Pointers may be compared
by using relational operators, such as ==, < and >. If p1 and
p2 point to variables that are related to each other, such as
elements of the same array, then p1 and p2 can be
65
meaningfully compared.
Relationship between Pointers
and Arrays
Before we understand the concept of array of pointers, let us
consider the following example, which makes use of an array
of 3 integers:

66
 Cont…
The out put of the above code is:

Pointers are the variables that hold address. Pointers can point
at cells of an array not only single variable. Consider this
example:
Int *ptr;

int a[5];

ptr = &a[2]; // &a[2] is the address of third element of a[5].

67
 Cont…
Suppose, pointer needs to point to the fourth element of an
array, that is, hold address of fourth array element in above
case.

Since ptr points to the third element in the above example, ptr
+ 1 points to the fourth element. You may think that, ptr + 1
may hold the address of byte next to ptr.

But it's not correct. It is because pointer ptr is a pointer to int

and size of int is fixed for a operating system (size of int is 4
byte of 64-bit operating system). Hence, the address between
ptr and ptr + 1 differs by 4 bytes.
68
 Cont…
If pointer ptr was pointer to char then, the address between
ptr and ptr + 1 would have differed by 1 byte since size of a
character is 1 byte.

Example: C++ Program to display address of elements of an

array using both array and pointers

69
Cont…

70
 Cont…
Output

In the above program, different pointer is used for displaying

the address of array elements. But, array elements can be
accessed using pointer notation (by using same array name).
For example:

71
 Cont…
Example: C++ Program to display address of array elements
using pointer notation.

72
 Cont….
You know that, pointer ptr holds the address and expression
*ptr gives the content in that address. Similarly, *(ptr + 1)
gives the content in address ptr + 1. Consider this code below:

73
 Cont…
Example: C++ Program to insert and display data entered by
using pointer notation.

74
Cont…

75
 Revisiting function calling by
reference (using pointers)
In function chapter, you learned about passing arguments to a
function. This is pass by value because actual value is passed.
There is another way of passing argument in which actual
value is not passed; only the reference to that value is passed.
Consider this example .

76
Cont…

77
 Cont…
In main(), two integer variables are defined. And those
integers are passed to a function swap() by reference.

Compiler can identify this is pass by reference because function

definition is void swap(int& n1, int& n2) (notice the & sign after
data type).

Here, n1 and n2 are the different names given to the argument

passed, that is n1 and a is exact same variable (not only their
value is same but both name refer to one single variable).
Similarly, n2 and b is exact same variable.

78
 Cont…
There is another way of doing this same exact task using
pointers. Consider this example:

79
 Cont…
The output of this example is same as before. In this case, the
address of variable is passed during function call rather than
variable itself.

swap(&a, &b); // &a is address of a and &b is address of b

Since the address is passed instead of value, dereference

operator must be used to access the value stored in that
address.

80
 Cont…
The *n1 and *n2 gives the value stored at address n1 and n2
respectively.

Since n1 contains the address of a, anything done to *n1

changes the value of a in main() function as well. Similarly, b
will have same value as *n2.

81
82