Presented by UFMFGT-15-1: Programming for Engineers
Tom Knowles Week 15: Arrays and Loops
Code: XX-XX-XX
22 February, 2024
This session
• Arrays
o Scalar vs array data types
o How to declare them
o How to access their items
• Loops
o while, do-while, for
o Flow control within loops
• Loops and arrays together
Why do we need Arrays and Loops?
• Up to this point, you can make programs that can do user I/O and make decisions
o scanf, printf
o Flow control (if, switch)
Arrays Loops
• Declare a single block of • Runs a block of code a
memory number of times
• Holding multiple variables of • Can run repeatedly until a
the same type condition is met
• Can be treated as a group or • Can work with array items
individual items iteratively
Scalar declaration
data
type
name = value ;
• We can choose any valid combination of letters, numbers and underscores
• Names like this represent scalar variables – they are completely independent
Array declaration
data
type
name [N] = value
;
• Adding square brackets lets us declare how many memory items to associate with this
variable name
• Functionally, this is the same as declaring N variables one after the other
o Except, we can refer to them as a group by their name
Scalar vs Array
Scalar Declaration Array Declaration
int sc1; int arr[3];
int sc2;
int sc3; arr[0] = 1;
arr[1] = 2;
sc1 = 1; arr[2] = 3;
sc2 = 2;
sc3 = 3;
printf("My array items:
printf("My scalars: %d, %d, %d, %d",
%d, %d", sc1, sc2, arr[0], arr[1],
sc3); arr[2]);
Scalar vs Array
Scalar Declaration Array Declaration
int sc1 = 1; int arr[3] = {1, 2, 3};
int sc2 = 2;
int sc3 = 3;
printf("My scalars: %d, printf("My array items:
%d, %d", sc1, sc2, %d, %d, %d",
sc3); arr[0], arr[1],
arr[2]);
Scalar vs Array
Scalar Declaration Array Declaration
int sc1 = 1; int arr[] = {1, 2, 3};
int sc2 = 2;
int sc3 = 3;
printf("My scalars: %d, printf("My array items:
%d, %d", sc1, sc2, %d, %d, %d",
sc3); arr[0], arr[1],
arr[2]);
Designated Initialisers
Array Declaration
• Not all of an array needs to be initialised
• If we only want specific non-default values, int arr[100] = {[3] = 1,
we can refer to specific items within [49]= 3,
our initialisation [70] = 7};
• This assigns values to those indexes only;
the rest remain default for that data type
printf("My array items:
%d, %d, %d",
arr[0], arr[1],
arr[2]);
Using whole arrays
Array Declaration
• The array variable name is a pointer to int arr[] = {1, 2, 3};
where the array starts
• C represents the variables as they are in
memory; contiguous
arr
• When referring to the array itself, we can arr[0] arr[1] arr[2]
1 2 3
also refer to it as a whole by 'referencing'
the variable arr[0]; finding its starting
memory location
• Functionally, the difference ends up being
adding an 'address of' operator in front of
the array item to refer to the whole thing
Example: user input
Array Declaration
• Familiar from the 2nd week of exercises -> char input[3];
scanf("%2s", input); Whole array
input[0] input[1] input[2] referenced
input 'h' 'i' '\0' printf("%d,%d,%d",
input[0],
input[1], input[2]);
Array items
referenced
input[0] input[1] input[2]
input # # #
Example: user input
Array Declaration
• Familiar from the 2nd week of exercises -> char input[3];
&input[0]
scanf("%2s", &input[0]);Whole array
input[0] input[1] input[2] referenced
input 'h' 'i' '\0' printf("%d,%d,%d",
input[0],
input[1], input[2]);
Array items
&input[0] referenced
&
input[0] input[1] input[2] 'address of'
# # #
operator
input
Loops
• Structures that repeat an inner block of code
• Come in three flavours:
While Do-While For
• Runs whilst a • Runs whilst a • Runs a set number of
conditional expression conditional expression iterations
is true is true • Stops once the last
• Stops when this • Stops when iteration has been run
becomes false this becomes false • Uses its own
• Checks the expression • Checks the expression dedicated iterator
before the first after the first iteration variable
iteration
While
int start, end;
• While the expression is true, execute code scanf("%d %d", &start, &end);
block repeatedly
• Expression ideally will change at some point int t = start;
to allow the while loop to exit
while (t < end) {
• Does this loop ever end?
printf("%d", t);
t++;
}
While
int start, end;
• Yes; regardless of how large end is, t will scanf("%d %d", &start, &end);
eventually reach it
• If start >= end, it won't run int t = start;
while (t < end) {
printf("%d", t);
t++;
}
While
int start, end;
• Adding if statements to catch scanf("%d %d", &start, &end);
troublesome inputs is good practice
• Will this code complete, given enough int t = start;
time?
if start >= end {
printf("Warning: start time is
larger than end time.");
} else {
while (start < end) {
printf("%d", t);
t++;
}
}
While
int start, end;
• No! We have made a mistake, and are not scanf("%d %d", &start, &end);
checking the right variables
int t = start;
if start >= end {
printf("Warning: start time is
larger than end time.");
} else {
while (start < end) {
printf("%d", t);
t++;
}
}
While
int start, end;
• Now it is checking the correct variables in scanf("%d %d", &start, &end);
the expression
int t = start;
if start >= end {
printf("Warning: start time is
larger than end time.");
} else {
while (t < end) {
printf("%d", t);
t++;
}
}
While
int start, end;
• Similarly, a loop without a proper change in scanf("%d %d", &start, &end);
its expression could 'step over' the
expression that would stop the loop int t = start;
while (t != end) {
printf("%d", t);
t = t + 2;
}
While
int start, end;
• Sticking to lower-specificity expressions can scanf("%d %d", &start, &end);
catch these cases
int t = start;
while (t <= end) {
printf("%d", t);
t = t + 2;
}
Do-While
#include <robot.h> // not a real .h
int status;
• A while loop flipped on its head
• Performs the loop body, then checks the do {
condition
status = startUp();
• Great for if something needs to run at least
once before checking if it needs to be run if (status != 0) {
again
• Couple of easy things to miss printf("Startup exited with
o Semicolon after the while expression status
%d: retrying...",
o No condition after the do keyword
status);
}
} while (status != 0);
For
#include <dataSource.h> // not a real
.h
• A while loop that uses an iterator rather int data[10] = loadData();
than an expression
• An iterator is a variable that tracks which for (int i = 0; i < loops; i++) {
loop is currently being run
// do something until !(i <
• Always an integer, and always defined as loops)
part of the loop
o If you want to check an external }
variable's value, use a while loop with a
relational expression
For
#include <dataSource.h> // not a real
.h
Dedicated iterator (int i = 0; int data[10] = loadData();
int loops = 10;
Conditional
expression i < loops; for (int i = 0; i < loops; i++) {
Iterator change per
loop i++) // do something until !(i <
loops)
• Each for loop has three parts to its
expression }
• Typically an increment (counting upwards)
• Can add more that 1 each time
• Can decrement
For loops and arrays
#include <sensor.h> // not a real .h
&data[0] int samples = 10;
int data[] = readData(samples);
data[0] data[...] data[9]
? . . . ?
for (int i = 0; i < samples; i++) {
data
currentItem = data[i];
printf("Value of item %d = %d",
• Consider an array of known size, but i, currentItem);
unknown contents
}
• We might want to 'unpack' the
array; getting all of its values }
• We can use the iterator as an index
• Don't mix up the index (location) of the
data and the data at that index
Inspecting arrays
#include <stdio.h> // includes
&data[0] <stddef.h>
int samples = 10;
data[0] data[...] data[N] int data[] = readData(samples);
data ? . . . ? printf("Size of data (in bytes): %d",
sizeof(data));
Size of data (in bytes): 40
• Unlike some languages, C arrays are very
barebones
• They are not objects and do not have
properties outside of their data contents
• However, <stdio.h> has some functions #include <stdio.h> // includes
to help us work with them eg. sizeof() <stddef.h>
• This can also be used to find how large a
printf("Size of int: %d",
given data type is in memory Size of int (in bytes):
sizeof(int)); 4
Inspecting arrays
#include <stdio.h> // includes
&data[0] <stddef.h>
int samples = 10;
data[0] data[...] data[N] int data[] = readData(samples);
data ? . . . ? printf("Size of data (in elements):
%d", sizeof(data) / sizeof(int));
Size of data (in elements):
• To emulate the behaviour of MATLAB’s 10
numel() or Python’s len(), we can divide the
size in bytes, by the size of an integer in
memory
• This gives how many elements (in this case,
integers) exist in the array
• We can use this in our loop conditional
expressions to allow for varying array sizes
Memory overrun
#include <sensor.h> // not a real .h
&data[0] int samples = 10;
int data[] = readData(samples);
data[0] data[...] data[9] int nextItem;
data ? . . . ? for (int i = 0; i < samples; i++) {
nextItem = data[i+1];
• It is possible to refer to items outside of the printf("Value of next item %d =
array %d",
o What is presented as an index is really i+1, nextItem);
just a memory offset of }
sizeof(dataType)
• When this happens, behaviour is undefined }
• Make sure to keep indexing variables within
the bounds of the array
Memory overrun
#include <sensor.h> // not a real .h
&data[0] int samples = 10;
int data[] = readData(samples);
data[0] data[...] data[9] int nextItem;
data ? . . . ? for (int i = 0; i < samples; i++) {
if ((i + 1) < samples) {
• Like with while loops, we can catch nextItem = data[i+1];
problematic cases with if statements
} else {
nextItem = data[i];
printf("Value of next item %d =
%d",
i+1, nextItem);
}
Flow control - break
int emailAddress[40];
&data[0] int size = sizeof(emailAddress);
scanf("%s", emailAddress);
data[0] data[...] data[9] int username[20];
data ? . . . ? for (int i = 0; i < size; i++) {
if(emailAddress[i] == '@') {
• At times, we may want to end the loop break;
structure early
}
• Useful if the rest of the for loop is
redundant for the array printf("%c", emailAddress[i]);
• Note that this moves the program counter
outside the for block, regardless of the }
status of the iterator
Flow control - continue
int emailAddress[40];
&data[0] int size = sizeof(emailAddress);
scanf("%s", &emailAddress);
data[0] data[...] data[9] int username[20];
data ? . . . ? for (int i = 0; i < samples; i++) {
if(emailAddress[i] == '.') {
• At times, we may want to end the loop and continue;
restart
}
• Useful if the rest of the loop is redundant
for that item if(emailAddress[i] == '@')
• Note that this keeps the program counter {break;}
inside the for block, and will carry on to
the next iteration (if any) printf("%c", emailAddress[i]);
}
Casting arrays
&input[0] &output[0]
input[0] input[...] input[9] output[0] output[...] output[9]
input char . . . char int . . . int output
• Last week we explored the idea of casting; char input[10];
converting one variable to another data type scanf("%s", &input[0]);
• Casting arrays is tricky, because they are int output[10];
contiguous
• Generally, it is better to cast the items and for (int i = 0; i < sizeof(input); i+
+){
reassemble a new array iteratively
• We can use the sizeof() function to tell output[i] = (int)input[i];
us the size of the array
}
2D Arrays
int input[3][3] = {{1, 2, 3},
&input[0][0] {4, 5, 6},
{7, 8, 9}};
input[0] input[1] input[2]
? . . . ?
input[0][0] input[1][0] input[2][0]
• 2D (and higher) arrays are perfectly possible
1 4 7 • Each array item is itself an array
• Still contiguous in memory; this just helps us
organise certain data more naturally
input[0][1] input[1][1] input[2][1]
• Examples:
input
2 5 8 o Greyscale image data (3D for RGB image)
o Data tables
input[0][2] input[1][2] input[2][2]
3 6 9
Working with 2D Arrays
int input[3][3] = {{1, 2, 3},
&input[0][0] {4, 5, 6},
{7, 8, 9}};
input[0] input[1] input[2]
? . . . ?
input[0][0] input[1][0] input[2][0] n_cols = sizeof(input[0]);
n_rows = sizeof(input) / n_cols;
1 4 7 for (int i = 0; i < n_cols; i++){
input[0][1] input[1][1] input[2][1] for (int j = 0; j < n_rows; j++){
input
2 5 8
printf("Item (%d, %d): %d",
i, j, output[i][j]);
input[0][2] input[1][2] input[2][2] }
}
3 6 9 • Scales poorly, but is essential for working
with high-dimensional datasets
Flow control - break
int input[3][3] = {{1, 2, 3},
{4, 5, 6},
• break statements can also be used within {7, 8, 9}};
nested loops
• They only exit the innermost block they are n_cols = sizeof(input[0]);
called in, not all parent blocks n_rows = sizeof(input) / n_cols;
for (int i = 0; i < n_cols; i++){
for (int j = 0; j < n_rows; j++){
// do something
break;
}
Flow control - continue
int input[3][3] = {{1, 2, 3},
{4, 5, 6},
• continue can also be used within nested {7, 8, 9}};
loops
• Like break, continue stays within its n_cols = sizeof(input[0]);
block n_rows = sizeof(input) / n_cols;
for (int i = 0; i < n_cols; i++){
for (int j = 0; j < n_rows; j++){
// do something
continue;
}
Flow control - goto
int input[3][3] = {{1, 2, 3},
{4, 5, 6},
• If we want to exit several layers of {7, 8, 9}};
nested blocks at once, we can use goto
• Can simplify highly nested code n_cols = sizeof(input[0]);
n_rows = sizeof(input) / n_cols;
• It is, however, very difficult to debug
when overused for (int i = 0; i < n_cols; i++){
• If you find yourself wanting to use goto,
consider if there isn't a way to refactor your for (int j = 0; j < n_rows; j++){
code or rethink the problem first
// do something
goto exitPoint;
exitPoint: // more code below
Summary
• New data structure
o 1D arrays Attendance Code:
o ND arrays
XX-XX-XX
• Loops
o while
o do-while
o for
• Continue, break and goto
• Arrays and loops together
Assessment FAQs
Question Answer
Do I need to submit my source code? Yes; zipped, as per recent video demo
Do I need to do
flowcharts/pseudocode for every Yes; this is worth as much as the
exercise? source code itself
Do I need to include program banners
in my source code? Yes; see lecture 1 for what to include
When is the first deadline? This Sunday; 25th Feb, 2pm. #1 and #2
None for the progress submissions, yes
What about RAs/extensions? for the final submission
