*DISCLAIMER:

“Everything in this document, teaches ONLY what the 2022

CAPE CS syllabus requires @ “Module 3: Programming (C source

code)” (Except “Programming Paradigms, Algorithms &

Translation Process) & it is limited to that alone.

I don’t like coding myself, so that’s why I put together this, for

people like me who have the same interest of being anti-C/C++,

Python,etc… But yuh hadda learn it anyways., So Good Luck, I

hope that this is beneficial to u.”

~ Isaac Ashton Ramdeen

 Table of Contents

Content Breakdown............................................................................................................................................... 5
1. Overview of C Libraries....................................................................................................................................9
Importance and Benefits of Using Libraries......................................................................................................9
Standard C Libraries........................................................................................................................................ 10
Using Library Functions for Common Tasks...................................................................................................11
2. Inputting & Outputting...................................................................................................................................12
Input Functions for Reading Data into Variables.............................................................................................12
Output Functions for Displaying Data on the Screen...................................................................................... 13
Error Handling and Input Validation Techniques............................................................................................ 14
3. Conditional & Iteration Constructs............................................................................................................... 16
Conditional Constructs.....................................................................................................................................16
Iterative Constructs (repetition/looping)..........................................................................................................19
Using Control Structures to Control Program Execution................................................................................ 22
4. Arrays of Type ‘int’ (integer data type)......................................................................................................... 23
Accessing and Manipulating Array Elements..................................................................................................24
Working with Multi-Dimensional Arrays........................................................................................................ 25
Array Traversal and Common Operations....................................................................................................... 27
5. Arrays of Type ‘char’ (character).................................................................................................................. 28
Character Arrays as Strings:............................................................................................................................ 28
String Manipulation Functions:....................................................................................................................... 28
String Input/Output and Formatting:............................................................................................................... 30
Character String Functions.............................................................................................................................. 31
6. Functions...........................................................................................................................................................37
Understanding Functions and their Role in Modular Programming:...............................................................37
Function Declaration, Definition, and Invocation:.......................................................................................... 37
Function Declaration Format:.......................................................................................................................... 38
Passing Arguments to Functions and Returning Values:................................................................................. 39
Recursive Functions and their Applications:................................................................................................... 40
7. Records/Structures (struct).............................................................................................................................41
Introduction to Structures and Their Purpose:................................................................................................. 41
Defining & Declaring Structure Types:........................................................................................................... 41
Accessing Structure Members and Using Dot Notation:.................................................................................42
Working with Arrays of Structures:................................................................................................................. 42
Essential Operations on Structures:................................................................................................................. 43
8. File (Importing & Exporting)......................................................................................................................... 45
File handling operations: opening, closing, reading, and writing files:...........................................................45
 Sequential file processing using file pointers:................................................................................................. 45
*Handling text files and binary files (Not Specific to CAPE Syll.):............................................................... 46
Importing data from files and exporting data to files:..................................................................................... 46
Essential operations used for “File Processing”.............................................................................................. 46
Example of a Program that Utilizes both Structures and File Handling Functions in C:................................ 50
9. Testing & Errors.............................................................................................................................................. 54
Syntax Error:....................................................................................................................................................54
1. Range Testing:............................................................................................................................................. 56
2. Desk Checking:............................................................................................................................................56
10. Programming Style & Documentation.........................................................................................................59
Importance of good programming style and readability:.................................................................................59
Proper indentation, spacing, and naming conventions:................................................................................... 59
Use of comments for code documentation:..................................................................................................... 59
Technical and user documentation practices:.................................................................................................. 60
References:............................................................................................................................................................61
 MODULE 3: PROGRAMMING

Content Breakdown

1. Libraries In C

● Overview of C libraries.

● Importance and benefits of using libraries.

● Standard C libraries: stdio.h, stdlib.h, math.h, etc.

● Using library functions for common tasks such as input/output, mathematical operations, etc.

2. Inputting & Outputting

● Input functions (scanf, fgets, etc.) for reading data into variables.

● Output functions (printf, puts, etc.) for displaying data on the screen.

● Formatting options and modifiers for input/output operations.

● Error handling and input validation techniques.

3. Conditional & Iteration Constructs

● Conditional constructs: if statement, switch statement.

● Iteration constructs: for loop, while loop, do-while loop.

● Using control structures to control the flow of program execution based on certain conditions.

4. Arrays of Type int

● Declaring and initializing integer arrays.

● Accessing and manipulating array elements.

 ● Working with one-dimensional and multi-dimensional arrays.

● Array traversal and common array operations.

5. Arrays of Type char

● Character arrays as strings.

● String manipulation functions (strlen, strcpy, strcat, etc.).

● String input/output and string formatting.

● Character string functions

6. Functions

● Understanding functions and their role in modular programming.

● Function declaration, definition, and invocation.

● Function declaration format

● Passing arguments to functions and returning values.

● Recursive functions and their applications.

7. Records/Structures (struct)

● Introduction to structures and their purpose.

● Declaring and defining structure types.

● Accessing structure members and using dot notation.

● Working with arrays of structures.

● Essential operations on structures

8. File (Importing & Exporting)

● File handling operations: opening, closing, reading, and writing files.

● Sequential file processing using file pointers.

● Handling text files and binary files.

● Importing data from files and exporting data to files.

● Essential operations used for “File Processing”

● Example of a Program that Utilizes both Structures and File Handling Functions in C

9. Testing and Errors

● Errors: Syntax & Semantic

● Range Testing

● Desk Checking

10. Programming Style and Documentation

● Importance of good programming style and readability.

● Proper indentation, spacing, and naming conventions.

● Use of comments for code documentation.

● Technical and user documentation practices.

 1. Overview of C Libraries

C libraries are collections of precompiled functions and declarations that provide a wide range of functionality

to C programs. They contain ready-to-use code that can be included in your program to perform specific tasks,

such as input/output operations, mathematical calculations, memory management, string manipulation, and

more. Libraries serve as a foundation for building programs by providing a set of standardized functions and

definitions that programmers can leverage.

Importance and Benefits of Using Libraries

Using libraries in C programming offers several benefits:

● Code Reusability (encapsulation): Libraries encapsulate commonly used functionality, allowing you to

reuse existing code rather than rewriting it from scratch. This promotes code modularity and reduces the

effort required to develop complex programs.

● Time and Effort Savings (also encapsulation btw): By utilizing libraries, you can save time and effort

by leveraging preexisting, well-tested functions that are already optimized for specific tasks. This

eliminates the need to implement complex algorithms or functionality manually.

● Standardization: C libraries follow standardized interfaces and conventions, ensuring compatibility

across different platforms and systems. This allows programs to be easily ported and run on various

environments without significant modifications.

● Faster Development (abstraction): Libraries provide high-level abstractions and utility functions that

simplify common programming tasks. By using these functions, you can speed up the development

process and focus on solving the specific problem at hand rather than dealing with low-level details.
Standard C Libraries

C programming language has several standard libraries that are widely used in C programming:

● stdio.h: This library provides functions for input and output operations. It includes functions like printf,

scanf, fgets, fopen, fclose, which allow you to read data from the user, display output, and work with

files.

● stdlib.h: The stdlib.h library offers functions for general-purpose tasks, including memory management,

conversion functions, random number generation, and more. Functions like malloc, free, atoi, rand, exit

are part of this library.

● math.h: The math.h library provides mathematical functions for performing various calculations. It

includes functions like sin, cos, sqrt, pow, abs, which enable you to work with trigonometry, logarithms,

exponentiation, and other mathematical operations.

● string.h: The string.h library contains functions for manipulating strings, such as copying,

concatenating, comparing, and searching. Functions like strcpy, strcat, strlen, strcmp are part of this

library.

These are just a few examples of standard C libraries. Depending on the specific requirements of your program,

you may also need to include other libraries that provide additional functionality, such as networking, graphics,

databases, etc.

Using Library Functions for Common Tasks

To use functions from C libraries, you need to include the corresponding library header file using the #include

directive at the beginning of your program. This allows your program to access the function declarations and

definitions from that library.

For example, to use functions from the stdio.h library, you would include the following line at the top of your

program:

#include <stdio.h>

Once you've included the library, you can call the functions provided by that library in your code. For instance,

you can use the printf function from stdio.h to display output to the console:

#include <stdio.h>

int main() {

printf("Hello, world!\n");

return 0;

Here, the printf function from the stdio.h library is used to display the "Hello, world!" message on the screen.
 2. Inputting & Outputting

Input Functions for Reading Data into Variables

In C programming, input functions are used to read data from the user or external sources and store it in

variables. Some commonly used input functions include:

● scanf(): The scanf() function allows you to read formatted input from the user or from a file. It takes a

format string as a parameter, which specifies the expected data format, and assigns the input values to

the specified variables. When using scanf(), you need to use the ampersand sign (&) before the variable

names of integers, real numbers, and characters to indicate the memory address where the input should

be stored. For example:

int age;

scanf ("%d", &age);

This code reads an integer value from the user and stores it in the variable 'age'.

● fgets(): The fgets() function is used to read a line of text from a file or from the user. It takes the

destination buffer and the maximum number of characters to read as parameters. For example:

char name[50];

fgets(name, sizeof(name), stdin);

This code reads a line of text from the user and stores it in the character array (string of char) 'name'.

Output Functions for Displaying Data on the Screen

Output functions in C are used to display data on the screen or write it to a file. The two commonly used output

functions are:

● printf(): The printf() function is used to display formatted output on the screen. It takes a format string

as a parameter, which specifies the desired output format, and additional arguments containing the

values to be displayed. For example:

int num = 10;

printf("The value of num is %d\n", num);

This code displays the value of the variable 'num' as part of the output message.

● puts(): The puts() function is used to display a string of characters on the screen. It takes a string as a

parameter and automatically appends a newline character at the end. For example:

char message[] = "Hello, world!";

puts(message);

This code displays the string "Hello, world!" on the screen.

C provides various formatting options and modifiers that can be used with input and output functions to control

the formatting of data. Some commonly used formatting options include:

● %d: Format specifier for integers.

- scanf("%d",&integer_variable);

● %f: Format specifier for floating-point numbers.

- scanf("%f",&float_variable);

● %s: Format specifier for strings.

- scanf("%s",&string_variable);

● %c: Format specifier for characters.

- scanf("%c",&char_variable);

● %p: Format specifier for pointers.

- scanf("%p",&point_variable);

Error Handling and Input Validation Techniques

Error handling and input validation are important aspects of input/output operations. Here are some techniques

to handle errors and validate user input:

● Checking Return Values: Most input functions return a value (return 0;) indicating the success

or failure of the operation. It is important to check these return values to detect errors and handle them

appropriately.
● Input Validation Loops: Use loops to repeatedly prompt the user for input until valid data is entered.

This helps to ensure that the program does not proceed with incorrect or unexpected input.

● Conditional Statements: Employ conditional statements, such as if-else statements or switch

statements, to validate input based on specific conditions. You can check input ranges, data types, or

other constraints to ensure the entered data is valid.

● *Buffer Management (not specific to CAPE Syll.): When using functions like fgets(), be cautious

about buffer overflow. Ensure that the input does not exceed the size of the destination buffer to prevent

memory-related errors.
 3. Conditional & Iteration Constructs

Conditional Constructs

Conditional constructs allow you to control the flow of program execution based on certain conditions. In C, the

If, If-Else & Case conditional constructs are commonly used:

● IF Control Structure: The IF control structure allows you to execute a block of code if a specified

condition is true. It has the following syntax:

if (condition) {

// code to be executed if the condition is true

Example of the IF Control Structure:

int num = 10;

if (num > 0) {

printf("The number is positive.\n");

● IF-ELSE Control Structure: The if-else control structure allows you to execute one block of code if a

condition is true and another block of code if the condition is false. It has the following syntax:
 if (condition) {

// code to be executed if the condition is true

} else {

// code to be executed if the condition is false

● Case Control Structure: The case control structure, also known as the switch statement, allows you

to select one of many code blocks to be executed based on the value of a variable or an expression (Like

the options in a main menu). It has the following syntax:

switch (expression) {

case value1:

// code to be executed if expression matches value1

break;

case value2:

// code to be executed if expression matches value2

break;

// ...

default:

// code to be executed if expression doesn't match any

value}
Example of the Case Control Structure:

int day = 3;

switch (day) {

case 1:

printf("Monday\n");

break;

case 2:

printf("Tuesday\n");

break;

case 3:

printf("Wednesday\n");

break;

default:

printf("Invalid day\n");

}
Iterative Constructs (repetition/looping)

Iterative constructs allow you to repeat a block of code multiple times until a specified condition is met. In C,

the following iterative constructs are commonly used:

● For Loop: The for loop is used when you know the number of iterations in advance. It has the

following syntax:

for (initialization; condition; update(iteration ++)) {

// code to be executed in each iteration

Example of the For Loop Construct:

for (int i = 1; i <= 5; i++) {

printf("%d\n", i);

In this code, the loop variable i is initialized to 1, and the loop executes as long as the condition i <= 5 is true.

In each iteration, it prints the value of i and updates i by incrementing it.

● While Loop:

- The while loop is used when you want to repeat a block of code based on a condition.

- If the precise moment at which the condition will be met is known, it is called a bounded loop;

if it is unknown, it is called an unbounded loop.

 - The code in a while loop is executed only if the first condition is met; the loop may not be

carried out at all. It has the following syntax:

while (condition) {

// code to be executed in each iteration

Example of the Bounded While Loop Construct:

int counter = 0;

while (counter < 5) {

printf("Iteration: %d\n", counter);

counter++;

In this example, the while loop will execute as long as the counter variable is less than 5. Once the counter

reaches 5, the condition becomes false, and the loop terminates.

Example of the Unbounded While Loop Construct:

char input;

while (1) {

printf("Enter a character (type 'q' to quit): ");

 scanf(" %c", &input);

if (input == 'q') {

break; // Terminate the loop when 'q' is entered

printf("You entered: %c\n", input);

In this example, the while loop continues indefinitely until the user enters the character 'q'. Once 'q' is entered,

the loop is terminated using the break statement.

N.B: An unbounded while loop must have a proper termination condition within the loop body to prevent it

from running infinitely.

● Do-While Loop: The do-while loop is similar to the while loop but guarantees that the block of code is

executed at least once before checking the condition. It has the following syntax:

do {

// code to be executed in each iteration

} while (condition);
Example of the Do While Loop Construct:

int i = 1;

do {

printf("%d\n", i);

i++;

} while (i <= 5);

In this code, the loop executes the code block at least once and then checks the condition i <= 5. If the

condition is true, it continues executing the loop.

Using Control Structures to Control Program Execution

Conditional and iteration constructs provide you with control structures that enable you to control the flow of

program execution based on conditions.

By using if statements, switch statements, for loops, while loops, and do-while loops, you can make decisions,

repeat code, and control the execution path of the program.

These control structures allow you to handle different scenarios, execute specific code blocks based on

conditions, and create loops to iterate over data or perform repetitive tasks. They give you the flexibility to

make your program more dynamic and responsive.

 4. Arrays of Type ‘int’ (integer data type)

An array is a collection of elements of the same data type. In C, arrays are zero-indexed, meaning the first

element is positioned at index 0. Here's an example showing the positioning of the first array at 0, the second

array at 1, and so on:

Name myArray [5]

Position (index) 0 1 2 3 4

Member 10 20 30 40 50

Integer (int) Arrays are declared as follows:

int myArray[5]; // Declaration of an integer array with 5 elements

int myArray[] = {10, 20, 30, 40, 50}; // Declaration and

initialization of an integer array with 5 elements

Accessing and Manipulating Array Elements

Array elements can be accessed and manipulated using their indices. Here's an example:

int myArray[5] = {10, 20, 30, 40, 50};

// Accessing array elements

int element1 = myArray[0]; // Accessing the first element (10)

int element3 = myArray[2]; // Accessing the third element (30)

// Modifying array elements

myArray[1] = 25; // Modifying the second element (20) to 25

myArray[3] = myArray[3] + 10; // Adding 10 to the fourth element (40)

Working with Multi-Dimensional Arrays

A multi-dimensional array is an array with more than one dimension. It is like having arrays within arrays.

For example, a two-dimensional array, also known as a matrix, can be declared and initialized as follows:

int matrix[3][3]; // Declaration of a 2D integer array with 3 rows

and 3 columns

int matrix[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; //

Declaration and initialization of a 2D integer array

In the table below, the 2D integer array named matrix from above is shown. Each member of the array is

identified by its position (index), denoted as [row][column], and listed in the "Member" column.

Name matrix [3,3]

Position [0,0] [0,1] [0,2] [1,1] [1,2] [1,3] [2,1] [2,2] [2,3]
(index)

Member 1 2 3 4 5 6 7 8 9
To access elements in a multi-dimensional array, multiple indices must be used.For example:

int matrix[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

int element = matrix[1][2]; // Accessing the element at row 1, column

2 (6)

Working with multi-dimensional arrays allows the organization and manipulation of data in a tabular or

grid-like structure. By understanding the indexing scheme and accessing elements using multiple indices, you

can effectively work with multi-dimensional arrays in C.

Array Traversal and Common Operations

Array traversal involves accessing and processing each element in an array. Common operations on arrays

include finding the minimum or maximum element, calculating the sum or average, searching for a specific

value, and sorting. Here's an example of finding the maximum element in an array:

int numbers[] = {5, 10, 15, 20, 25};

int size = sizeof(numbers) / sizeof(numbers[0]); // Calculating the

size of the array

int max = numbers[0]; // Assume the first element is the maximum

for (int i = 1; i < size; i++) {

if (numbers[i] > max) {

max = numbers[i]; // Update the maximum if a larger element

is found

printf("Maximum element: %d\n", max);

This example demonstrates how to traverse the array numbers and find the maximum element.
 5. Arrays of Type ‘char’ (character)

In C, character arrays are often used to represent strings. A string is a sequence of characters terminated by a

null character ('\0'). By understanding how to work with character arrays as strings, utilize string manipulation

functions, and perform string input/output and formatting, you'll have the necessary skills to handle text-based

data efficiently.

Character Arrays as Strings:

Character arrays can be used to store and manipulate strings in C. Here's an example of declaring and

initializing a character array as a string:

char myString[10] = "Hello"; // Declaration and initialization of a

character array as a string

In the example above, myString is a character array that can hold up to 10 characters, including the null

character. It is initialized with the string "Hello". Keep in mind that the size of the array should be large enough

to accommodate the string and the null character.

String Manipulation Functions:

C provides several string manipulation functions that allow you to perform various operations on strings. Some

commonly used functions include:

● strlen(): Calculates the length of a string.

● strcpy(): Copies one string to another.

● strcat(): Concatenates two strings.

 ● strcmp(): Compares two strings.

These functions are part of the string.h library. Here's an example that demonstrates the use of strlen() and

strcpy():

#include <stdio.h>

#include <string.h>

int main() {

char source[] = "Hello";

char destination[20];

int length = strlen(source);

strcpy(destination, source);

printf("Length: %d\n", length);

printf("Copied string: %s\n", destination);

return 0;

In the example above, strlen() calculates the length of the source string, and strcpy() copies the source string to

the destination string.

String Input/Output and Formatting:

C provides input/output functions specifically designed for strings. For input, scanf() can be used with the %s

format specifier to read a string from the user. For output, printf() can be used with the %s format specifier to

display a string.

Here's an example:

#include <stdio.h>

int main() {

char name[20];

printf("Enter your name: ");

scanf("%s", name);

printf("Hello, %s!\n", name);

return 0;

In the example above, scanf("%s", name) reads a string from the user and stores it in the name array. The

printf() statement then displays a greeting message using the entered name.
Additionally, C provides various formatting options to control how strings are displayed. For example, you can

use the %10s format specifier to specify a minimum field width of 10 characters when printing a string.

Character String Functions

In C, character arrays are often used to represent strings. Understanding how to declare, assign values to, output,

manipulate, and perform various operations on character arrays will allow you to effectively work with strings

in your programs.

Char String Function Use

strlen To determine the length of a string.

strcpy To copy the content of one string to another.

strcat To concatenate (combine) two strings.

strcmp To compare two strings and determine their relative

order.

strchr To locate the first occurrence of a character in a

string.

strstr To locate the first occurrence of a substring in a

string.

strncpy To copy a specific number of characters from one

string to another.

strncat To concatenate (combine) a specific number of

characters from one string to another

strncmp To compare a specific number of characters of two

strings.

strtok To tokenize (split) a string into smaller strings based

on delimiters.
 1. To Declare a Character Array (String Variable):

char myString[SIZE];

Example:

char name[20];

This code declares a character array named name with a size of 20, capable of holding a string of characters.

2. To Assign a Value to a Member of a String Variable:

myString[index] = value;

Example:

name[0] = 'J';

This code assigns the character 'J' to the first element of the name array.

3. To Assign a Value to a String Variable:

strcpy(myString, "value");

Example:

strcpy(name, "John");

This code assigns the string "John" to the name array using the strcpy function.

4. To Output the Value of the String Variable:

printf("%s", myString);

Example:

printf("Name: %s\n", name);

This code outputs the value of the name array, which represents a string.

5. To Output a Single Character from a String Variable:

printf("%c", myString[index]);

Example:

printf("First character: %c\n", name[0]);

This code outputs the first character of the name array.

6. To Create an Array of String Variables:

char myArray[NUM_STRINGS][SIZE];

Example:

char fruits[3][10];

This code creates a 2-dimensional character array named fruits, capable of holding 3 strings with a maximum

size of 10 characters each.

 7. To Add User-Entered Data to an Array of String Variables:

scanf("%s", myArray[index]);

Example:

scanf("%s", fruits[0]);

This code reads a string from the user and stores it in the first element of the fruits array.

8. To Determine the Length of a String Variable:

strlen(myString);

Example:

int length = strlen(name);

This code calculates and stores the length of the name string in the variable length using the strlen function.

9. To Compare Two (2) String Variables to Determine if they are the same:

if (strcmp(string1, string2) == 0){

//printf statement;

Example:

if (strcmp(name1, name2) == 0) {

printf("The names are the same.\n");

}

This code compares the strings name1 and name2 using the strcmp function and if construct. If the return value

is 0, the strings are the same.

10. To Concatenate (combine) Two (2) String Variables:

strcat(destination, source);

Example:

char greeting[50] = "Hello";

char name[20] = "John";

strcat(greeting, name);

This code concatenates the string in the name array to the end of the string in the greeting array using the

strcat function.

11. To Copy the Content of One (1) String Variable to Another String Variable:

strcpy(destination, source);

Example:

char source[10] = "Hello";

char destination[10];

strcpy(destination, source);

This code copies the content of the source array to the destination array using the strcpy function.
The Following Program Code Shows how a String Variable is Traversed, so as to Determine if any of the

Vowels are Present:

#include <stdio.h>

#include <string.h>

int main() {

char word[20];

printf("Enter a word: ");

scanf("%s", word);

int length = strlen(word);

int i;

for (i = 0; i < length; i++) {

if (word[i] == 'a' || word[i] == 'e' || word[i] == 'i' || word[i]

== 'o' || word[i] == 'u') {

printf("Vowel found: %c\n", word[i]);

return 0

This program prompts the user to enter a word, and then it traverses the characters of the word to determine if

any vowels are present. If a vowel is found, it is printed to the console.

 6. Functions

Understanding Functions and their Role in Modular Programming:

Functions are an essential concept in modular programming. They allow you to break down a program into

smaller, manageable, and reusable pieces of code. Functions encapsulate a set of instructions and can be called

from different parts of a program whenever needed. This modular approach promotes code reusability,

readability, and maintainability.

Function Declaration, Definition, and Invocation:

● Function Declaration: A function declaration informs the compiler about the existence of a function,

its name, return type, and the types of parameters it accepts. It serves as a prototype for the function.

Example:

int add(int a, int b); // Function declaration

● Function Definition: The function definition contains the actual implementation of the function. It

specifies the return type, function name, and the body of the function that contains a set of

instructions.

Example:

int add(int a, int b) { // Function definition

int sum = a + b;

return sum;

}
 ● Function Invocation: To use a function, you invoke/call it by its name, passing the required arguments

(if any). The function executes its code and may return a value.

Example:

int result = add(5, 3); // Function invocation

Function Declaration Format:

In C, functions are declared using the following format:

return_type function_name(datatype parameter_name)

● return_type: Specifies the data type of the value the function returns. It can be void if the function does

not return a value.

● function_name: Represents the name of the function, which should be unique within the program.

● (datatype parameter_name): Specifies the data type and name of the parameters the function accepts.

Parameters are optional, and multiple parameters can be separated by commas.

Including these elements in a function declaration is crucial as it provides essential information to the compiler

and other developers working with the code. It clarifies the expected return type, function name, and the types

of arguments the function can accept.

Passing Arguments to Functions and Returning Values:

Passing Arguments: Functions can accept parameters/arguments, which are values passed to the function when

it is called. Arguments provide input data for the function to work with.

Example:

void greetUser(char name[]) {

printf("Hello, %s!\n", name);

The function greetUser takes a character array name as an argument and prints a personalized greeting

message.

● Returning Values: Functions can also return a value to the calling code. The return type specified in

the function declaration indicates the type of the value the function will return. Use the return statement

to provide the value.

Example:

int square(int num) {

int result = num * num;

return result;

The function square takes an integer num as an argument, calculates its square, and returns the result.
Recursive Functions and their Applications:

A recursive function is a function that calls itself from within its own body. It enables solving complex

problems by breaking them down into smaller, similar sub-problems. Recursive functions have two

components: base case(s) and recursive case(s).

Example:

int factorial(int n) {

if (n == 0) {

return 1; // Base case: factorial of 0 is 1

} else {

return n * factorial(n - 1); // Recursive case: n * (n-1)!

The function factorial calculates the factorial of a given number n using recursion. The base case is when n is

0, returning 1. In the recursive case, the function calls itself with n-1 and multiplies the result by n.

Recursive functions are commonly used in algorithms such as tree traversal, sorting (e.g., quicksort), and

searching (e.g., binary search).

Functions play a vital role in structuring programs, promoting code reuse, and managing complexity. They

allow you to break down problems into smaller tasks and encapsulate logic within self-contained units of code,

making your programs more modular and easier to understand and maintain.
 7. Records/Structures (struct)

Introduction to Structures and Their Purpose:

Structures, also known as records, are user-defined data types in C that allow you to combine different types of

variables under a single name. They provide a way to represent a collection of related data items as a single

unit. Structures are useful when you need to organize and manipulate data that has different properties but

belongs together conceptually.

Defining & Declaring Structure Types:

Declaring a Structure Type: To declare a structure type, you use the struct keyword followed by the structure

name. Inside the structure, you define the members (variables) that make up the structure.

● Example:

struct Person {

char name[50];

int age;

float salary;

};
Defining Structure Variables: After declaring a structure type, you can define variables of that type by

specifying the structure name followed by the variable name.

Example:

struct Person employee1;

struct Person employee2;

Accessing Structure Members and Using Dot Notation:

Structure members are accessed using the dot notation (.), which allows you to access individual members of

a structure variable.

Example:

strcpy(employee1.name, "John Doe");

employee1.age = 30;

employee1.salary = 5000.0;

Working with Arrays of Structures:

You can create arrays of structures to store multiple records of the same structure type. This allows you to

work with collections of related data efficiently.

Example:

struct Person employees[5];

Essential Operations on Structures:

1. To Declare a New Instance of Type "record_name": To declare a new instance of a structure type, use

the structure name followed by the variable name.

Example:

struct Person employee3;

This code declares a new instance of the Person structure named employee3. It creates a variable of type

Person that can hold data for an individual person, such as their name, age, and salary.

2. To Assign Values to Data Fields in a Record in C: Use the dot notation to assign values to the data

fields of a structure variable.

Example:

employee2.age = 25;

This code assigns the value 25 to the age field of the employee2 structure.

3. To Declare an Array of a particular Record in C: Use the structure name followed by the array

name and size.

Example:

struct Person employees[5];

This code declares an array employees of type Person with a size of 5. It creates an array that can store

information for multiple employees, with each element of the array being a Person structure.
 4. To Assign Values to Data Fields in an Array of Records in C: Use the dot notation and array

indexing to assign values to the data fields of individual structures within the array.

Example:

employees[0].salary = 6000.0;

This code assigns the value 6000.0 to the salary field of the first structure in the employees array.

5. To Assign All the Values of one (1) Instance of a Record to another Instance: Use the assignment

operator (=) to assign the values from one structure to another.

Example:

employee2 = employee1;

This code assigns all the values of the employee1 structure to the employee2 structure.

6. To Pass a Record to a Function: Declare a function parameter with the structure type, and pass the

structure variable as an argument when calling the function.

Example:

void displayEmployee(struct Person emp) {

printf("Name: %s\n", emp.name);

printf("Age: %d\n", emp.age);

printf("Salary: %.2f\n", emp.salary);

This code defines a function displayEmployee that takes a Person structure as a parameter and displays its

contents.
 8. File (Importing & Exporting)

File handling operations: opening, closing, reading, and writing files:

● Opening a file: In C, you can use the fopen() function to open a file. It takes two parameters: the file

name and the mode (e.g., "r" for reading, "w" for writing, "a" for appending). The function returns a file

pointer that can be used to access the file.

● Closing a file: To close a file, you can use the fclose() function and pass it the file pointer. This step is

essential to release system resources and ensure that all data is properly written to the file.

● Reading from a file: To read data from a file, you can use functions such as fscanf() or fgets(). These

functions allow you to read data from the file and store it in variables or character arrays.

● Writing to a file: To write data to a file, you can use functions such as fprintf() or fputs(). These

functions allow you to format and write data to the file.

Sequential file processing using file pointers:

● File pointers: In C, a file pointer is a special variable that points to a specific location in a file. It

keeps track of the current position for reading or writing data. You can declare a file pointer

using the FILE data type.

● Sequential file processing: Sequential file processing involves reading or writing data in a

sequential manner from the beginning of the file to the end, or vice versa. You can use loops and

file handling functions to perform sequential file processing operations.

*Handling text files and binary files (Not Specific to CAPE Syll.):

● Text files: Text files store data in plain text format, where each character is represented by its

corresponding ASCII value. Text files are human-readable and can be edited with a text editor.

● Binary files: Binary files store data in a binary format, which means that the data is represented

in its raw binary form. Binary files are not human-readable and often contain complex data

structures or binary representations of data.

Importing data from files and exporting data to files:

● Importing data from files: You can import data from files by opening the file in read mode and

using appropriate file reading functions. The data can be read and stored in variables or data

structures for further processing in the program.

● Exporting data to files: You can export data to files by opening the file in write mode or append

mode and using appropriate file writing functions. The data can be formatted and written to the

file for storage or future use.

Essential operations used for “File Processing”

1. To Declare a File in C:

Example:

FILE *filePointer;

In C, you can declare a file using the FILE data type and a file pointer. The file pointer will be used to access

the file and perform file handling operations.

 2. To Open a File in "Read-Only" Mode:

● Example:

FILE *filePointer;

filePointer = fopen("filename.txt", "r");

To open a file in "read-only" mode, you can use the fopen() function with the file name and the mode "r". This

allows you to read data from the file.

3. To Open a File in "Write-Only" Mode:

● Example:

FILE *filePointer;

filePointer = fopen("filename.txt", "w");

To open a file in "write-only" mode, you can use the fopen() function with the file name and the mode "w". This

allows you to write data to the file. If the file already exists, its previous content will be overwritten.

4. To Write to a File:

● Example:

FILE *filePointer;
filePointer = fopen("filename.txt", "w");

fprintf(filePointer, "This is a line of text.\n");

After opening a file in "write-only" mode, you can use the fprintf() function to write data to the file. The data is

formatted and written to the file using the file pointer.

5. To Read from a File:

● Example code:

FILE *filePointer;

filePointer = fopen("filename.txt", "r");

char buffer[100];

fgets(buffer, sizeof(buffer), filePointer);

After opening a file in "read-only" mode, you can use the fgets() function to read data from the file. The data is

read into a character array (buffer in this example) using the file pointer.
 6. To Close a File:

● Example:

FILE *filePointer;

filePointer = fopen("filename.txt", "r");

// Perform file operations

fclose(filePointer);

To close a file, you can use the fclose() function and pass it the file pointer. This step is important to release

system resources and ensure proper handling of the file.

7. To Check if a File is Empty:

● Example:

FILE *filePointer;

filePointer = fopen("filename.txt", "r");

if (filePointer == NULL) {

printf("File does not exist.\n");

exit(0);

If the file pointer is NULL after attempting to open the file. If the file pointer is NULL, it means the file does

not exist or could not be opened for some reason. In such cases, we display an appropriate message to the user

and exit the program using exit(0) to terminate the execution.

 8. To utilize the "End-Of-File" functionality:

● Example:

FILE *filePointer;

filePointer = fopen("filename.txt", "r");

int data;

while (fscanf(filePointer, "%d", &data) != EOF) {

// Process the data

When reading data from a file, you can use the fscanf() function inside a loop. The function returns the number

of successful conversions, and when it reaches the end of the file, it returns EOF (End-Of-File) which can be

used as a condition to terminate the loop.

Example of a Program that Utilizes both Structures and File Handling Functions in C:

The program on the following page, allows the user to enter the names, ages, and averages of five (5) students.

The information is then stored in a file called "students.txt" using the fprintf() function. Later, the program

reads the data from the file using fscanf() and displays it to the user using printf(), A FULL Explanation of

EACH element in the code will be ont the following page, after the code:
#include <stdio.h>

struct Student {

char name[50];

int age;

float average;

};

int main() {

FILE *filePointer;

filePointer = fopen("students.txt", "w"); // Open the file in

write mode

if (filePointer == NULL) {

printf("Error opening the file.\n");

return 1;

struct Student student;

for (int i = 1; i <= 5; i++) {

printf("Enter name, age, and average for student %d:\n", i);

 scanf("%s %d %f", student.name, &student.age,

&student.average);

fprintf(filePointer, "%s %d %.2f\n", student.name,

student.age, student.average); // Write student data to the file

fclose(filePointer); // Close the file

filePointer = fopen("students.txt", "r"); // Open the file in

read mode

if (filePointer == NULL) {

printf("Error opening the file.\n");

return 1;

printf("\nStudent Information:\n");

while (fscanf(filePointer, "%s %d %f", student.name,

&student.age, &student.average) != EOF) {

printf("Name: %s, Age: %d, Average: %.2f\n", student.name,

student.age, student.average); // Read and display student data from

the file

}
 fclose(filePointer); // Close the file

return 0;

Explanation:

● The code defines a structure Student to store information about a student.

● The main() function is the entry point of the program.

● The filePointer is a pointer to a FILE object, which will be used to handle the file.

● The code opens the file "students.txt" in write mode using fopen() and checks if the file was

successfully opened. If not, it displays an error message and returns 1 to indicate an error.

● The program then prompts the user to enter the name, age, and average for five students using a loop.

The data entered by the user is written to the file using fprintf().

● After writing the data, the file is closed using fclose().

● The code opens the file "students.txt" again, but this time in read mode.

● It then reads the student information from the file using fscanf() in a loop until the end of the file

(EOF) is reached. The data is read into the student structure and displayed on the console.

● Finally, the file is closed again using fclose().

● The program returns 0 to indicate successful execution.

 9. Testing & Errors

Syntax Error:

1. A syntax error occurs when the code violates the rules of the programming language, resulting in a

compilation error.

#include <stdio.h>

int main() {

printf("Hello, World!\n") // Missing semicolon at the end of the

statement

return 0;

In this example, the missing semicolon at the end of the printf statement is a syntax error. The code will not

compile and will produce a syntax error message.

Semantic Error:

2. A semantic error occurs when the code is grammatically correct but produces unintended or incorrect

results.

#include <stdio.h>

int main() {

int a = 5;

int b = 0;

int result;

result = a / b; // Division by zero

printf("Result: %d\n", result);

return 0;

In this example, the division by zero is a semantic error. The code will compile and run without any syntax

errors, but it will produce an error at runtime due to the attempted division by zero.

Semantic errors can also occur when the logic of the code is incorrect, leading to unintended behavior or

incorrect results. These errors often require thorough testing and debugging to identify and resolve.
1. Range Testing:

● Range testing involves validating input data to ensure it falls within the expected range. It helps

identify potential errors caused by invalid or out-of-bounds values.

● For example, if a function expects an integer input between 1 and 10, range testing involves

checking if the provided value is within that range before performing any further operations.

2. Desk Checking:

● Desk checking is a manual method of testing code by mentally executing the code on paper or

using a debugger, step by step, to verify its correctness.

● It involves analyzing the code line by line, tracking variable values, and evaluating the expected

outcomes at each step.

● By carefully examining the code and its execution, desk checking helps identify logic errors,

incorrect calculations, or unexpected behavior.

Example of Desk Checking:

Consider the following code snippet:

#include <stdio.h>

int main() {

int a = 5;

int b = 3;

int result;

result = a + b;

printf("Result: %d\n", result);

return 0;

}
Desk Checking:

1. Assign a a value of 5.

2. Assign b a value of 3.

3. Declare result.

4. Compute a + b and assign the result to result.

5. Print the value of result, which is the sum of a and b.

Output: "Result: 8" (since 5 + 3 = 8)

By going through this process of desk checking, you can verify the correctness of the code manually before

running it. It allows you to catch potential errors, trace the flow of execution, and ensure the expected results are

produced.
 10. Programming Style & Documentation

Importance of good programming style and readability:

1. Good programming style and readability are essential for creating maintainable, understandable, and

bug-free code. A well-written code is easier to comprehend, debug, and modify. It enhances

collaboration among developers and improves the overall quality of the software. By following good

programming style practices, you ensure that your code is clean, consistent, and easy to follow.

Proper indentation, spacing, and naming conventions:

2. Indentation and spacing are used to visually structure the code and make it more readable. Consistent

indentation, such as using spaces or tabs, helps in visually identifying code blocks and nested structures.

Proper spacing around operators, commas, and parentheses improves code clarity.

Naming conventions play a vital role in code readability. Choosing meaningful and descriptive names

for variables, functions, and other identifiers makes the code self-explanatory. It is recommended to use

camel case (e.g., myVariable) or underscores (e.g., my_variable) for naming variables and functions.

Use of comments for code documentation:

3. Comments are used to provide explanations, clarifications, and documentation within the code. They

help other developers (including yourself in the future) understand the purpose, logic, and usage of

various parts of the code. Comments should be used to describe complex algorithms, summarize code

sections, and highlight important details. It is essential to maintain comments and update them as the

code evolves.
Technical and user documentation practices:

4. Technical documentation focuses on explaining the inner workings of the code, such as APIs, libraries,

and modules. It includes information about functions, data structures, input/output formats, and error

handling. Technical documentation is often created using tools like Javadoc, Doxygen, or Markdown,

and it helps other developers understand how to use and contribute to the codebase.

User documentation aims to provide instructions and guidance for end-users of the software. It includes

user manuals, installation guides, FAQs, and tutorials. User documentation should be written in a clear

and accessible language, avoiding technical jargon as much as possible.

 References:

Chat GPT. (n.d.). [Online conversation]. OpenAI.

West, J. O. (2013). Computer Science for CAPE® Examinations UNIT 1. Caribbean Educational Publishers.