Module-3
Arrays and Strings
School of Electronics Engineering (SENSE)
Vellore Institute of Technology
Chennai
(School of Electronics Engineering (SENSE)Vellore Institute
Module-3of Arrays
Technology
and Strings
Chennai) 1 / 50
Module 3: Arrays and Strings
Outline
1 Introduction to Arrays
2 One-Dimensional Arrays, Multi-Dimensional Arrays
3 Arrays in Memory, Operations on Arrays
4 Introduction to Strings
5 String Manipulations
6 Functions in C
7 Function Parameters and Return Types
8 Recursion in Functions
9 Introduction to Pointers
10 Pointer Arithmetic
11 Pointers and Arrays, Strings, Functions
12 Introduction to Structures
13 Accessing Structure Members
14 Structures and Functions
15 Introduction to Unions
16 Structures vs Unions
Module-3 Arrays and Strings 2/50
Introduction to Arrays
Definition
An array is a collection of items stored at contiguous memory locations.
In C, arrays are used to store similar types of elements.
Application in Embedded Systems
Arrays are used in embedded systems for handling multiple similar data
efficiently, such as sensor readings, buffer storage, and lookup tables.
Module-3 Arrays and Strings 3/50
One-Dimensional Arrays
Syntax and Declaration
int arr[10]; // Declares an array of 10 integers
Example
arr[0] = 1; // Sets the first element to 1
Module-3 Arrays and Strings 4/50
Declaration of One-Dimensional Arrays
Array Declaration Syntax
type arrayName[arraySize];
Example: Sensor Readings Array
#define NUM_SENSORS 4
int sensorReadings[NUM_SENSORS]; //Array for storing sensor va
Note on Embedded Systems
In embedded C, the size of arrays is often determined by the number of
physical components, like sensors or actuators, connected to the
microcontroller.
Module-3 Arrays and Strings 5/50
Initializing One-Dimensional Arrays
Array Initialization Syntax
type arrayName[arraySize] = {val1, val2, ..., valN};
Example: Setting Initial Sensor States
int sensorStates[NUM_SENSORS] = {0}; // Initialize all to 0
Embedded Systems Context
Initialization is crucial in embedded systems to ensure that memory has
defined values before use, particularly for registers or state variables.
Module-3 Arrays and Strings 6/50
Accessing Array Elements
Accessing Elements Syntax
Elements in an array are accessed using their index.
arrayName[index]
Example: Accessing an Element
int array[5] = {1, 2, 3, 4, 5};
int firstElement = array[0]; // Access first element
Embedded Systems Consideration
When accessing array elements in embedded systems, ensure that the
index is within the bounds to prevent undefined behavior and potential
system crashes.
Module-3 Arrays and Strings 7/50
Iterating Over Arrays
Iterating Over Arrays
To perform operations on each element in an array, a loop is used.
for (int i = 0; i < arraySize; i++) {
// Code to execute
}
Example: Summing Array Elements
int sum = 0;
for (int i = 0; i < 5; i++) {
sum += array[i];
}
Embedded Systems Tip
In time-critical embedded applications, consider the loop’s impact on
execution time and optimize the iteration process.
Module-3 Arrays and Strings 8/50
Example: Summing Elements in an Array
Standard C Example
int main() {
int values[5] = {5, 10, 15, 20, 25};
int sum = 0;
for (int i = 0; i < 5; i++) {
sum += values[i];
}
printf("Sum of values: %d\n", sum);
return 0;
}
Module-3 Arrays and Strings 9/50
Multi-Dimensional Arrays Overview
Definition
Multi-dimensional arrays are arrays of arrays.
They are used to represent data in more than one dimension, such as
matrices.
Module-3 Arrays and Strings 10/50
Multi-Dimensional Arrays
Syntax and Declaration
int multiArr[3][4]; // Declares a 3x4 array
Example
multiArr[0][1] = 5; // Element at row 0, column 1 to 5
Module-3 Arrays and Strings 11/50
Declaration of Multi-Dimensional Arrays
Declaration Syntax
type arrayName[size1][size2];
Example: 2D Array for LED Matrix
#define ROWS 3
#define COLS 3
int ledMatrix[ROWS][COLS]; // LED states for a 3x3 matrix
Embedded C Context
Such arrays can represent physical layouts in hardware, like an LED matrix,
with each element controlling the state of an LED.
Module-3 Arrays and Strings 12/50
Initializing Multi-Dimensional Arrays
Initialization Syntax
type arrayName[size1][size2] = {{val1, val2}, {...}};
Standard C Example
int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
Embedded C Application
Initializing state matrices for devices like displays where each element
represents a pixel or segment state.
Module-3 Arrays and Strings 13/50
Accessing Multi-Dimensional Array Elements
Accessing Elements
Use row and column indices to access elements in a multi-dimensional
array.
arrayName[row][column]
Standard C Example
int value = matrix[1][2]; // Accesses the element at second ro
Embedded C Context
For embedded systems, ensure the indices are within bounds to maintain
system stability.
Module-3 Arrays and Strings 14/50
Nested Loops and Multi-Dimensional Arrays
Using Nested Loops
Nested loops allow iteration over rows and columns of a multi-dimensional array.
for(int i = 0; i < rows; i++) {
for(int j = 0; j < columns; j++) {
// Access array elements
}
}
Standard C Example
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 3; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
Embedded C Consideration
In embedded systems, nested loops are commonly used for scanning or controlling a grid of
sensors or actuators.
Module-3 Arrays and Strings 15/50
Example: Matrix Addition
Standard C Example - Adding Two Matrices
void addMatrices(int A[2][3], int B[2][3], int C[2][3]) {
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 3; j++) {
C[i][j] = A[i][j] + B[i][j];
}
}
}
Embedded C Application
Matrix addition can be used in embedded systems for combining data from
multiple sensor arrays.
Module-3 Arrays and Strings 16/50
Arrays in Memory: How C Stores Arrays
Memory Layout of Arrays
Discuss how arrays are contiguous blocks of memory and how
multi-dimensional arrays are stored in row-major order.
Embedded C Significance
Understanding memory layout is crucial in embedded systems for
optimizing data storage and access patterns.
Module-3 Arrays and Strings 17/50
Address Arithmetic in Arrays
Understanding Address Arithmetic
Addresses of array elements are calculated using the base address and
the size of the element type.
This is essential for pointer arithmetic and understanding how arrays
are accessed in memory.
Standard C Example
int array[5];
int *ptr = array;
printf("%p %p", ptr, ptr + 1); // Prints contiguous addresses
Embedded C Application
Directly manipulating memory addresses is common in embedded systems,
for instance when interfacing with hardware registers.
Module-3 Arrays and Strings 18/50
Example: Searching an Array
Implementing a Search Algorithm
A linear search algorithm iterates over an array to find a value.
This is a straightforward example of how to traverse an array with a
loop.
Standard C Code for Linear Search
int linearSearch(int arr[], int size, int value) {
for (int i = 0; i < size; i++) {
if (arr[i] == value) return i;
}
return -1; // Value not found
}
Embedded C Scenario
Searching through a data array to find a sensor reading that exceeds a
threshold could trigger an event or alert.
Module-3 Arrays and Strings 19/50
Strings in C: A Special Kind of Array
What Are Strings in C?
In C, strings are arrays of characters terminated by a null character \0.
Usage in Embedded Systems
Strings are often used for storing data read from or to be written to
peripherals, like displays in embedded systems.
Module-3 Arrays and Strings 20/50
Declaring and Initializing Strings
Declaration and Initialization
char str[] = "Hello, World!";
Embedded C Example
char errorMessage[20] = "Error Code: ";
Note
String initialization automatically includes the null terminator.
Module-3 Arrays and Strings 21/50
Reading and Writing Strings
Using Standard I/O Functions
scanf("%s", str);
printf("%s", str);
Embedded C Considerations
In embedded systems, functions like ‘sprintf‘ and ‘sscanf‘ are used for
formatting strings to interact with hardware or protocol messages.
Module-3 Arrays and Strings 22/50
String Manipulation Functions
Common Functions
‘strlen‘ - Get string length
‘strcpy‘ - Copy string
‘strcat‘ - Concatenate strings
‘strcmp‘ - Compare two strings
Embedded Systems Note
Use these functions carefully to avoid buffer overflows, which are critical in
the context of embedded systems with limited memory.
Module-3 Arrays and Strings 23/50
Example: String Concatenation
Concatenating Two Strings
char greeting[50] = "Hello, ";
char name[] = "John";
strcat(greeting, name);
Embedded C Application
String concatenation might be used in embedded systems for creating log
messages or protocol frames.
Module-3 Arrays and Strings 24/50
Functions in C
Definition and Purpose
Functions are reusable blocks of code that perform a specific task. They
help modularize the code, making it more readable and maintainable.
Embedded Systems Context
Functions in embedded systems are used to encapsulate hardware control
operations, algorithms, and routines.
Module-3 Arrays and Strings 25/50
Declaring and Defining Functions
Function Declaration (Prototype)
void functionName(parameters);
Function Definition
void functionName(parameters) {
// Code to execute
}
Note
Function prototypes are often declared in header files, while definitions are
in source files.
Module-3 Arrays and Strings 26/50
Declaring and Defining Functions
Figure: Function Declaration
Module-3 Arrays and Strings 27/50
Calling Functions in C
Calling a Function
functionName(arguments);
Example
void turnOnLED(int ledNumber);
turnOnLED(1); // Turns on LED number 1
Embedded C Tip
Ensure that any functions that interface with hardware are called with the
correct timing and context to avoid system errors.
Module-3 Arrays and Strings 28/50
Calling Functions in C
Module-3 Arrays and Strings 29/50
Passing Parameters to Functions
Parameter Passing
In C, parameters can be passed by value, where a copy of the data is
made, or by reference, using pointers, which allows the function to modify
the original data.
Pass by Value Example
void setTemperature(int temp);
Pass by Reference Example
void resetCounter(int *counter) {
*counter = 0;
}
Module-3 Arrays and Strings 30/50
The Return Statement and Return Types
Returning Values from Functions
Functions in C can return a value. The type of the return value must
match the function’s return type.
Return Statement Example
int getSensorData() {
return sensorValue; // Assume sensorValue is an int
}
Embedded C Application
Functions that interact with hardware components often return status
codes, data readings, or boolean values indicating success or failure.
Module-3 Arrays and Strings 31/50
Example: A Function to Find Maximum Value
Function to Determine the Maximum of Two Integers
int max(int num1, int num2) {
return (num1 > num2) ? num1 : num2;
}
Calling the Function
int a = 5, b = 10;
int maximum = max(a, b);
printf("Maximum: %d", maximum);
Embedded C Usage
Such a function could be used in an embedded system to determine the
highest sensor value, control signal, or other measurement critical to the
system’s operation.
Module-3 Arrays and Strings 32/50
The Stack and Functions: How C Handles Calls
Understanding the Stack
Each function call in C is managed using a stack data structure that stores
parameters, local variables, and return addresses.
Embedded C Consideration
Stack size is limited in embedded systems. Recursive functions or deep
function calls can lead to stack overflow.
Module-3 Arrays and Strings 33/50
Recursion in Functions: Basics
What is Recursion?
Recursion occurs when a function calls itself to solve a problem by
breaking it down into smaller, more manageable sub-problems.
Example: Recursive Function for Factorial
int factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
Embedded C Note
Recursive functions should be used with caution in embedded systems due
to limited stack space.
Module-3 Arrays and Strings 34/50
Example: Recursive Factorial Function
Full Recursive Factorial Program in C
#include <stdio.h>
int factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
int main() {
int num = 5;
printf("Factorial of %d is %d", num, factorial(num));
return 0;
}
Module-3 Arrays and Strings 35/50
Recursion vs. Iteration: Comparative Study
Comparing Recursion and Iteration
Recursion can be more intuitive and easier to write for problems that
naturally fit the recursive pattern.
Iteration is generally more memory-efficient and can be faster because
it does not incur the overhead of multiple function calls.
Embedded Systems Best Practice
Prefer iteration over recursion when working with resource-constrained
embedded systems, unless recursion significantly simplifies the problem.
Module-3 Arrays and Strings 36/50
Introduction to Pointers
What is a Pointer?
A pointer is a variable that stores the memory address of another variable.
Pointers are a powerful feature in C that allow for dynamic memory
management and efficient array handling.
Importance in Embedded Systems
Pointers are critical in embedded systems for interacting with hardware,
managing memory, and optimizing performance.
Module-3 Arrays and Strings 37/50
Declaring and Using Pointers
Module-3 Arrays and Strings 38/50
Declaring and Using Pointers
Pointer Declaration
type *pointerName;
Pointer Usage
int var = 10;
int *ptr = &var;
Embedded C Example
char *bufferPtr; // Pointer to a character buffer
Module-3 Arrays and Strings 39/50
Declaring and Using Pointers
Module-3 Arrays and Strings 40/50
Pointer Arithmetic
Pointer Operations
Pointer arithmetic allows pointers to be incremented or decremented,
effectively moving through an array or block of memory.
Example: Navigating an Array
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr;
for(int i = 0; i < 5; i++) {
printf("%d ", *(ptr + i));
}
Module-3 Arrays and Strings 41/50
Pointers and Arrays
Relationship Between Pointers and Arrays
Arrays in C are closely related to pointers; the array name can be used as a
pointer to the first element.
Example: Array Element Access
int array[3] = {1, 2, 3};
int *ptr = array;
printf("%d", *(ptr + 1)); // Outputs 2, the second element
Module-3 Arrays and Strings 42/50
Pointers and Strings
Using Pointers with Strings
Since strings are arrays of characters, pointers can be used to iterate and
manipulate strings.
Example: String Traversal
char str[] = "Hello";
char *ptr = str;
while(*ptr != ’\0’) {
putchar(*ptr++);
}
Module-3 Arrays and Strings 43/50
Pointers and Strings
Module-3 Arrays and Strings 44/50
Pointers in Functions: Pass-by-Reference
Pass-by-Reference Concept
Passing arguments by reference to a function allows the function to modify the
original value.
Example: Modifying Variables
void increment(int *value) {
(*value)++;
}
int main() {
int num = 5;
increment(&num);
printf("%d", num); // Outputs 6
}
Embedded Systems Application
This technique is frequently used in embedded systems for updating hardware
states or shared variables.
Module-3 Arrays and Strings 45/50
Example: Swapping Two Numbers Using Pointers
Swapping Function
void swap(int *x, int *y) {
int temp = *x;
*x = *y;
*y = temp;
}
int main() {
int a = 10, b = 20;
swap(&a, &b);
printf("a: %d, b: %d", a, b); // Outputs a: 20, b: 10
}
Module-3 Arrays and Strings 46/50
Dynamic Memory Allocation in C
Heap Memory Allocation
Dynamic memory allocation involves managing memory at runtime using
functions like ‘malloc‘, ‘calloc‘, ‘realloc‘, and ‘free‘.
Embedded Systems Consideration
Careful management of dynamic memory is crucial in embedded systems
due to limited memory resources.
Module-3 Arrays and Strings 47/50
References I
Brian W. Kernighan and Dennis M. Ritchie.
The C Programming Language.
Prentice Hall, 2nd Edition, 1988.
The definitive guide to C programming by its original creators.
Stephen Prata.
C Primer Plus.
Pearson Education, 6th Edition, 2013.
Comprehensive guide to C programming, covering basic to advanced
topics.
Module-3 Arrays and Strings 48/50
References II
Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and
Clifford Stein.
Introduction to Algorithms.
MIT Press, 3rd Edition, 2009.
Provides insights into algorithmic thinking relevant to programming
challenges.
Michael Barr.
Programming Embedded Systems in C and C++.
O’Reilly Media, 1999.
A book focusing on embedded systems programming.
Michael J. Pont.
Patterns for Time-Triggered Embedded Systems.
Addison-Wesley, 2001.
Building reliable applications with the 8051 family of microcontrollers.
Module-3 Arrays and Strings 49/50
References III
GeeksforGeeks - C Programming Language.
https://www.geeksforgeeks.org/c-programming-language/
A comprehensive online resource for learning C with examples and
tutorials.
Learn C and C++ Programming - Cprogramming.com.
https://www.cprogramming.com/
An online portal offering tutorials and explanations on C and C++
programming.
Module-3 Arrays and Strings 50/50
