Lesson slides for C programming course

1© 2018 The Knowledge Academy Ltd
C Programming

Project Management,
Management
& Leadership
About The Knowledge Academy
• World Class Training Solutions
• Subject Matter Experts
• Highest Quality Training Material
• Accelerated Learning Techniques
• Project, Programme, and Change
Management, ITIL® Consultancy
• Bespoke Tailor Made Training Solutions
• PRINCE2®, MSP®, ITIL®, Soft Skills, and More

• Trainer
• Fire Procedures
• Facilities
• Days/Times
• Breaks
• Special Needs
• Delegate ID Check
• Phones and Mobile Devices
Administration

• What is a program?
• (De)constructing a simple program
• Variables and Constants
• Operators and Terminologies
• Constructs
• Arrays
• Strings
Outline day 1

• A bit of C programming history…
• Functions
• Pointers
• Structures
• Operating Bigger Programs
Outline day 2

What is a program?

A program is
a recipe!

Analyse this:

Main Kitchen
(RETURNS hot sauce) Sous-chef sauce kitchen (can take in and )
Grind meat (using meat grinder)
Read recipe book no.1
Boil pasta and veggies. Use blender for veggies.
Cook meat in butter. Add salt and a touch of wine.
Ask Sous-chef sauce kitchen to make hot sauce! (send sous-chef some and some )
Hot sauce received.
Meal ready and sent to customer!
Heat up butter in milk.
Use blender to chop up chillies.
Add salt and red wine.
Send hot sauce to main kitchen!

Notion 1: GLOBAL vs LOCAL
GLOBAL ingredients
(that can be used from any kitchen)
LOCAL ingredients
(that can only be used one specific kitchen)

(in programming terms…)
GLOBAL variables = variables that can be read from any
function
LOCAL variables = variables that can only be read from
the function where they are declared
(as we can see: some local variables can be sent from one function to another. We will have a
closer look at this on Day 2)

Notion 2: main structure of a C program
Headers, pre-processor directives, global/constant variables, function prototypes…
Main function
Function A
Function B

Analyse this…

Project Management,
Management
& Leadership

in fact…
Headers, pre-processor directives, global/constant variables, function prototypes…
Documentation
Main function
Function A
Function B

Analyse this…

/*
Documentation section
C programming basics & structure of C programmes
Author: theknowledgecacademy.com
Date: 06/11/2018
*/
#include <stdio.h> /* Link section */
int total = 0; /* Global declaration, definition section */
int sum = (int, int); /* Function declaration section */
int main () /* Main function */
{
printf (“This is a C basic programme n”);
total = sum (1, 1);
printf (“Sum of two numbers : %d n”, total)l
return 0;
}
int sum (int a, int b) /* User defined function */
{
return a + b; /* definition section */
}

RECAP
In general, most C programs use the following structure:
• Documentation section (if necessary)
• Pre-processors directives and/or header files and/or global variable
declarations and/or function prototypes…
• Main() function  absolutely mandatory!!!
• Other functions (if necessary)

Project Management,
Management
& Leadership
(De)constructing a simple program

Let’s start by typing this code in:
#include <stdio.h>
int main()
{
printf(“Hello, World!n”);
return 0;
}

• We are going to start by writing the
basic program "Hello World”, which
will print (or output) the message
"Hello, World!" on screen
• This is a very simple program
designed to help you understand the
syntax of C
• We will break down each component
line by line and explain its function
#include <stdio.h>
int main()
{
return 0;
}

(De)constructing a simple program:
line 1
• The first line is the #include command,
followed by <stdio.h>
• stdio.h is a header file containing
standard input and output functions for
the program (such as printf)
• Without this file, input and output
functions will not work and the program
will not compile
#include <stdio.h>
int main()
{
return 0;
}

more on line 1
• the #include command is in fact called a pre-processor directive
• Pre-processor directives tell the compiler how to modify the code before it is
compiled
• This is the section where header files (here: <stdio.h>) are placed in the system
library to access predefined functions
• We include files using #include followed by the name of the file in < >
• All header files end in .h
• Pre-processors are specified using the # directive

(De)constructing a simple rogram:
more on line 1
• Examples include:
#include
<stdio.h>
#define pi=3.14 #undefine pi #ifdef

line 2
• The next line is the start of the int main()
function (notice the curly brackets {…})
• This int main() may or may not have
other elements (called arguments) inside
its (…) (but we won’t talk about this)
• As with any other function, int placed
before main() means that the main()
function returns a value once all of the
contents inside its {…} has been
processed  we can see this on the last
line, where it is said: return 0
#include <stdio.h>
int main()
{
return 0;
}

more on line 2
• The main() function defines where the C
program starts.
• Regardless of where it is placed, it is
always the first function executed when
the program starts.
• This main() function is mandatory for
any C program, as all other functions are
called from it.
#include <stdio.h>
int main()
{
return 0;
}

line 3
• The printf() function displays the text
inside quotation marks (“Hello, World!”)
• It is a library function that sends the
output to the screen
• Printf() will not work without stdio.h
• /n is an escape sequence, which
essentially represents a newline
character for the “Hello, World!” string
#include <stdio.h>
int main()
{
return 0;
}

line 4
The program ends when the
return statement is encountered
within the main() function (but it
in this very rare case, it is not
mandatory)
‘0’ provides an exit status,
showing that the program
executed successfully with no
errors
#include <stdio.h>
int main()
{
return 0;
}

How it all runs
The following steps are used in every C program – whether small or large – to generate an
output:
Create Compile Execute or run Get the output

Note on the notion of compiling
• Compiling means converting C code into machine language that can be
read and understood by the computer
• Popular C compilers include GCC (Linux), Visual C++ (Windows), Turbo C,
and Borland C
• Once the .C program has been compiled, a new file with the same name
but the extension .EXE is generated
• It is this .EXE file that is executed

Exercise!
Write a short C program where five statements of your
choice are printed out.
Watch out! Each statement must start on a new line!

Project Management,
Management
& Leadership

The fascinating world of variables

What is a variable?
First and foremost, a variable is a memory location, the
name of which (“cat”, “var1”, “loopiloo”…) is decided
by the programmer.
This memory location contains a specific type of data
(confirmed through its declaration), the size and layout
of which is precisely determined by the type.
A variable can have its contents changed at any time
(as long as it is of the same type)
(NOTE: we will talk more about memory when we talk
about pointers)
RAM
8
Memory location
a is reserved

Two sorts of memory locations
There are two types of memory locations:
- Variables: memory locations whose contents can change during the
execution of a program
- Constants: memory locations whose contents cannot be changed while the
program is executing (the use of const determines when a variable is a
constant)
See example:

Project Management,
Management
& Leadership

Try and change the value of a const variable!!

Project Management,
Management
& Leadership

4 main Data Types
Before we can use a variable in C we must declare it. When we declare it, we
tell the computer what data type it is.
There are 4 basic data types:
• int – an integer, or a whole number
• char – a single character
• float – decimals, numbers with a ‘floating point’ value up to 7 digits
• double – a more precise version of float up to 15 digits

Real purpose of declaring a variable
When we declare a variable, we in fact inform the computer how much
memory space we require for this variable!
This memory space is generally in bytes (remember: 1 byte = 8 bits)
Try the following to know the amount of memory required for each type of
variable…

Project Management,
Management
& Leadership

Various rules for naming variables
• A variable’s name can only start with a letter or underscore; it will not accept
integers
• Able to contain letters, integers, and underscores though!
• Reserved word/keyword (e.g. char, float) cannot be used for variable’s name
• No whitespace is permitted

2 ways of declaring variables
(manually)
Technique 1:
Technique 2: int age, yearOfBirth, population;
int age;
int yearOfBirth;
int population;

Initialising variables: how it is done
Now that we have seen how to declare a variable (ie: to inform the computer
of the amount of memory space required for the variables we wish to use),
the time now comes to place values inside these variables!
This is called: initialisation, and it is done through the symbol =
WARNING: as we shall see, the = symbol does not mean ‘equal’!

2 ways of initialising variables
(manually)
Technique 1:
Technique 2: FirstNumber = SecondNumber = ThirdNumber = 24;
FirstNumber = 24;
SecondNumber = 24;
ThirdNumber = 24;

Declaring + initialising variables all in one go
(manually)
int FirstNumber = 24, SecondNumber = 45, ThirdNumber = 9001;

Rules for declaring variables
• Declared variables cannot be changed, as shown below
• int cannot be changed to floating point 5.5, nor can it be changed to a double
number
• Error generated as a result of this
int number = 5; // integer variable
number – 5.5; // error
double number; // error

Example of
LOCAL variable
declaration &
initialisation

Example of
GLOBAL
variable
declaration &
initialisation

Initialising variables
(user)
To enable users to test your program by entering whatever value they want, the scanf() function
must be used.
The syntax is as follows:

Format identifiers(1)
Notice the “…%” expression, when we use scanf()?
This is to enable the real-time input of values through
scanf().
This expression is called a format identifier.

Format identifiers(2)

Format identifiers - examples
#include <stdio.h>
int main()
{
char ch = 'A';
printf("%cn", ch);
return 0;
}
#include <stdio.h>
int main()
{
float a = 12.67;
printf("%fn", a);
printf("%en", a);
return 0;
}

Project Management,
Management
& Leadership
Operators and Terminologies

Operators
An operator in C is a symbol that tells
the compiler to perform a specific
mathematical or logical function.
The C language has many built-in
operators, such as:
• Arithmetic Operators
• Relational Operators
• Logical Operators
• Assignment Operators
• Bitwise Operators
• Misc Operators

Operators
The various Arithmetic Operators in C are:
Operator Description Example
+ Adds two numbers A+B= 20
- Subtracts second
number from the
first
A-B=10
* Multiplies both
numbers
A*B=200
/ Divides two numbers A/B=10
% Finds the remainder
after division
B%A=0

Operators
Relational Operators
== Checks if the values of two numbers
are equal or not. If yes, then the
condition becomes true
A==B is not true
!= Checks if the values of two numbers
are equal or not.
If the values are not equal, then the
(A != B) is true
> Checks if the value of left number is
greater than the value of right
number. If yes, then the condition
becomes true
(A > B) is not true
These are used to check the relationship between two numbers.

Operators
Arithmetic Unary Operators
++ Increment operator
– increases a
number by 1
A++
--
Decrement operator
– decreases a
number by 1
A--

Operators
Relational Operators
< Checks if the value of left number
is less than the value of right
number. If yes, the condition
becomes true
(A < B) is true
>= Checks if the value of left number
is greater than or equal to the
value of right number. If yes, the
(A >= B) is not true
<= Checks if the value of left number is
less than or equal to the value of
right number. If yes, the condition
becomes true
(A <= B) is true

Operators
Logical Operators
&& Logical AND Operator – if both numbers are
true, then the condition becomes true
(A && B) is false
|| Logical OR Operator – if any of the two
numbers is true, then the condition
becomes true
(A || B) is true
! Logical NOT Operator – if the numbers are
true, the condition is false. If the numbers
are false, the condition becomes true.
!(A && B) is true
These are used to check if multiple conditions are true.

Assignment Operators
= Basic Assignment – assigns one
value so it is equal to another
C = A + B will assign the
value of A + B to C
+= Addition Assignment – adds the
right number to the left number and
assigns the result to the left number
C += A is equivalent to C
= C + A
-= Subtraction Assignment –
subtracts the right number from the
left number and assigns the result to
the left number
C -= A is equivalent to C
= C - A
These are used to assign one value to another.

Assignment Operators
*= Multiplication Assignment –
multiplies the left number by the right number
and assigns the result to the left number
C *= A is equivalent to C = C * A
/= Division Assignment – divides the left number
with the right number and assigns the result to
the left number
C /= A is equivalent to C = C / A
%= Remainder Assignment – finds the remainder of
a division and assigns the result to the left
number
C %= A is equivalent to C = C %
A

Bitwise Operators
& Bitwise AND Operator – if both bits
are true, then the condition becomes
true
(A & B) = 12, i.e., 0000
1100
| Bitwise OR Operator – if either bit is
true, the condition becomes true
(A | B) = 61, i.e., 0011
1101
^ Bitwise XOR Operator – returns true if
either bit is true (but not both)
(A ^ B) = 49, i.e., 0011
0001
These operate on numbers at the bit level, allowing users to manipulate individual bits. A bit with
value 1 is equivalent to true, a bit with value 0 is equivalent to false.

Bitwise Operators
~ Bitwise Complement Operator – changes
true to false and false to true
(~A ) = -61, i.e., 1100 0011
in 2's complement form
>> Right Shift Operator – shifts all bits to the
right by a specified number
(A | B) = 61, i.e., 0011
1101
<< Left Shift Operator – shifts all bits to the
right by a specified number
A << 2 = 240 i.e., 1111
0000

Bitwise Operators
P Q P&Q P|Q P^Q
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1

Terms used in C
Terminologies
The Terminology of C
auto break case char
const continue default do
double else enum extern
float for goto if
int long register return
short signed sizeof static
struct switch typedef union
unsigned void volatile while

Terminologies
• auto: the variables declared with auto are declared every time the program starts
• break: used to exit out of a conditional or iterative structure
• case: used for selecting an option from a given set of options. Preferred in place
of multiple ifs
• char: represents a data-type to store a single character
• const: declare a constant value

Terminologies
• continue: skip the current iteration and start with the next
• default: the option to be selected if none of the others are selected
• do: starts the do loop that executes at least once even if the given condition is
false
• double: data-type to store a value with decimal points in case the value is
beyond the range of float
• else: the part that executes in case the if part evaluates to false

Terminologies
• enum: used for declaring enumerated types
• extern: used to declare variables or functions having external links
• float: data-type to store decimal point values
• for: used for creating a loop to repeat some process
• goto: used for transferring control to another part of the program

Terminologies
• int: used for storing integer values
• long: used for storing values greater than the range of int
• register: create register variables
• return: return a value to the calling function. Used in functions only
• short: limit the range of int data-type between -32768 to 32767

Terminologies
• signed: same as short
• sizeof: the operator is used to calculate the size of a data-type
• static: static variables are used to store their previous values
• struct: used to define structures containing a number of variables of
different types
• switch: construct used along with case instead of if

Terminologies
• typedef: used for defining user-defined types
• union: used for grouping different variables under a single name
• unsigned: allow storage of unsigned data only
• void: used when a function returns nothing
• volatile: used for creating volatile objects that can be modified by the hardware
• while: loop executes only when a condition is true

Constants
Backslash and character constants
• Backslash preceding symbol indicates a special function
Backslash character Meaning
b Backspace
f Form feed
n New line
r Carriage return
t Horizontal tab
” Double quote

Constants
Backslash and character constants
Backslash character Meaning
’ Single quote
Backslash
v Vertical tab
a Alert or bell
? Question mark
N Octal constant
XN Hexadecimal constant

Escape Sequences
Escape sequences are functions within a string literal or character that are not a
character themselves. They always begin with a backslash.
Operator Description
? Question mark
n New line
r Reset cursor to beginning of the current line
t Horizontal tab
v Vertical tab
Insert a backslash
’ Insert a single quote
” Insert a double quote
a Alert noise

Variables: RECAP
Local variable
• Declared inside the function
• Usable only inside the function inside which it is declared
Global variable
• Declared outside the function
• Can be used throughout a C programme

Variables: RECAP
Static variable
• Retains value between multiple calling of functions
• Declared via static keyboard
External variable
• May be shared across multiple C source files
• Declared via extern keyboard
Automatic variable
• Declared inside the block

Key Terms
• Keywords – These are predefined terms that have specialised meanings in C
• Identifiers – These are the unique names assigned to variables, functions, macros,
arrays etc.
• Variable – A name used to refer to a location in the memory; a placeholder for a
changeable value
• Constants – The opposite of variables: data that will not change during program
execution
• Operator – A symbol that performs an action on a variable

Let’s code!

1) Write a C program that asks the user to enter 3
integers, then:
- Adds these three INT variables up
- Multiplies the result with a CONST INT variable
- Multiplies the result with a GLOBAL INT variable
- Verifies if the final result is even or odd
Print a statement for each result.

2) Write a C program that prompts the user to enter a
double value for Celsius degrees, then convert this
Celsius temperature to Fahrenheit

3) Write a C program that calculates the total average and
percentage of five school subjects

4) Write a C program that does the following:
- If variable var1 is greater than 5 and var2 smaller than 17, print:
“Exercise 1: passed”
else:
“Exercise 1: failed”
- If variable m1 is greater than 13 or if m2 is equal to 509, print:
“Exercise 2: passed”
else:
“Exercise 2: failed”

Project Management,
Management
& Leadership
Constructs

Constructs
What are constructs?
• Comparable to the syntax of programming language
• Able to be read and understood by a compiler, and
free of ambiguity
• Comprised of curly braces, semicolons, etc.
• Loops, statements, invocations, and conditions are
types of constructs

Constructs
• The language C uses various constructs to
accomplish specific tasks
• These include conditional constructs as well as
iterative constructs
• Conditional constructs include if, if else, if else
if else, and switch case constructs
• The iterative constructs include do...while,
while, and for loops

Constructs
Sequence constructs
• Set of instructions that denote the
order of execution
• Often runs ‘top to bottom’ (i.e. line
1, line 2, line 3, and so on)
• Sequences sometimes illustrated by
flow charts, which make use of
different shapes (e.g. circles,
squares, rhombuses)

Constructs
Selection constructs
• Selective execution, which is
dependent on conditions being met
• Compiler ‘asks’ questions in the form
of an if statement
• Sometimes known as ‘branching’

Constructs
Iteration constructs
• Repetitive execution of statements using loop
statements
• Loop statements consist of three types:
o For loops
o While loops
o Repeat until loops
• Saves programmers re-writing same lines of
codes

Constructs
Constructs
Conditional
If
If else
If else if else
switch case
Iterative
do while
while
for

Conditional Constructs
However, the program does not output anything as the condition specified is false

This program outputs j is greater as the condition i > j is false

This program first evaluates if (which returns false), then evaluates else if (which also returns false)
and finally executes the else part and prints both are equal

This program assigns a value to I, and based on that value it prints a word wherever that condition
is met. A break statement is required after every case except default. This program prints Two

This program prompts the user to enter a value between 1 and 3. Depending on
the value entered, the switch case construct returns a result.

Iterative Constructs
• The do while loop executes a minimum of once
• This is because the condition is checked after the first execution
• Thereafter it depends upon the value of the control variable

• The while loop is contrary to the do while loop as it executes only if a condition is true
• The condition is checked first, after which the body of the loop is executed only if the
loop condition evaluates to true

• The for loop is more or less like a while loop
• Within a for loop, the initial value, the terminating condition, and the increment/decrement
value are all specified in a single statement

• If a loop needs to be executed in reverse order, this can be done by specifying the bigger
value as the initial value and the smaller value as the terminating value
• The loop should then decrement the value instead of incrementing it

• C also allows the use of infinite loops (though not recommended)
• These can be specified as follows:
int i=1;
do
{
printf(“%d”,i);
} while (i<=1);
int i=1;
while (i=1)
{
printf(“%d”,i);
};
for(;;;)

Let’s code!

1) Write a C program to find the largest of
two numbers using IF…ELSE

2) Write a C program to find the largest value between
three numbers.

3) Write a C program to print all natural numbers from 1
to n using WHILE loop, then FOR loop

4) Write a C program to find the sum of all even numbers
between 1 to n

Project Management,
Management
& Leadership
Arrays

Arrays
Introduction
• An array is simply an ordered collection of elements, all of which are the
same data type
• Each of the elements are numbered, allowing individual access
• Arrays can be one-dimensional (like a list) or two-dimensional (like a table)
“A group of elements belonging to a homogenous type
and accessed by an index can be called an array”

Declaring & initialising arrays
(manually)
There are various way of declaring & initialising an array:
1) Either by entering every value, separated by commas (with the array size):
double str[5] = {3.455, 21.609, 4.44, 31000.9, 8.504};
2) Either by entering every value, separated by commas (without the array size):
int str[] = {12, 34, 5, 1777, 56, 2358, 380};

Declaring & initialising arrays
(user)

Accessing Elements in an Array
• An Array element in C can be accessed using its index number
• The index number is a numeric value that starts with 0 and the last value can be 1 less
than the size of the array
• In an array with 10 elements, the first index number would be 0 and the last would be 9
• So, to access element 5, we would simply access the element with the index as 4,
shown below:
int x = list[4];

Accessing Elements in an Array
• The following program initialises the array at runtime and then
displays the contents of that array:

Two-Dimensional Arrays
• In a two-dimensional array we can declare rows and columns
• To access individual elements, we use two numbers instead of one
• For example, to access 2 in this list we would use the reference [0] [1]
1 2 3 4
5 6 7 8
list[0] [0] list[0] [3]list[0] [2]list[0] [1]
list[1] [3]list[1] [2]list[1] [1]list [1] [0]
int list[2][4]=
{
{1,2,3,4},
{5,6,7,8}
};

Two-Dimensional Arrays

Exercise time!

1) Write a C program where you declare & initialise an
array of any type (your choice) and of size 20, then print
the 9th and 15th values of that array.

2) Write a C program to find the sum of an array’s
elements.

3) Write a C program to count all even and odd elements
in a given array

4) Write a C program to copy all elements of first array
into a second array in reverse order.

Sorting Arrays
• Arrays can be initialised with random values and displayed in a particular
order
• This is possible due to various sorting algorithms that can be applied
• The simplest of these is the Bubble Sort
• The program here accepts a few numbers from the user and stores them
in an array, in the order in which they have been entered
• Thereafter, the array is sorted in the next step using Bubble Sort
• Finally, the sorted array is displayed to the user

Let’s have a look at an example
Say we have the following array of 10 integers, stored in random order:

In the first pass of the outer loop (ie: when i == 0), we
have:

And so: we have essentially pushed the highest value in
the array to the rightmost box of the array.
The second pass (ie: i == 1) will therefore push the second
largest value of the array to the right, and so on until
i == 9 and the array is finally sorted in ascending order.

QUESTION
Look at both terminating values for the outer and inner
loops.
What do you notice?
Why are they different?

The efficiency of sorting algorithms
By clicking here, we can see that Bubble Sort isn’t great:

Question: what should we change in the previous to
order the array in decreasing order?

Project Management,
Management
& Leadership
Strings

Introduction to strings
So far, we have seen how to declare, initialise and manipulate arrays of
various data types.
Among these, we haven’t mentioned the possibility of implementing arrays
of type char, as so:
char myCharArray[];
Since char arrays hold, in effect, characters that can make up a word, several
words, or even sentences with meaning, could we then say that arrays of
type char constitute strings – ie: text?
 WRONG!

Introduction to strings
There lies in fact a difference between any sort of array (including char arrays) and strings:
Strings are arrays of type char that end with a compulsory ‘0’ (null) character!!!
Following is the memory presentation of the above defined string in C:

NOTE:
The null character shows the computer where the string
ends.
But we do not need to place the null character at the end
of a string!
The C compiler automatically does that for us: it places
the '0' at the end of the string when it initializes the
array.

Declaring & initialising a string in C
(manually)
There are several ways to declare and initialise a string:
1) Either by entering every character in single quotes (with or without the array size):
- char str[] = {'H','e','l','l','o',' ','w','o','r','l','d','0’};
- char str[14] = {'H','e','l','l','o',' ','w','o','r','l','d','0’};
2) Either by entering full words and spaces in text style and in double quotes (with or without
the array size):
- char str[] = "Hello world!";
- char str[50] = "Hello world!";

Declaring & initialising a string in C
(user)
There are several ways to have a string initialised by users.
One of the safest and enduring ways is as follows:
#include <stdio.h>
int main()
{
char str[20];
printf(“Please enter your string:nn”);
scanf("%[^n]%*c", str);
printf(“nnYour string:nn%s", str);
return 0;
}

String Methods
• If we want to do anything with our strings, such as compare, concatenate
or copy them, we need access string methods
• We do this using the header file string.h
• Here are some of the most popular string handling methods:
o strlen()
o strcpy()
o strncpy()
o strcat()
o strncat()
o strcmp()

String Methods
strlen
• This calculates the length of the string, minus the null character
• Format: strlen (string variable)

String Methods
strcpy
• This copies the content of one string to another
• Format: strcpy(destination_string, source_string);

String Methods
strncpy
• This allows us to copy a selected number characters from one string to another
• Format: strncpy (destination_string, source_string, number of characters to copy);

String Methods
strcat
• This allows us to concatenate (or join) two strings together
• Format: strcat(destination_string, source_string);
strcat (str2,str1);

String Methods
strncat
• Like strcat, this lets us join strings together, but unlike strncat, it lets us specify how
many characters
• Format: strncat (destination_string, source_string, number of characters);

String Methods
strcmp
• This compares strings
• If the strings are equal, it returns 0.
If the 1st is greater than the 2nd, it
returns a value greater than 0. If the
1st is less than the 2nd, it returns a
value less than 0
• Format: strcmp (string_1,string_2);

String Methods
strcmp

Library of most string functions
Function Description
strlen Finds the length of a string
strlwr Makes string characters lowercase
strupr Makes string characters uppercase
strcat Appends one string at the end of another
strncat Appends first n character of string at the end of another
strcpy Copies one string into another
strncopy Copies first n characters of one string into another
strcmp Compares two strings

strncmp Compares first n characters of two strings
strcmpi Compares two strings without regard to case
stricmp Compares two strings without regard to case
strnicmp Compares first n characters of two strings without regard to case
strdup Duplicates string
strchr Seeks first occurrence of given character within string
strrchr Seeks last occurrence of given character within string

strstr Find first occurrence of given string in another string
strset Sets all characters of a string to a given character
strnset Sets first n characters of a string to a given character
strrev Reverses a string

1) Write a C program to concatenate two strings

2) Write a C program to compare two strings.

What is C
Programming?
• A general purpose programming
language closely related to the UNIX
operating system
• Developed specifically for UNIX,
given that most systems and
programmes running in UNIX are
written in C language
• Standardised by American National
Standards Institute (ANSI) in 1989

UNIX – what’s that again…?
Unix distinguishes itself from its predecessors as the first portable operating system: almost the entire
operating system is written in the C programming language, thus allowing Unix to reach numerous
platforms.
Development started in the 1970s at the Bell Labs research centre. by Ken Thompson, Dennis Ritchie,
and others.
Both Unix and the C programming language were developed by AT&T and distributed to government
and academic institutions, which led to both being ported to a wider variety of machine families than
any other operating system
The Unix system had significant impact on other operating systems. It achieved its reputation by its
interactivity, by providing the software at a nominal fee for educational use, by running on inexpensive
hardware, and by being easy to adapt and move to different machines.

History of C
• It was developed by Dennis Ritchie of Bell
Labs between 1969 and 1973 as a
successor to the B language
• In 1978, the publication of "The C
Programming Language" by Bryan
Kerninghan and Ritchie caused a
revolution in the computing world
• In 1983, the American National Standards
Institute (ANSI) established a committee
to provide a modern definition of C and
this definition was completed in late 1988

History of C
Year Language Developed by Remarks
1960 ALGOL International committee Too general and too
abstract
1963 CPL Cambridge University Hard to learn,
difficult to
implement
1967 BCPL Martin Richards at
Cambridge University
Could deal only with
specific problems
1970 B Ken Thompson at AT & T Could deal only with
specific problems
1972 C Dennis Ritchie at AT & T Lost generality of
BCPL and B restored

C Facts
• Today, C is one of the most widely
used programming languages in the
world
• C has been used for everything
imaginable, from operating systems to
databases to network drivers
• Linux OS, PHP, and MYSQL are all
written in C
• Modern programming concepts are
based on C

According to
• According to TIOBE Index:
• https://www.tiobe.com/tiobe-index/

C and Other Languages
• C is considered the mother tongue for programming because its features strongly
influenced subsequent languages
• Many popular languages like Java, C++, Perl, Ruby, PHP, Bash, Python, and Objective
C have borrowed syntaxes and functions from the C language
• They have the same operators, expressions, statements, and control structures of C
• High level programming languages like JAVA and Python can merge with C
• The C compiler combines the capabilities of an assembly language, along with the
features of a high level language, making it suitable for developing system software
and packages

Assembly language – what’s that again…?

High-level language – ok…
A high-level language (HLL) is a programming language such as C, FORTRAN, or Pascal that enables a programmer to
write programs that are more or less independent of a particular type of computer. Such languages are considered
high-level because they are closer to human languages and further from machine languages.
In contrast, assembly languages are considered low-level because they are very close to machine languages.
Advantages of High-Level Languages
The main advantage of high-level languages over low-level languages is that they are easier to read, write, and
maintain. Ultimately,
programs written in a high-level language must be translated into machine language by a compiler or interpreter.
The first high-level programming languages were designed in the 1950s. Now there are dozens of different
languages, including Ada,
Algol, BASIC, COBOL, C, C++, FORTRAN, LISP, Pascal, and Prolog.

Reasons to Use C
C has now become a widely used programming language, and is favoured for
the following reasons among others:
• Easy to learn
• Structured programming language
• Runs programmes efficiently
• Compiles code quickly
• Handles low-level activities
• Can be used on a variety of operating systems (e.g. Windows, Android, Mac)

What is a structured programming language?
Structure programming is a "computing philosophy" which states that there three main ways of combining programs:
- sequencing
- selection
- iteration (+ recursion)
These are deemed sufficient to express any computable function.
"Sequence"; ordered statements or subroutines executed in sequence.
"Selection"; one or a number of statements is executed depending on the state of the program. This is usually expressed with
keywords such as if..then..else..endif.
"Iteration"; a statement or block is executed until the program reaches a certain state, or operations have been applied to every
element of a collection. This is usually expressed with keywords such as while, repeat, for or do..until. Often it is recommended that
each loop should only have one entry point (and in the original structural programming, also only one exit point, and a few
languages enforce this).
"Recursion"; a statement is executed by repeatedly calling itself until termination conditions are met. While similar in practice to
iterative loops, recursive loops may be more computationally efficient, and are implemented differently as a cascading stack.

Reasons to Use C
• Foundation of modern information
technology sector, including a great
deal of IT principles such as:
o Operating systems
o Databases
o Graphic user interfaces
o Image processing
o Real-time systems
o Algorithms

Reasons to Use C
• Used by over 90% of desktop programmes
(e.g. email clients in web browsers) use C
• Used extensively in robotics
• Standardised by ANSI and International
Organisation for Standardisation (ISO)
• Foundation skill for more advanced
programming techniques like multithread
programming, embedded programming, real-
time programming, and cloud computing

Reasons to Use C
• Highly flexible and adaptable, due to
the presence of different data types
• Possesses capabilities of assembly
language, along with high-level
language for developing system
software and packages
• Uses 32 keywords and several
functions

Reasons to Use C
• Able to extend itself
• Language has a collection of functions
• C library is able to continuously
accommodate new functions
• Procedural in nature

What is procedural programming?
Historically, procedural programming arose out of the concept of structured programming.
The idea is that programs can be written with only three things:
- Sequence (execution moves forward one statement at a time)
- Selection (if statements)
- Iteration (loops)
But all in all, procedural programming (PP) is a programming paradigm that takes a top-down approach.
It is about writing a list of instructions to tell the computer what to do step by step.
It relies on procedures or routines.
Procedural programs can be faster than most alternatives. This is especially true historically.
We can easily get the maximum performance out of procedures because we become “empathetic” to what the
machine’s most efficient way to perform a task is.

Reasons to Use C
• Can be said to use object oriented
programming (OOP)
• Absence of ‘garbage collection’ and
‘dynamic typing’ allows C to function
faster than its language counterparts
• Portable, and therefore easy to
compile from disparate systems

Portability
• C’s portability means that, when
written well, it can be compiled
once and then moved to another
system without modification
• However, C does not guarantee
portability. Programs must be
optimised in certain ways in order
to run elsewhere without issue
C programs are portable

Reasons to Use C
• Sections of C can be stored for future
use (i.e. modularity), thanks to its
libraries
• Statistically typed as opposed to
dynamically typed
• Seamlessly merges with high-level
programming languages like Java and
Python

Statically-typed vs dynamically-typed
Statically typed languages
A language is statically typed if the type of a variable is known at compile time. For some languages this means that
you as the programmer must specify what type each variable is (e.g.: Java, C, C++); other languages offer some form
of type inference, the capability of the type system to deduce the type of a variable (e.g.: OCaml, Haskell, Scala,
Kotlin). The main advantage here is that all kinds of checking can be done by the compiler, and therefore a lot of
trivial bugs are caught at a very early stage.
Examples: C, C++, Java, Rust, Go, Scala
Dynamically typed languages
A language is dynamically typed if the type is associated with run-time values, and not named variables/fields/etc.
This means that you as a programmer can write a little quicker because you do not have to specify types every time
(unless using a statically-typed language with type inference).
Examples: Perl, Ruby, Python, PHP, JavaScript

Reasons to Use C
C is middle level and structured
• Middle level means it fills the gap
between machine language (what the
computer reads) and high-level
languages (languages like Ruby that are
closer to natural human language)
• Structured means that C follows a
logical structure which divides
problems into individual modules

Features of C
• This means instructions are executed step-by-step to carry out tasks
• A program may contain one or more procedures for performing these tasks
• This makes C quite intuitive as it works how you may expect a program to
work – by following instructions
C is a procedural language

Features of C
C programs are fast
• As C is a compiled language, it only needs to be run through a compiler
once for it to be translated into machine code that a computer can
understand
• Interpreted languages, in comparison, must be interpreted every time
they are run, which slows down performance and takes a lot longer

Features of C
C is a statically typed language
• This means types of variable are checked while the language is being
compiled, rather than when it is run
• This again makes it faster than other (dynamically typed) languages
• It also ensures errors are caught earlier in the development process

Project Management,
Management
& Leadership
Functions

Main Kitchen
(RETURNS hot sauce) Sous-chef sauce kitchen (can take in and )
Grind meat (using meat grinder)
Boil pasta and veggies. Use blender for veggies.
Cook meat in butter. Add salt and a touch of wine.
Ask Sous-chef sauce kitchen to make hot sauce! (send sous-chef some and some )
Hot sauce received.
Meal ready and sent to customer!
Heat up butter in milk.
Use blender to chop up chillies.
Add salt and red wine.
Send hot sauce to main kitchen!

Describing Functions
• Sometimes while programming, the need arises to repeat a set of statements again and
again
• The programmer could choose to write the code again provided it is small and not being
constantly replicated
• To avoid this, C makes use of functions
• One function we have already seen is the main() function
• Main is an in-built function that can be used for calling other functions, as we saw in the
case of Strings
• This section will describe how functions can be created in C

User Defined Functions
There are two categories of functions:
- In-built functions are those that have been defined by the C development team for
performing basic jobs . These functions reside in the header files (e.g. stdio.h, string.h,
math.h etc.). Each of these header files contain functions as per their names.
- User-defined functions are sets of statements that can be defined and subsequently
called across multiple program files

Parts of a Function
Function name
Actual name of the function
Parameter list
Comparable to a placeholder, as value is passed to the parameter
when a function commences. Not all functions have parameters
Function body
A collection of statements that defines the operations of the functions
Return type
Function may return a value, but not always the case (even when
desired operation has taken place)

Parts of a Function

Declaring Functions
• Tells compiler how many parameters the function will be taking, as well as data types
and the return type
• Below is a function taking two integers as parameters, and then returning an integer
int max(int, in);
• Following is a function taking a char and int as parameters, which return an integer
int fun(char, int);

Functions
printf() functions
• In-built library functions available by default
• Declared stdio.h header file
• Used to print characters, strings, floats, integers, octals, and hexadecimal
values on output screen
• New line generated by n

Functions
C programme with printf() functions
#include <stdio.h>
int main()
{
char ch = ‘A’;
char str[30] = “theknowledgeacademy.com”;
float flt = 10.234;
int no = 150;
double dbl = 20.123456;
printf(“Character is %c n”, ch);
printf(“String is %s n” , str);
printf(“Float value is %f n”, flt);
printf(“Integer value is %dn” , no);
printf(“Double value is %lf n” , dbl);
printf(“Octal value is %o n” , no);
printf(“Hexadecimal value is %x n” , no);
return 0;
}
OUTPUT
Character is A
String is theknowledgeacademy.com
Float value is 10.234999
Integer value is 150
Double value is 20.123456
Octal value is 226
Hexadecimal value is 96

Functions
scanf() functions
• Format specifier %d is used in scanf() statement, so that value entered
is received as an integer and in %s for string
• Ampersand (&) is used before name of variable ch in scanf() statement
as &ch
• Comparable to a pointer, as it ‘points’ to the variable

• Every user defined function in C has a structure like this:
• Any user-defined function must be declared immediately after the pre-
processors, to enable the compiler to locate them
<return type> function name ([<list of
arguments>])
{
body of function
…
[optional return statement];
}

• Return type – the return type is the type of the data that will be returned by the
function to the calling function. If no data is returned then return type is void and the
function will have no return statement, as in main()
• Function name – this is the name of the function that another function will call in the set
of statements
• Argument list – if any extra information needs to be passed to the function to complete
its processing, it is passed as an argument. The function can have no arguments, or
many. Arguments are of two types – actual and formal
• Body – this is the part of the function which is actually doing the processing
• Return statement – this is used for returning data of the return type. It is optional

• Example:

• The program shown here defines two functions that do not return any value or
accept any arguments
• Both functions are first declared immediately after the #include statement, so
that the compiler knows that these functions have been defined by the user in
this program and does not come up with any error when they are called
• The welcome() statement invokes a function by the same name and so does the
terminate() statement
• void specifies that no value is returned and as such no return keyword in either of
the functions

• Example demonstrating the use of return keyword and argument list

• This program accepts two numbers, First and Second (of integer type)
• The numbers are passed to the user-defined function add() where they are
received in the formal parameters a and b
• Inside the function, a local variable c is declared to hold the sum of a and b
• The return statement is used to return this value to the main program
• Inside main(), the variable Result holds the returned value, which is then printed
on the user’s screen

Nesting Function Calls
• Functions in C can be called
from another function the
same as they are called from
main()
• When the main() function
calls FunctionOne(),
FunctionOne() calls
FunctionTwo(), FunctionTwo()
calls FunctionThree(), and so
on, this is known as nesting

Recursive Functions
• Sometimes programmers come across situations where a function needs to be
called repeatedly
• This can be hazardous: an infinite loop may result in an “Out of Memory” error
and the system may as well crash
• To avoid this, programmers often include an if condition that helps them to
terminate the loop at a specified point
• These are known as recursive functions
• The terminating condition is known as the base condition
• The best example of a recursive function is the factorial of a number

Recursive Functions

Setting a
number to
the power n –
technique 1

Setting a
number to
the power n –
technique 2

Setting a
number to
the power n –
technique 3

Exercise time!

1) Write a C program to input a number from user and
check whether given number is even or odd using
functions.

2) Write a C program to input a number from user and
check whether given number is even or odd using
functions.

3) Write a recursive function in C programming to find
the sum of all natural numbers between 1 to n.

Project Management,
Management
& Leadership
Pointers

Using Pointers
• Pointers are an advanced way of dealing with data in C
• A Pointer is a special type of variable that can store
the address of another variable. They are unique to C
and C++
• A pointer can point to a variable of the same type as
that of the pointer
• Pointers use two special symbols to operate
• These are & to store the address of a variable and * to
access the value of a variable. &var generates an
address for var within the programme’s memory
• * is also used while declaring a pointer variable
#include <stdio.h>
int main()
{
int var = 10;
printf(“Value: %dn”, var);
printf(“Address: %u”, &var);
return 0;
}

Using Pointers

Using Pointers
• If the value of the pointer is incremented or decremented using the ++ or – operators, the
address stored in the pointer will change
• This may (though not always) lead to erroneous output

Using Pointers
• The program shown on the last slide initialises the pointer to the address
of i
• It also increments the value of ptr twice, which changes the address stored
in it and consequently the value
• As such, it is imperative that pointers are handled very carefully

String Pointers
• Pointers can be used with almost any data type
• With Strings, pointers can be used to manipulate each and every character
• This example counts the number of characters in a string using pointers

String Pointers
• The ‘&’ character was not used in the above
program
• This is because a string is already a character array
and the ptr = str statement assigns the address of
the 0th element of str to the pointer variable ptr
• When we increment ptr, it increments the address
to the next index number
• Thus, calling *ptr displays one character at a time
instead of the entire string
• We use i as a counter variable to keep track of the
length of the string

Pointers to Pointers

Pointers to Pointers
• The previous example illustrates how a user can define a Pointer to a Pointer
• Initially, we define a pointer ptr that points to an integer point i
• Next, another pointer variable ptr2ptr (also of integer type) points to ptr
• Using either of these variables we can get the value 340 as depicted in the output
• Remember a Pointer to a Pointer must be declared with a ** instead of a *

Array of Pointers
• C allows users to declare an array of pointers
• An array of pointers can be declared like any other array but the contents are only pointers

Array of Pointers
• This program declares an array of
integers and then an array of integer
pointers
• The first for loop assigns the address of
the integer array cells to the array of
pointers
• Once this is done, the pointer’s address
and its values are printed on to the user
screen

NULL Pointers
• You can declare a pointer as NULL in value if the address of pointer
variable is not known
• NULL pointers are constant
• Not to be confused with an uninitialised/dangling pointer, which is not
guaranteed to be compared as unequal to an initialised pointer
• Two NULL pointers will compare as equal

RECAP

Exercises!

1) Write a C program to create, initialize and demonstrate
the use of pointers.

2) Write a C program to prompts the user to enter two
float values, assigns their addresses to two float pointers
and adds these two float values using both pointers.

Project Management,
Management
& Leadership
Structures

Structures
• In C, structures are used for storing different types of data that is grouped together
• A user may want to store employee details such as Employee Code, Employee
Name and Salary or Customer Details such as Customer Number, Customer Name,
Product Purchased, Qty Purchased, or Amount Paid
• All these details could be stored in a single structure, such as Employee or
Customer
• An object of the structure could then be created to store or access its values
• A structure is by default public in nature

Structures
Example of a structure
#include <stdio.h>
struct EmployeeData{
char *employee_name;
char *employee_title;
char *employee_dept;
};
char main()
{
struct EmployeeData employee;
employee.employee_name = "John Bonham";
employee.employee_title = "Marketing Executive";
employee.employee_dept = "Marketing";
printf("Employee Name is: %s", employee.employee_name);
printf("nEmployee Title is: %s", employee.employee_title);
printf("nEmployee Department is: %s", employee.employee_dept);
return 0;
}
OUTPUT
Employee Name is: John Bonham
Employee Title is: Marketing Executive
Employee Department is: Marketing

Structures
typedefs
• Define types using a different name
when working with structs and
pointers, which appear as asterisks
• Essentially saves coder from constantly
typing struct throughout the code
• Code is shorter and more visually
accessible
typedef struct work_address{
int house_number;
char *street_name;
char *town;
char *city;
char *county;
int *postcode;
}addr;
..
..
addr var1;
var.town = “London”;

Structures
Designated initialisation
• Members of the structure (i.e.
variables) can be initialised in
any given order
• Added to C99 standard
• Unavailable in C++
struct Point
{
int x, y, z;
};
int main()
{
// Examples of initialisation using designated initialisation
struct Point p1 = {.y = 0, .z = 1, .x = 2};
struct Point p2 = {.x = 20};
printf ("x = %d, y = %d, z = %dn", p1.x, p1.y, p1.z);
printf ("x = %d", p2.x);
return 0;
}

Array of Structures
• It is possible to create a
structure and use it in an array
• This would be useful in a
situation where there are
more than one employees for
whom the same details need
to be entered or retrieved
• In such cases, we could make
use of an array of structures,
as in this example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main()
{
struct employee
{
int empcode;
int salary;
float allow;
float deduct;
float netsal;
};

Array of Structures
• Structure Example (contd.)
struct employee emp[3];
int i;
clrscr();
for(i=0;i<3;i++)
{
printf("Enter Code Number:");scanf("%d", &emp[i].empcode);
printf("Enter Employee Salary:");scanf("%d", &emp[i].salary);
emp[i].allow=0.05 * emp[i].salary;
emp[i].deduct=0.02 * emp[i].salary;
emp[i].netsal=emp[i].salary+ emp[i].allow-emp[i].deduct;
printf("n================================n");
}

Array of Structures
• Structure Example (contd.)
clrscr();
for(i=0;i<3;i++)
{
printf("nCode:%d", emp[i].empcode);
printf("nBasic Salary:%d", emp[i].salary);
printf("nAllowance:%.2f",emp[i].allow);
printf("nDeduction:%.2f",emp[i].deduct);
printf("nNet Salary:%.2f",emp[i].netsal);
printf("n================================");
}
getch();
}

Using Structures with Pointers
• A very common concept in C is that of the linked list
• A linked list is a list of nodes where each node is a structure
• A Single Linked List has nodes that are added at the end of the list
• The first node added is known as the start node, the final node is called the last
node, and the node being traversed currently is called the current node
• Whenever a node is added, the program checks whether the list contains any
nodes
• If the list is empty, the new node becomes the first as well as the last node

• As the nodes are added, the start node
remains fixed but the last node moves
ahead
• Every new node contains a NULL value
in its next pointer
• The last pointer replaces this with the
address of the next node
• The result is as follows:

• Example Program
#include <stdio.h>
void showlist();
struct node* getnode();
struct node *start;
struct node *last;
struct node
{
int empcode;
int salary;
struct node* next;
};

• Example Program
void main()
{
struct node *ptr;
char ans='y';
clrscr();
start=NULL;
while (ans=='y')
{
if(start==NULL)
{
ptr=getnode();
start=ptr;
last=start;
}

• Example Program
else
{
ptr= getnode();
last->next=ptr;
last=ptr;
}
printf("n Continue(y/n)?");
ans=getch();
}
showlist();
getch();
}

• Example Program
void showlist()
{
struct node *temp; int i=1;
clrscr();
temp=start;
while(temp!=NULL)
{
printf("nRecord No:%d",i++);
printf("nCode:%d", temp->empcode);
printf("nSalary:%d", temp->salary);
printf("n=====================");
temp=temp->next;
getch();
}
}

• Example Program
struct node* getnode()
{
struct node *temp;
temp = (struct node*) malloc (sizeof (struct node));
printf("nEnter Code:");
scanf("%d", &temp->empcode);
printf("nEnter Salary:");
scanf("%d",&temp->salary);
temp->next=NULL;
return temp;
}

Project Management,
Management
& Leadership
Operating Bigger Programs

Dividing Programs
• Sometimes programmers are asked to write very large programs
• Navigating huge programs is an extremely difficult process
• As a best practice, it is always advisable to divide a single huge program into
multiple modules as well as a library of functions containing a suite of
subroutines within one or more modules
• However, only one of these files will contain the main() function
• By writing a group of functions in different module files, these module files can
be shared with many other programs as well

Dividing Programs
Why write modules instead of a single programme?
• Modules will naturally divide into common
groups of functions
• It is much easier to compile each module
separately, rather than link them in compiled
modules
• UNIX utilities can help maintain large systems

Header Files
• If we are dealing with modular files, we will have to store the definition
of the variables and functions somewhere
• As per convention, the best place would be a header file
• C allows its users to create their own header files
• These header files can be included into our C program using the keyword
#include in the following manner:
#include “userdefined.h”

Header Files
Example of modules
#define .....
void .....
int .....
#include< >
#include “header.h”
main()
{
.....
}
#include “header.h”
void
WriteMyString()
{
.....
}
header.h
main.c WriteMyString.c
#include .....
fns .....
#include .....
fns .....
#include .....
fns .....
Other modules
mod1.c
mod2.c
mod3.c

Header Files
Full listings
main.c:
/* * main.c */
#include "header.h"
#include <stdio.h>
char *AnotherString = "Hello Everyone";
main()
{
printf("Running...n");
/* * Call WriteMyString() - defined in another file */
WriteMyString(MY_STRING);
printf("Finished.n");
}

Header Files
Full listings
WriteMyString.c:
/*
* WriteMyString.c
*/
extern char *AnotherString;
void WriteMyString(ThisString)
char *ThisString;
{
printf("%sn", ThisString);
printf("Global Variable = %sn", AnotherString);
}

Header Files
Full listings
header.h:
/*
* header.h
*/
#define MY_STRING "Hello World"
void WriteMyString();

Header Files
Full listings
• Some modules have a #include “header.h” that share common definitions
• Some (like main.c) also include standard header files
• main calls the function WriteMyString(), which is in the WriteMyString.c module
• The function prototype void for WriteMyString is defined in header.h

Header Files
Sharing variables
• If global variables are declared in a module, the knowledge of said variables must be
passed on to other modules
• This can be achieved by passing values as parameters to functions; however:
o This can be a convoluted process if the same parameters are passed to many
functions, and/or if there is a long argument list involved
o Large arrays and structures are difficult to store locally, and there are often memory
problems associated with the stack function

Header Files
External variables and functions
• “Internal” implies that arguments and functions are defined inside the functions (i.e.
locally)
• Therefore, “external” variables are defined outside of functions
• In other words, they are potentially available to the entire programme
• External variables are always permanent

Header Files
Scope of externals
• External variables/functions are not always completely global
• With that in mind, C programming language will apply the following rule:
“The scope of an external variable (or function) begins at its point of declaration and
lasts to the end of the file (module) it is declared in.”
A. D. Marshall (1998)
Hands On: C Programming and Unix Application Design: UNIX System Calls and Subroutines Using C

Using Several Files
• In a team of programmers, each programmer could work on different files and
yet access the same modules
• An object oriented style can be used, with each file defining a particular type of
object as a data type and various operations that can be carried on that object
• To make it more structured, the object can be implemented privately
• Files can contain all functions from a related group, which can be accessed like a
function library
• Well implemented objects or function definitions can be re-used in other
programs

Using Several Files
• In very large programs, each major function can occupy a file to itself
• Any lower-level functions used to implement them can be kept in the
same file – this reduces distraction for developers
• When changes are made to a file, only that file needs to be recompiled
to rebuild the program
• The UNIX make facility is very useful for rebuilding multi-file programs in
this way

The Modular Approach
Advantages
• Teams of programmers can work on individual
programmes, and focus on their area of expertise
• An object-oriented style can be used; each file defines
a particular type of object as a data type, and
operations on that object as functions
• Implementation of the object can be kept private from
the rest of the programme

Advantages
• Guarantees well-structured programmes that are
easy to maintain
• Files can contain all functions from a related group
o e.g. All matrix operations can be accessed like a
function library

Advantages
• Well-implemented object/function definitions can be
re-used in other programmes, therefore reducing
development time
• Each major function within a large programme can
occupy a file to itself; any lower level functions used to
implement these can be kept in the same files
• Changes made to a file can easily be recompiled when
re-building the programme

Dividing a programme between several files
• Where objects are implemented as data structures, it is sensible to keep all functions
(which access that object) in the same file
• The advantages are:
o The object can easily be re-used in other programmes
o All related functions are stored together
o Future changes to the object require only one file to modified

Organisation of data
• Any and every file must have its data organised in a certain order, which will typically be:
o A preamble consisting of #defined constraints, #included header files, and typedefs
of important datatypes
o A declaration of global and external variables, the former of which may be initialised
o One or more functions

Organisation of data
• Ordering must not be overlooked, since every object must be defined before it can be used
• Functions that return values must be defined before they are called
• One of two definitions may be applicable:
o Where the function is defined and called in the same file, a full declaration of the
function can be placed ahead of any call to the function
o If the function is called from a file where it is not defined, a prototype should appear
before the call to the function

Congratulations
Congratulations on completing this course!
Keep in touch
info@theknowledgeacademy.com
Thank you

Lesson slides for C programming course

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Lesson slides for C programming course

Similar to Lesson slides for C programming course (20)

Recently uploaded

Recently uploaded (20)

Lesson slides for C programming course

Editor's Notes