Arrays & Strings.pptx

• An array is a collection of variables of the same type
that are referred to by a common name.
• Arrays offer a convenient means of grouping
together several related variables, in one dimension
or more dimensions:
• product part numbers:
int part_numbers[] = {123, 326, 178, 1209};
• student scores:
int scores[10] = {1, 3, 4, 5, 1, 3, 2, 3, 4,
4};
• characters:
char alphabet[5] = {’A’, ’B’, ’C’, ’D’,
’E’};

•names:
char names[][40] =
{“Peter”, “Mary”, “Lisa”,
“John”, "George-Simon"};
•3D coordinates:
vector coordinates[4][3] =
Back
{{0, 0, 0},
{1, 0, 1},
{1, 0, 5}
{4, 7, 9}};

One-Dimensional Arrays
A one-dimensional array is a list of related variables
The general form of a one-dimensional array
declaration is:
type variable_name[size]
• type
:
• size:
• variable_name:
base type of the array,
determines the data type of
each element in the array
how many elements the
array will hold the name
of the array
Examples:
int sample[10];
ﬂoat float_numbers[100];
char last_name[40];

Accessing Array Elements
An individual element within an array is
accessed by use of an index. An index
describes the position of an element
within an array.
Note:
In C++ the ﬁrst element has the index zero!

Representation of Arrays in Memory
In C++, any array is mapped to a
contiguous memory location. All memory
elements reside next to each other.
The lowest address corresponds to the ﬁrst
element, and the highest address to the last
element.

Example:
int a[8];
int j;
for(j=0; j<8; j++) a[j] = 7-j;
Then the memory representation of array a looks like
this:
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7]
7 6 5 4 3 2 1 0

Example: Finding the Maximum
#include <iostream.h> int
main()
{
int i, max = 0; int
list[100];
// initialize the array with
random values
for(i=0; i<100; i++) list[i] = rand();
// findmaximum value
for(i=0; i<100; i++)
if(max < list[i]) max = list[i];
cout << “Maximum value: “ << max;
return(0);
}

No Array-to-Array Assignments
You cannot assign one array to another in
C++. The following is illegal:
int a[10], b[10];
// do something
// assign all elements of array b to array a
a = b; // error -- illegal
Instead, you have to do the assignments for each element:
int i;
// assign all elements of array b to array a
for(i=0; i<10; i++) a[i] = b[i];

Strings
The most common use for one-dimensional arrays is to store
strings of characters.
In C++, a string is deﬁned as a character array terminated by
a null symbol ( ‘0’ ).
To declare an array str that could hold a 10-character string,
one would write:
char str[11];
Specifying the size as 11 makes room for the null at the end of
the string.
‘H’ ‘e’ ‘l’ ‘l’ ‘o’ ‘0’

Some examples of string constants in C++ are:
"hello there"
"I like C++."
"#$%§@@+*"
""" """"
""
""
The null string, ““, only contains the null
terminator and represents the empty string.

Reading a String from the Keyboard
How to read a string entered from the keyboard?
Make an array, that will receive the string, the target of a cin stream. The
following program reads (part of) a string entered by the user:
#include <stdio.h> int
main()
{
char str[80];
cout << “Enter a string: “;
cin >> str; // read string from keyboard
cout << “Here is your string: “;
Cout << str;
return(0);}

Problem: Entering the string “This is a test”, the above program
only returns “This”, not the entire sentence.
Reason: The C++ input/output system stops reading a string
when the ﬁrst whitespace character is encountered.
Solution: Use another C++ library function, gets().
#include <iostream.h>
#include <cstdio.h>
int main()
{
char str[80]; // long enough for user input?
gets(str); // read a string from the keyboard
cout << “Here is your string: “;
cout << str << endl;
return(0);}

Some C++ Library Functions for Strings
C++ supports a range of string-manipulation functions. The
most common are:
• strcpy() :
• strcat() :
• strlen() :
• strcmp() :
copy characters from one string to
another concatenation of strings
length of a string
comparison of
strings

strcpy(to_string, from_string) — String Copy:
#include <cstring.h>
int main()
{
char a[10];
strcpy(a, “hello”);
cout << a;
return(0);
}
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]
h e l l o 0 ? ? ? ?

strlen(string) — String Length
strlen(str) returns the length of the string pointed to by str,
i.e., the number of characters excluding the null terminator.
#include <cstdio.h>
int main()
{
char str[80];
gets(str);
cout << “Length is: “ << strlen(str);
return(0);}

strcat(string_1, string_2) — Concatenation of Strings
The strcat() function appends s2to the end of s1. String s2is
unchanged.
// includes ... int
main()
{
char s1[21], s2[11];
strcpy(s1, “hello”);
strcpy(s2, “ there”);
strcat(s1, s2);
cout << s1 << endl;
cout << s2 << endl;
return(0);
}

Note:
• The ﬁrst string array has to be large enough to hold both
strings:
• To be on the safe side:
strlen(s1concats2) >= strlen(s1) + strlen(s2)
‘ ‘ t h e r e 0 ? ? ? ?
h e l l o 0 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
0 1 2 3 4 5 6 7 8 9 1011121314151617181920
s1:
0 1 2 3 4 5 6 7 8 9 10
s2:
h e l l o ‘ ‘ t h e r e 0 ? ? ? ? ? ? ? ? ?
0 1 2 3 4 5 6 7 8 9 1011121314151617181920
strcat(s1,s2):

strcmp(string_1, string_2) — Comparison of Strings
The strcmp(str_1, str_2) function compares two strings
and returns the following result:
• str_1 == str_2
• str_1 > str_2
• str_1 < str_2
: 0
: positive number
: negative
number
The strings are compared lexicographically
(i.e., according to dictionary order):
a < aa < aaa < … < b < ba < bb < … < bz < baa < … < abca < abd <
...

// Comparing strings
#include <cstdio.h>
int main()
{
char str[80];
cout << “Enter password: “;
gets(str);
if(strcmp(str, “password”)) {
// strings differ
cout << “Invalid password.n”;}
else cout << “Logged on.n”;
return(0);
}

Using the Null Terminator
Operations on strings can be simpliﬁed using the fact that all
strings are null-terminated.
// Convert a string to uppercase
// ... includes ...
int main()
{
charstr[80];
int i;
strcpy(str, “this is a test”);
for(i=0; str[i]; i++)
str[i] = toupper(str[i]);
cout << str; return(0); }

Two-Dimensional Arrays
A two-dimensional array is a list of one-dimensional arrays.
To declare a two-dimensional integer array two_dim of size
10,20 we would write:
int matrix[3][4];
This corresponds to a table with 3 rows and 4 columns (for
example).
1 2 3 4
5 6 7 8
9 10 11 12
0 1 2 3
0
1
2
Left
Index
Right
Index
two_dim[1][2]

We can generate the array above by using this program:
int main()
{
int row=3, col=4;
int matrix[row][col];
for(row=0; row < 3; ++row) {
for(col=0; col < 4; ++col) {
matrix[row][col] = (row*4)+ col +1;
cout << matrix[row][col] << ‘ ‘;
}
cout << ‘n’;
}
return(0);}

Memory Allocation for Two-Dimensional Arrays
Storage for all array elements is determined at compile time.
The memory used to hold an array is required the entire time
that the array is in existence.
The following formula determines the number of bytes of
memory that will be allocated:
bytes = rows * columns * number_of_bytes_in_type
For example, an integer array (with two-byte integers) with
dimensions 100,100 would require 100 * 100 * 2 = 20,000
bytes.

Multidimensional Arrays
C++ allows arrays with more than two dimensions.
The general form of an N-dimensional array declaration is:
type array_name [size_1] [size_2] … [size_N];
For example, the following declaration creates a 4 x 10 x 20
character array, or a matrix of strings:
char string_matrix[4][10][20];
This requires 4 * 10 * 20 = 800 bytes.
If we scale the matrix by 10, i.e. to a 40 x 100 x 20 array, then
80,000 bytes are needed.

Array Initialization
The general form of array initialization is similar to that of
other variables:
type array-name[size] = { list-of-values };
The list-of-values has to be a comma-separated list of
constants that are type-compatible with the base type of
the array.
In the following example, a 10-element ﬂoat array is
initialized with the numbers 1.0 through 10.0:
float i[10] =
{1.,2.,3.,4.,5.,6,7,8,9,10};
Therefore, i[0] will have the value 1.0, and i[9] will
have the value 10.0.

Character Array Initialization
Character arrays that will hold strings allow a shorthand
initialization that takes this form:
char array-name[size] = “string”;
For example, the following code fragment initializes str to
the phrase “hello”:
char str[6] = “hello”;
This is the same as writing
char str[6] =
{‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘0’};
Remember that one has to make sure to make the array long
enough to include the null terminator.

Multi-Dimensional Array Initialization
Multi-dimensional arrays are initialized the same way as one-
dimensional arrays.
For example, the following code fragment initializes an array
squares with the numbers 1 through 10 and their squares:
intsquares[9][2] =
{ 1, 1,
2, 4,
3, 9,
4, 16,
5, 25,
6, 36,
7, 49,
8, 64,
9, 81 };

For better readability, especially for multi-dimensional arrays,
one can use subaggregate grouping by adding braces
accordingly.
The same declaration as above can also be written as:
int squares[10][2] =
{ {1, 1},
{2, 4},
{3, 9},
{4, 16},
{5, 25},
{6, 36},
{7, 49},
{8, 64},
{9, 81},
{10, 100}
};

The following program uses the squares array to ﬁnd the root
of a number entered by the user.
// declaration of squares array goes here
int main()
{
int i, j;
cout << “Enter a number 1<=i<=100: “;
cin >> i;
// look up i
for(j=0; j<10; j++)
if(squares[j][1] == i) {
cout << "Root: " << squares[j][0];
return(0);}
cout << "No integer root."; return(0);}

© Christian Jacob
Unsized Array Initializations
It is possible to let C++automatically dimension the arrays
through the use of unsized arrays.
char error_1[] = “Divide by 0n”;
char error_2[] = “End-of-Filen”;
char error_3[] = “Access Deniedn”;
C++ will automatically create arrays large enough to hold all
the initializers present.
For a multi-dimensional array, all but the leftmost dimension
have to be speciﬁed. So we can write:
char errors[][20] = {
“Divide by 0n”,
“End-of-Filen”,
“Access Deniedn” };

Arrays of Strings
An array of strings is a special form of a two-dimensional array.
• The size of the left index determines the number of strings.
• The size of the right index speciﬁes the maximum length of
each string.
For example, the following declares an array of 30 strings,
each having a maximum length of 80 characters (with one
extra character for the null terminator):
char string_array[30][81];

For accessing an individual string, one simply speciﬁes only
the left index:
firstString = string_array[0];
sixthString = string_array[5];
The following example calls the gets() function with the third
string in the array:
gets(string_array[2]);

This program accepts lines of text entered at the keyboard
and redisplays them after a blank line is entered.
// includes go here
int main()
{
int t, i;
char text[100][80];
// quit on blank line
for(t=0; t<100; t++) {
cout << t << “: “;
gets(text[t]);
if(!text[t][0]) break;
}
for(i=0; i<t; i++) // redisplay the strings
cout << text[i] << ‘n’;
return(0);}

An Example Using String Arrays
Arrays of strings are commonly used for handling
tables of information.
One such application would be an employee database that
stores
• the name
• telephone number
• hours worked per pay period, and
• hourly wage.
These data we could store in arrays:
charname[20][80]; // employee names
int phone[20]; // phone numbers
float hours[20];
loat wage[20];
// hours worked
// wage

Entering Information
void enter()
{
inti;
for(i=0; i<20; i++)
{
cout<< “Lastname: “;
cin>>name[i];
cout<< “Phonenumber: “;
cin>>phone[i];
cout<< “Hoursworked: “;
cin>>hours[i];
cout<< “Wage:“;
cin>>wage[i];
}
}

Displaying Database Contents
Void report()
{
inti;
for(i=0; i <20;i++)
{
cout<< "Name:"<<name[i]<<"/"<<"phone:"
<<phone[i] << ‘n’;
cout<< “Pay for theweek: “;
cout<< wage[i]*hours[i];
cout<<‘n’;
}
}

Menu For User´s Selection
intmenu()
{
intchoice;
cout<< “0.Quitn”;
cout<< “1.Enter informationn”;
cout<< “2.Reportinformationn”;
cout<< “n”;
cout<< “Choose one: “;
cin>> choice;
Return choice;
}

Main Function
int main()
{
int choice;
do {
choice = menu(); // get selection
switch(choice) {
case 0: break;
case 1: enter(); break;
case 2: report(); break;
default: cout << “Try again.nn”;
}
} while( choice != 0);
return(0);
}

© Christian Jacob
Putting It All Together
// array declarations int
menu();
void enter();
void report();
int main()
{ ... }
int menu()
{ ... }
void enter()
{ ... }
void report() { ... }

Arrays & Strings.pptx

Recommended

More Related Content

Similar to Arrays & Strings.pptx (20)

Recently uploaded (20)

Arrays & Strings.pptx