CSC 203

COMPUTER
PROGRAMMING I
COURSE OUTLINE
Introduction to problem solving methods and Algorithms
Programming language elements (Syntax, Semantics)
Variable Declaration, Data Types, Use of Operators (Arithmetic,
Assignment, Increment/Decrement, Relational, Logic, etc)
Control structures of Algorithms
Introduction to C Programming language
Structural program development in C
C program control (Control structures in C)
C functions
C Arrays
C Pointers
COURSE OUTLINE
Course Lecturer:
⚫ Dr.A. Abayomi-Alli (Coordinator)
⚫ Prof. A. S. Sodiya
 INTRODUCTION TO PROGRAMMING
What is a program??? Differentiate between an Algorithm and
a Program!!!

A program is :
the implementation of an algorithm in a programming
language that can be executed by a computer.
a sequence of instructions to instruct a computer to perform
specific tasks. Every program is written in some programming
language.
It can be executed several times, every time with different inputs
Programs are commonly referred to as software. Software is
essential to a computer because it controls everything the
computer does. All of the software that we use to make our
computers useful is created by individuals working as
programmers or software developers.

A programmer, or software developer, is a person with the

training and skills necessary to design, create, and test
computer programs.
What is Computer programming?
Computer programming is the act of writing computer programs
using a Computer Programming Language to perform a
specified task by the computer.

There are thousands of programming languages which can be

used to write computer programs such as Java, C, C++, Python,
PHP, Perl, Ruby etc

Lady Ada Lovelace was an impressive mathematician. She

created a program for the Analytical Engine. Based on this
work, Ada is now credited as being the first computer
programmer and, in 1979, a contemporary programming
language was named Ada in her honour.
 Three levels of computer programming languages may be
distinguished:
1. Machine language
2. Assembly language
3. High-level language

Computers can only execute programs that are written in machine

language. A program can have thousands or even millions of
binary instructions, and writing such a program would be very
tedious and time consuming.
Assembly language uses short words that are known as
mnemonics. For example, in assembly language, the mnemonic
add typically means to add numbers, mul typically means to
multiply numbers, and mov typically means to move a value to
a location in memory.

Assembly language is close in nature to machine language, and

as such, both are called low-level languages.
Assembly language also requires that you write a large number
of instructions for even the simplest program like machine
language.
A special program known as an assembler is used to translate an
assembly language program to a machine language program.
 A high-level language allows you to create powerful and
complex programs without writing large numbers of low-level
instructions. High-level languages use words that are easy to
understand as English like expressions.

Language Description

Ada Ada was created in the 1970s, primarily for applications

used by the U.S.
Department of Defense.
BASIC Beginners All-purpose Symbolic Instruction Code is a
general-purpose language that was originally designed
in the early 1960s to be simple enough for beginners
to learn.

FORTRAN FORmula TRANslator was the first high-level

programming language. It was designed in the 1950s for
performing complex mathematical calculations.
Language Description

COBOL Common Business-Oriented Language was created in

the 1950s, and was designed for business applications.

Pascal Pascal was created in 1970, and was originally designed

for teaching programming. The language was named in
honor of the mathematician, physicist, and philosopher
Blaise Pascal.
C and C++ C and C++ are powerful, general-purpose languages
developed at Bell Laboratories.
C# C# was created by Microsoft around the year 2000 for
developing applications based on the Microsoft .NET
platform.
Java Java was created by Sun Microsystems in the early 1990s.

JavaScript JavaScript, created in the 1990s, can be used in web pages.

Despite its name, JavaScript is not related to Java.
Language Description

Ruby Ruby is a general-purpose language that was

created in the 1990s. It is increasingly
becoming a popular language for programs
that run on web servers.

Visual Basic VB is a Microsoft programming language and

software development environment that
allows programmers to create Windows-based
applications quickly.

There is NO best programming language, each

language has its applications.
INTEGRATED DEVELOPMENT ENVIRONMENT (IDE)
An IDE or Integrated Development Environment is a
software program that is designed to help programmers
and developers build software.

Most IDEs include:

a source code editor
a compiler
build automation tools
a debugger
SOFTWARE DEVELOPMENT LANGUAGES

C
C++ (C-plus-plus)
C# (C-Sharp)
Pascal
Delphi
Visual Basic
WEB LANGUAGES
HTML (Hyper Text Markup Language)
XML (Extensible Markup Language)
Javascript
VBScript
PHP (Hypertext Preprocessor)
Java
ASP (Active Server Pages)
COMPILERS AND INTERPRETERS
Because the CPU understands only machine language
instructions, programs that are written in a high-level language
must be translated into machine language.

The programmer will use either a compiler or an interpreter to

make the translation.

A compiler is a program that translates a high-level language

program into a machine language program and executes after.
An interpreter is a program that both translates and executes the
instructions line by line. As the interpreter reads each individual
instruction in the program, it converts it to machine language
instructions and then immediately executes them.
FIGURE 1- COMPILING A HIGH-LEVEL PROGRAM AND EXECUTING IT
FIGURE 2- EXECUTING A HIGH-LEVEL PROGRAM WITH AN INTERPRETER
PHASES OF A COMPILER
1. Lexical analysis: This is the initial part of reading and
analysing the program text. The text is read and divided into
tokens, each of which corresponds to a symbol in the
programming language, e.g., a variable name, keyword or
number.
2. Syntax analysis: This phase takes the list of tokens produced
by the lexical analysis and arranges these in a tree-structure
(called the syntax tree) that reflects the structure of the
program. This phase is often called parsing.
3. Semantic analysis: This phase analyses the syntax tree to
check for errors. It resolves semantic information.
PHASES OF A COMPILER
4.Intermediate code generation: The program is
translated to a simple machine independent
intermediate language.
5. Register allocation: The symbolic variable names
used in the intermediate code are translated to
numbers, each of which corresponds to a register in
the target machine code.
6.Machine code generation: The intermediate
language is translated to assembly language (a textual
representation of machine code) for a specific
machine
architecture.
PHASES OF A COMPILER
7. Assembly and linking: The assembly-language code is
translated into binary representation.

The first three phases are collectively called the frontend of the
compiler and the last three phases are collectively called the
backend. The middle part of the compiler is the intermediate
code generation
 DESIRABLE PROGRAM CHARACTERISTICS
Some important characteristics are expected in programs written in any
programming language.

1. Integrity. This refers to the accuracy of the calculations. Programs

will be meaningless if the calculations are not carried out correctly.
Thus, the integrity of the calculations is an absolute necessity in any
computer program.

2. Clarity: refers to the overall readability of the program, with

particular emphasis on its underlying logic. If a program is clearly
written, it should be possible for another programmer to follow the
program logic without undue effort. It should also be possible for the
original author to follow his or her own program after being away from
the program for an extended period of time.
 DESIRABLE PROGRAM CHARACTERISTICS
3. Simplicity. The clarity and accuracy of a program are usually
enhanced by keeping things as simple as possible, consistent
with the overall program objectives.

4. Efficiency is concerned with execution speed and efficient

memory utilization. These are generally important goals, though
they should not be obtained at the expense of clarity or
simplicity.
 DESIRABLE PROGRAM CHARACTERISTICS
5. Modularity: Many programs can be broken down into a series of
identifiable subtasks. It is a good programming practice to implement
each of these subtasks as a separate program module. In C, such
modules are written as functions. The use of a modular programming
structure enhances the accuracy and clarity of a program, and it
facilitates future program alterations.

6. Generality: Usually we will want a program to be as general as

possible, within reasonable limits. For example, we may design a
program to read in the values of certain key parameters rather than
placing fixed values into the program. As a rule, a considerable
amount of generality can be obtained with very little additional
programming effort.
CONCEPT AND ROLE OF ALGORITHM
An algorithm is a logical procedure to solve a certain
problem.
It is a sequence of elementary steps that an execution
machine must follow to solve a problem.
It is simply the step-by-step procedure of solving a
problem.

For example, design an algorithm to find the Sum and

Average of n numbers.
CONCEPT AND ROLE OF ALGORITHM
Algorithm
1. Start
2. Sum = 0
3. Input i, n
4. For (i = 1, n, i++)
5. Sum = Sum + i
6. ENDFOR
7. Output Sum
8. Average = Sum/n
9. Output Average
10. End

ASSIGNMENT:
REVISE NOTES ON ALGORITHMS (from CSC 102 class)!!!
Programming language
elements (Syntax, Semantics)
SYNTAX AND SEMANTICS OF A PROGRAMMING LANGUAGE

SYNTAX: It refers to the Grammar of the language, the legal

expressions and structure of the language.
If a code contains a syntax error, it cannot be translated. A syntax
error is a mistake such as mispelled keyword, a missing
character, or in the incorrect use of an operator. When this
happens, the compiler/interpreter displays an error message.
Examples of syntax error is:
j=4*(6-x;
i= /5; etc.

SEMANTICS: it refers to the meaning of the expressions.

 PROGRAMMING ERRORS
Three types of errors can occur when writing programs:
1. Compiling errors (syntax error): these occurs when the rules
of the language have not been followed. This may include a
misspelt variable, a forgotten brace, etc. Such statement cannot
be translated and the program cannot be executed.
2. Execution errors (run-time errors): Such errors do not occur
until the program is run. The program may be syntactically
correct, but still contains mistakes that prevents it from
continuing normally when executed.
Occurs when the program directs the computer to perform an
illegal operation, such as dividing a number by zero.
PROGRAMMING ERRORS
Logic errors (Design Error): This mistake can be caused by
faulty reasoning when designing the program.
Its an error caused by following an incorrect algorithm
Very difficult to detect - it does not cause run-time error
and does not display message errors.
The only sign of logic error is an incorrect program output
Can be detected by testing the program thoroughly,
comparing its output to calculated results
To prevent, carefully check the algorithm and written
program before you actually type it.

Debugging: Process of removing errors from a program

PROGRAMMING PARADIGMS
There are a number of alternative approaches to the
programming process, referred to as Programming
paradigms. Different paradigms represents fundamentally
different approaches to building solutions to specific types of
problems using programming. Most programming languages
fall under one paradigm, but some languages have elements of
multiple paradigms.

Two of the most important programming paradigms are the

Procedural paradigm and the Object-oriented paradigm.
 STRUCTURED PROGRAMMING
Structured Programming: The principle idea behind
structured programming is the concept of “divide and
conquer”. Any task that is too complex to be described simply
is broken down into a set of smaller component tasks until the
tasks are sufficiently small and self-contained enough that each
is easily understood.
As an example, computing the average salary of an employee
of a company can be broken down into the following subtasks:
1. Count how many employees you have.
2. Find out what each employee earns.
3. Add all the salaries
4. Divide the total by the number of employees you have.
STRUCTURED PROGRAMMING(CONT’D)
Totalling the salaries can be broken down into the following
subtasks.
1. Get each employee’s record.
2. Access the salary.
3. Add the salary to the running total.
4. Get the next employee’s record.

In turn, obtaining each employee’s record can be broken down

into the following:
1. Open the files of employees.
2. Go to the correct record.
3. Read the data.
 PROCEDURAL PROGRAMMING
1.Procedural programming: is a programming paradigm derived from
structured programming based upon the concept of the procedure
call. It uses a list of instructions to tell the computer what to do
step-by-step. Procedural programming relies on procedures, also known
as routines or subroutines. A procedure contains a series of
computational steps to be carried out. Any given procedure might be
called at any point during a program's execution, including by other
procedures or itself.

Procedural programming is also referred to as Imperative programming.

Procedural programming languages are also known as top-down
languages.

Examples of procedural languages include Fortran, COBOL and C.

 OBJECT-ORIENTED PROGRAMMING
2. Object-Oriented programming: OOP provides techniques for
managing enormous complexity. It is an approach to
problem-solving where all computations are carried out using
objects. An object is a component of a program that knows how
to perform certain actions and how to interact with other
elements of the program. Objects are the basic units of
object-oriented programming.
A simple example of an object would be a person. Logically, you
would expect a person to have a name. This would be
considered a property of the person. You would also expect a
person to be able to do something, such as walking. This would
be considered a method of the person.
OBJECT-ORIENTED PROGRAMMING
Basically, objects have characteristics, also called properties or
attributes, such as name, age, colour etc....They also have
capabilities, also called methods or functions.
A method in object-oriented programming is like a procedure in
procedural programming. The key difference here is that the
method is part of an object. In object-oriented programming, you
organize your code by creating objects, and then you can give
those objects properties and you can make them do certain
things.

Examples of object-oriented languages include C#, Java, Perl

and Python.
Variable Declaration, Data
Types, Use of Operators
(Arithmetic, Assignment,
Increment/Decrement,
Relational, Logic, etc)
VARIABLE DECLARATION
Variable: a name associated with a memory cell whose value
can change. Its simply a memory storage.

Variable Declaration: specifies the data type of a variable

⚫ Example: int num;

Variable Definition: assigning a value to the declared variable

⚫ Example: int num = 5;
CONSTANTS
Entities that appear in the program code as fixed values.
Any attempt to modify a CONSTANT will result in error.

Major types of constants:

⚫ Integer constants
Positive or negative whole numbers with no fractional part
Example:
const int MAX_NUM = 10;
const int MIN_NUM = -90;
CONSTANTS
⚫ Floating-point constants (float or double)
Positive or negative decimal numbers with an integer
part, a decimal point and a fractional part
Example:
const double VAL = 0.5877e2; (stands for 0.5877 x
102)
const double pi = 3.412;
Character constants
⚫ A character enclosed in a single quotation mark
⚫ Example:
const char letter = ‘n’;
const char number = ‘1’;
BASIC DATA TYPES
There are 4 basic data types :
⚫ int
⚫ float
⚫ double
⚫ Char

int
⚫ used to declare numeric program variables of integer type
⚫ whole numbers, positive and negative
⚫ keyword: int
int number;
number = 12;
BASIC DATA TYPES
float
⚫ fractional parts, positive and negative
⚫ keyword: float
float height;
height = 1.72;

double
⚫ used to declare floating point variable of higher precision or
higher range of numbers
⚫ exponential numbers, positive and negative
⚫ keyword: double
double valuebig;
valuebig = 12E-3;
BASIC DATA TYPES
char
⚫ equivalent to ‘letters’ in English language
⚫ Example of characters:
Numeric digits: 0 - 9
Lowercase/uppercase letters: a - z and A - Z
Space (blank)
Special characters: , . ; ? “ / ( ) [ ] { } * & % ^ < > etc
⚫ single character
⚫ keyword: char
char my_letter;
my_letter = 'U';

Qualifiers: short, long, unsigned, signed, const

ARITHMETIC OPERATORS
The major operators in any programming language are +
(Plus), - (Minus), * (Multiplication), /(Division)

Others include:
Increment: a++
⚫ Example
⚫ int a=5;

⚫ a++ =6;

Modulus (remainder): %
⚫ Example:
⚫ 12%5 = 2;
ARITHMETIC OPERATORS
Assignment by addition: +=
⚫ Example:
⚫ int a=4;
⚫ a+=1; (means a=a+1) value of a becomes 5

Comparison Operators: <, > , <=, >= , != (not equal), ==, ! (logical
not), && (logical and), ||(logical or) .
⚫ Example:
⚫ int a=4, b=5;
⚫ a<b returns a true value.

Bitwise Operators: << (shift left), >>(shift right), ~(bitwise not), &
(bitwise and), |(bitwise or) ,^ (bitwise xor).
⚫ Example
⚫ int a=8;
⚫ a= a>>1; // value of a becomes 4
OPERATOR PRECEDENCE
Meaning of a + b * c ?
Is it a+(b*c) or (a+b)*c ?
All operators have precedence over each other
*, / have more precedence over +, - .
⚫ If both *, / are used, associativity comes into picture. (more on this
later)
⚫ Example :
⚫ 5+4*3 = 5+12= 17.
PRECEDENCE TABLE
Highest on top

++ -- (Postfix)

++ -- (Prefix)

* / %

+ -

<< >>

< >

&

&&

||
THE COMMA OPERATOR
The operator enables you to put more than one expression on a
single line by separating each one with a comma.
e.g int i = 10; j = 25;
CONTROL
STRUCTURES OF
ALGORITHMS
 CONTROL STRUCTURES OF ALGORITHMS
What kinds of control structures are necessary in order to describe
algorithms?

(1) Sequence: This structure is the most elementary structure. The

sequence structure is a case where the steps in an algorithm are
constructed in such a way that, no condition step is required.
For example, suppose you are required to design an algorithm for
finding the average of Six numbers, and the sum of the numbers is
given.
Algorithm:
1. Start
2. Input Sum
3. Average = Sum / 6
4. Output Average
5. Stop
 CONTROL STRUCTURES OF ALGORITHMS
2) Selection: The selection structure also known as decision
structure is a case in the algorithm where one has to make a
choice of two alternatives by making a decision depending on a
given condition.

A selection structure takes the form:

If condition is true
Then do task A
else
Do TaskB
CONTROL STRUCTURES OF ALGORITHMS
The selection requires the following:
• Choose alternative actions as a result of testing a logical
condition
• Produce code to test a sequence of logical tests

In making choices, IF statement is used together with logical

operators to test for true or false.

The logical operators used are:

= is equal to <= is less than or equal
> is greater than <> is not equal to
< is less than
>= is greater than or equal
 IF STATEMENT
The If statement appears as follows:
if (condition)
{
statements;
}
-The statement is executed only if Condition is True
-If condition is false, the statement is ignored and the next
appropriate statement is simply executed.
e.g
If (sales > 5000)
{
bonus=500;
}
 THE IF-ELSE STATEMENT
The If-else statement never appears in a program without the If
statement. The syntax is:
if (condition)
{
statements;
}
else
{
statements;
}
E.g
if (production > target)
{
 target *=1.10;
}
else
{
target*=0.90;
}
 CONTROL STRUCTURES OF ALGORITHMS
(3) Iteration: this requires repeating a block of instructions until a
logical event is verified or not.

The iteration structure can be implemented using

• Repeat Until Loop • The While Loop • The For Loop

Any program instruction that repeats some statement or

sequence of statements a number of times is called an iteration
or a loop. The commands used to create iterations or loops are
all based on logical tests.
CONTROL STRUCTURES OF ALGORITHMS
Repeat Until Loop
The syntax is
REPEAT
A statement or block of statements
UNTIL
a true condition

For example, A program repeatedly asking for an entry of a

number in the range 1 to 100 until a valid number is entered.
REPEAT
Output “Enter a number between 1 and 100”
UNTIL
number >= 1 OR number <= 100
 CONTROL STRUCTURES OF ALGORITHMS
THE WHILE LOOP
The second type of iteration. This type of conditional loop tests for terminating
condition at the beginning of the loop.

The syntax is:

WHILE (a condition is true)
A statement or block of statements
ENDWHILE

The while loop enables your programs to repeat a series of statements, over and
over, as long as a certain condition has not been met. The format is:

while (condition)
{
statements;
}
 CONTROL STRUCTURES OF ALGORITHMS
The For Loop: The third type of iteration. This, in its simplest
form, uses an initialisation of the variable as a starting point, a
stop condition depending on the value of the variable. The
variable is incremented on each iteration until it reaches the
required value.
The syntax is:
FOR (starting state, stopping condition, increment) Statements
ENDFOR

For example:
FOR (n = 1, n <= 4, n++)
Output n
ENDFOR
FOR LOOP Cont’d
For (initialization; stopping condition; increment/decrement)
e.g
For (j=2; j<=80; j+=5)
For (i=10; i>=1; i--)
For (j=99; j>=0; j-=11)

THE DO-WHILE LOOP

It is similar to the while loop except the test condition occurs at the
end (rather than the beginning) of the loop. The syntax of do-while is:
do
{
statements
}
while (condition)
CONTROL STRUCTURES OF ALGORITHMS
Introduction to C
Programming
language
HISTORY OF C
In 1972 Dennis Ritchie at Bell Labs writes C and in 1978 the
publication of The C Programming Language by Kernighan
& Ritchie caused a revolution in the computing world

In 1983, the American National Standards Institute (ANSI)

established a committee to provide a modern, comprehensive
definition of C. The resulting definition, the ANSI standard, or
"ANSI C", was completed late 1988.
WHY IS C USEFUL?
C provides:
● Efficiency, high performance and high quality
● flexibility and power
● Stability and small size code
● Provide functionality through rich set of function libraries
● Gateway for other professional languages like
C C++ Java

C is used:
● system software Compilers, Editors, embedded systems
● data compression, graphics and computational geometry, utility
programs
● databases, operating systems, device drivers, system level routines
● there are zillions of lines of C legacy code
● also used in application programs
BASICS OF C ENVIRONMENT
C systems consist of 3 parts
⚫ C development environment
⚫ Language
⚫ C Standard Library

C Development environment has 6 phases

⚫ Edit
⚫ Pre-processor
⚫ Compile
⚫ Link
⚫ Load
⚫ Execute
 C DEVELOPMENT ENVIRONMENT

Program edited in
Editor and stored
Phase 1 Editor Disk on disk

Preprocessor
program processes
Phase 2 Preprocessor Disk the code

Creates object code

and stores on disk
Phase 3 Compiler Disk

Links object code

with libraries and
Phase 4 Linker Disk stores on disk
 C DEVELOPMENT ENVIRONMENT

Primary memory
Puts program in
memory
Phase 5 Loader

Primary memory
Takes each instruction
and executes it storing
Phase 6 CPU new data values
C COMPILERS, LINKERS, LOADERS
 FEW NOTES ON C PROGRAM…
C is a Structured programming language.

C is case-sensitive
⚫ Word, word, WorD, WORD, WOrD, worD, etc are all different
variables / expressions
Eg. sum = 23 + 7
What is the value of Sum after this addition ?
THE GENERAL FORM OF A SIMPLE PROGRAM
Simple C programs have the form
directives
int main ()
{
statements
}
C uses { and } in much the same way that some other
languages use words like begin and end.
Even the simplest C programs rely on three key language
features:
⚫ Directives
⚫ Functions
⚫ Statements
DIRECTIVES
Before a C program is compiled, it is first edited by a
preprocessor.
Commands intended for the preprocessor are called directives.
Example:
#include <stdio.h>
<stdio.h> is a header containing information about C’s
standard I/O library.
Directives always begin with a # character.
By default, directives are one line long; there’s no semicolon or
other special marker at the end.
Two most common directives :
⚫ #include
⚫ #define
FUNCTIONS
Every C program consists of one or more modules called
FUNCTIONS. One of the functions must be called main where the
execution begins when the program is run.
A function is a self-contained module of code that can accomplish
some task.
A function is a sub-unit of a program that performs a specific task.

Each function must contain:

⚫ a function heading
⚫ a list of argument declarations (arguments are also referred to as
parameters.
⚫ a block of statements, which is enclosed within a pair of braces { }
⚫ The braces may contain one or more elementary statements or other
block of statements.
i.e {
{
}
}
 FUNCTIONS
The program will always begin by executing the main function,
which may access other functions. Every function must return a
value.

THE MAIN FUNCTION

The main function is mandatory.
main is special: it gets called automatically when the program
is executed.
main returns a status code; the value 0 indicates normal
program termination.
If there’s no return statement at the end of the main
function, many compilers will produce a warning message.
STATEMENTS
A statement is a command to be executed when the program
runs.
Asking a function to perform its assigned task is known as
calling the function.
Each statement in C needs to be terminated with semicolon
(;)

Statement has two parts :

⚫ Declaration
The part of the program that tells the compiler the names
of memory cells in a program
⚫ Executable statements
Program lines that are converted to machine language
instructions and executed by the computer
FEW NOTES ON C PROGRAM…
Comments
⚫ are inserted into the code using /* to start and */ to end a
comment
⚫ Some compiler support comments starting with //
⚫ Such comments are useful in explaining the underlying logic
of various program features
⚫ They may appear anywhere within a program, as long as they
placed within delimiters /* and */ or //

⚫ Provides supplementary information but is ignored by the

preprocessor and compiler
/* Program to calculate the area of a circle*/
// This program was written by Iyabo Moshood
 C SYNTAX

#include inserts another file. “.h” files are called “header”

files.
What do the < >
mean?
This is a comment. The compiler ignores this.

#include <stdio.h>
The main() function is always
/* The simplest C Program */ where your program starts
int main(int argc, char **argv) running.
{
printf(“Hello World\n”);
Blocks of code (“lexical
scopes”) are marked by { … }
return 0;
}

Returning a value from the

Print out a message. ‘\n’ means “new line”.
function
 A QUICK DIGRESSION ABOUT THE COMPILER

#include <stdio.h>
/* The simplest C Program */
Compilation occurs in two steps:
int main(int argc, char **argv)
Preprocess
{
printf(“Hello World\n”);
“Preprocessing” and “Compiling”
return 0;
}

__extension__ typedef unsigned long long int __dev_t; In Preprocessing, source code is “expanded” into a
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t; larger form that is simpler for the compiler to
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef unsigned long long int __ino64_t; understand. Any line that starts with ‘#’ is a line that is
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t; interpreted by the Preprocessor.
__extension__ typedef long long int __off64_t;
extern void flockfile (FILE *__stream) ;
extern int ftrylockfile (FILE *__stream) ;
extern void funlockfile (FILE *__stream) ;
int main(int argc, char **argv)
• Include files are “pasted in” (#include)
{
printf(“Hello World\n”);
• Macros are “expanded” (#define)
}
return 0;
• Comments are stripped out ( /* */ , // )
• Continued lines are joined ( \ )

my_progr The compiler then converts the resulting text into

am binary code the CPU can run directly.
Compile
 FUNCTIONS
A Function is a series of instructions to run. You pass
Arguments to a function and it returns a Value.

“main()” is a Function. It’s only special because it always

gets called first when you run your program.

Return type, or void

#include <stdio.h>
Function Arguments

/* The simplest C Program */

int main(int argc, char **argv)
{ Calling a Function: “printf()” is just another
printf(“Hello World\n”); function, like main(). It’s defined for you in a
“library”, a collection of functions you can
return 0;
call from your program.
}
Returning a value
SIMPLE C PROGRAM
/* A first C Program*/

#include <stdio.h>

void main()

{
printf("Hello World \n");

}
 SIMPLE C PROGRAM
Line 1: #include <stdio.h>
As part of compilation, the C compiler runs a program called the
C preprocessor. The preprocessor is able to add and remove
code from your source file.
In this case, the directive #include tells the preprocessor to
include code from the file stdio.h.
This file contains declarations for functions that the program
needs to use. A declaration for the printf function is in this
file.

Line 2: void main()

This statement declares the main function.
The "void" specifies the return type of main. In this case,
nothing is returned to the operating system.
 SIMPLE C PROGRAM
Line 3: {
This opening bracket denotes the start of the program.

Line 4: printf("Hello World \n");

Printf is a function from a standard C library that is used to print
strings to the standard output, normally your screen.
The compiler links code from these standard libraries to the code
you have written to produce the final executable.
The "\n" is a special format modifier that tells the printf to put a
line feed at the end of the line.

Line 5: }
This closing bracket denotes the end of the program.
C PROGRAM STRUCTURE
Another example of simple program in C

#include <stdio.h>

int main()
{
printf(“I love programming\n”);
printf(“You will love it too once ”);
printf(“you know the trick\n”);
return 0;
}
THE OUTPUT
The previous program will produce the following output on your
screen

I love programming
You will love it too once you know the trick
INPUT/OUTPUT FUNCTIONS
A few functions that are pre-defined in the header file <stdio.h>
such as :
⚫ printf()
⚫ scanf()
⚫ getchar() & putchar()

1. The printf function

Used to send data to the standard output (usually the monitor) to be
printed according to specific format.

General format:
1.printf(“string literal”);
A sequence of any number of characters surrounded by double quotation
marks.
E.g printf(“Thank you\n”);
Thank you
THE PRINTF FUNCTION CONT…
2.printf(“format string”, variables);
Format string is a combination of text, format specifier and escape
sequence.
E.g printf (“Total sum is: %d\n”, sum);

Total sum is: 50

Assuming that the
value of sum is 50
%d is a placeholder (format specifier)
marks the display position for a type integer variable
a common format identifier used in printf function.

\n is an escape sequence
moves the cursor to the new line
PLACEHOLDER / FORMAT SPECIFIER
2. THE SCANF FUNCTION
Reads data from the standard input device (usually keyboard)
and stores it in a variable.
General format:
⚫ scanf(“format string”, &variable);
E.g scanf (“%d” , &a);

Ampersand (&) operator :

⚫ it passes the address of the variable
⚫ tells the scanf() where to find the variable to store the new value

Format string is a combination of format specifier and escape

sequence (if any).
THE SCANF FUNCTION CONT…
Common Format Identifier used in printf and scanf functions.

printf scanf
int %d %d
float %f %f
double %f %lf
char %c %c
Example : string %s %s
int age;
printf(“Enter your age:”);
scanf(“%d”, &age);
THE SCANF FUNCTION CONT…
If you want the user to enter more than one value, you serialise the
inputs.

Example:

float height, weight;

printf(“Please enter your height and weight:”);

scanf(“%f%f”, &height, &weight);
GETCHAR() AND PUTCHAR()

getchar() - read a character from standard input

putchar() - write a character to standard output
Example:
Please type a character: h
You have typed this character: h

#include <stdio.h>
int main
{
char my_char;
printf(“Please type a character:”);
my_char = getchar();
printf(“\nYou have typed this character: ”);
putchar(my_char);
return 0;
} 96
GETCHAR() AND PUTCHAR() CONT

Alternatively, you can write the previous code using

normal printf / scanf and %c placeholder.
Example
#include <stdio.h>
int main
{
char my_char;
printf(“Please type a character: ”);
scanf(“%c”,&my_char);
printf(“\nYou have typed this character: %c”, my_char);
return 0;
}
Please type a character: h
You have typed this character: h
 A SIMPLE C PROGRAM
1 /* A first program in C */
2 #include <stdio.h>
3
4 int main()
5 {
6 printf( "Welcome to C!\n" );
7
8 return 0;
9 }
Welcome to C!

Comments
⚫ Text surrounded by /* and */ is ignored by computer
⚫ Used to describe program
#include <stdio.h>
⚫ Preprocessor directive
Tells computer to load contents of a certain file
⚫ <stdio.h> allows standard input/output operations
int main()
⚫ Parenthesis used to indicate a function
⚫ int means that main "returns" an integer value
⚫ Braces ({ and }) indicate a block
The bodies of all functions must be contained in braces

printf( "Welcome to C!\n" );

⚫ Instructs computer to perform an action
Specifically, prints the string of characters within quotes (“ ”)
⚫ Entire line called a statement
All statements must end with a semicolon (;)
⚫ Escape character (\)
Indicates that printf should do something out of the ordinary
\n is the newline character

return 0;
⚫ A way to exit a function
⚫ return 0, in this case, means that the program terminated normally

Right brace }
⚫ Indicates end of main has been reached
 A SIMPLE C PROGRAM

1 /* Addition program */
2 #include <stdio.h>
3
4 int main()
5 {
6 int integer1, integer2, sum; /* declaration */
7
8 printf( "Enter first integer\n" ); /* prompt */
9 scanf( "%d", &integer1 ); /* read an integer */
10 printf( "Enter second integer\n" ); /* prompt */
11 scanf( "%d", &integer2 ); /* read an integer */
12 sum = integer1 + integer2; /* assignment of sum */
13 printf( "Sum is %d\n", sum ); /* print sum */
14
15 return 0; /* indicate that program ended successfully */
16 }
OUTPUT
Enter first integer
45
Enter second integer
72
Sum is 117
1 /* Using if statements, relational
2 operators, and equality operators */
3 #include <stdio.h>
4
5 int main()
6 {
7 int num1, num2;
10
11 printf( "Enter two integers, and I will tell you\n" );
12 printf( "the relationships they satisfy: " );
13 scanf( "%d%d", &num1, &num2 ); /* read two integers */
14
15 if ( num1 == num2 )
16 printf( "%d is equal to %d\n", num1, num2 );
17
18 if ( num1 != num2 )
19 printf( "%d is not equal to %d\n", num1, num2 );
20
21 if ( num1 < num2 )
22 printf( "%d is less than %d\n", num1, num2 );
23
24 if ( num1 > num2 )
25 printf( "%d is greater than %d\n", num1, num2 );
26
27 if ( num1 <= num2 )
28 printf( "%d is less than or equal to %d\n",
29 num1, num2 );
 30
31 if ( num1 >= num2 )
32 printf( "%d is greater than or equal to %d\n",
33 num1, num2 );
34
35 return 0; /* indicates program ended
successfully
36 } */

Enter two integers, and I will tell you

the relationships they satisfy: 3 7
3 is not equal to 7
3 is less than 7
3 is less than or equal to 7

Enter two integers, and I will tell you

the relationships they satisfy: 22 12
22 is not equal to 12
22 is greater than 12
22 is greater than or equal to 12
 MORE EXAMPLES
#include <stdio.h>
// program prints a number of type int
int main()
{
int number = 4;
printf (“Number is %d”, number);
return 0;
}

Output: Number is 4
MORE EXAMPLES
#include <stdio.h>
// program reads and prints the same thing
int main()
{
int number ;
printf (“ Enter a Number: ”);
scanf (“%d”, &number);
printf (“Number is %d\n”, number);
return 0;
}

Output : Enter a number: 4

Number is 4
C TOKEN
Tokens are a series of continuous characters that compilers
treat as separate entities.

Tokens can be classified into:

1. Reserved words (also known as keywords)
2. Identifiers
3. Constants
4. String Literal
5. Punctuators
6. Operators
RESERVED WORDS
Keywords that identify language entities such as
statements, data types, language attributes, etc.
Have special meaning to the compiler, cannot be used as
identifiers (variable, function name) in our program.
Should be typed in lowercase.
Example: const, double, int, main, void, printf, while, for,
else (etc..)
IDENTIFIERS
Words used to represent certain program entities (variables,
function names, etc).
Example:
⚫ int my_name;
my_name is an identifier used as a program variable
⚫ void CalculateTotal
CalculateTotal is an identifier used as a function name
RULES FOR NAMING IDENTIFIERS

Rules Example
Can contain a mix of characters and numbers. H2o
However it cannot start with a number

First character must be a letter or underscore Number1; _area

Can be of mixed cases including underscore XsquAre

character my_num
Cannot contain any arithmetic operators R*S+T
… or any other punctuation marks… #@x%!!

Cannot be a C keyword/reserved word struct; printf;

Cannot contain a space My height
… identifiers are case sensitive Tax != tax
CONSTANT EXAMPLE – VOLUME OF A CONE
#include <stdio.h>

int main ()
{
const double pi = 3.412;
double height, radius, base, volume;

printf(“Enter the height and radius of the cone:”);

scanf(“%f %f”, &height, &radius);

base = pi * radius * radius;

volume = (1.0/3.0) * base * height;

printf(“\nThe volume of a cone is %f ”, volume);

return 0;
}
#DEFINE
You may also associate constant using #define preprocessor directive

#include <stdio.h>
#define pi 3.142

int main ()
{
double height, radius, base, volume;

printf(“Enter the height and radius of the cone:”);

scanf(“%f %f”, &height, &radius);

base = pi * radius * radius;

volume = (1.0/3.0) * base * height;

printf(“\nThe volume of a cone is %f ”, volume);

return 0;
}
STRING LITERAL
A sequence of any number of characters surrounded by double
quotation marks “ ”.
Example of usage in C program:
printf(“What a beautiful day.\n”);

What a beautiful day.

To have double quotation marks as part of the sentence, precede

the quote with backslash
printf(“He shouted \“stop!\” to the thief.\n”);

He shouted “stop!” to the thief.

PUNCTUATORS (SEPARATORS)
Symbols used to separate different parts of the C program.
These punctuators include:
[ ] ( ) { } , ; “: * #
Example:

#include <stdio.h>

int main ()
{
int num = 10;
printf(“%d”,num);
return 0;
}
 MORE EXAMPLES

side1 = 4 - 1 = 3
side2 = 7 - 5 = 2

• Convert the above outlined solution to a program in C

 ARRAYS
The array is another kind of variable that is used extensively in C.
An array is an identifier that refers to a collection of data items
that all have the same name. The data items must all be of the
same type (e.g., all integers, all characters, etc.).
The individual data items are represented by their corresponding
array-elements, each element of the array can be accessed
referring to its position in the array.
E.g Suppose that x is a 10-element array,
int x[10];
The first element is referred to as x[0] ,the second as x[1] ,....,the
last element will be x[9].
ONE-DIMENSIONAL ARRAY
E.g char charray [20];
⚫ The datatype is defined as char
⚫ The array name is charray
⚫ The array has 20 elements, indicated by [20]

Initializing one-dimensional array

An array can be defined as:
int var[5] = {10,20,30,40,50};

When initializing an array, all the elements must be grouped

within a pair of delimiters { } and must be seperated by commas.
If there are more elements within delimiters than indicated by
the limit, a compiler error will result
e.g int var[5] = {1,2,3,4,5,6};

However, an array can have fewer elements than the limit e.g int
var[5] = {1,2,3,4};
-all shortages are set to 0 by default.

Sometimes, no number is supplied for the size of an array, so the

compiler counts the number of items between delimiters and
sets the array size to that number e.g int var[ ] = {1,2,3,4};
 MULTI-DIMENSIONAL ARRAY
Multidimensional arrays are defined in much the same manner as
one-dimensional arrays, except that a separate pair of square
brackets is required for each array. Thus, a two-dimensional
array will require two
pairs of square brackets, a three-dimensional array will require
three pairs of square brackets, etc

Example: Consider a computer supplies where 2 sales

representatives are employed. Considering 12 rows, one for each
month of the year, and 2 columns, one for the sales rep. The
array can be represented as:
int sales [12][2];
You can declare 3 separate arrays for 6,12 or 18 elements:
int sales1 [6][2];
int sales2 [12][2];
int sales3 [18][2];

The #define directive can be used to define a symbolic constant

#define LIMIT 18
int main ( )
{
int sales1 [6][2];
int sales2 [12][2];
int sales3 [18][2];
M X N 2-DIMENSIONAL ARRAY
 Initializing multi-dimensional array
Considering an array where the months of the year are divided into 4
seasons. This array definition has 4 rows that represents the
seasons and 3 elements in each row to represent the 3 months in
each season e.g
int seasons [4][3] = {
{3,4,5}, /*spring*/
{6,7,8}, /*summer*/
{9,10,11}, /*fall*/
{12,1,2} /*winter*/
};

The array representing the four seasons of the year could be

written like this:
int seasons[4][3] = {3,4,5,6,7,8,9,10,11,12,1,2};
 Each element in the array can be accessed like this:
Seasons [1][2] contains the value 8
Seasons [2][0] contains the value 9

*Declaring a character array*

char arr [5] = {‘h’ , ‘e’, ‘l’, ‘l’, ‘o’};

*Declaring numeric array*

int arr [5] = {1,2,3,4,5};
PROGRAM TO CONVERT LOWERCASE TO UPPERCASE
TEXT
Here is a complete program that reads in a one-dimensional character
array, converts all of the elements to uppercase, and then displays the
converted array.

/ * reads in a line of lowercase text to uppercase */

#include <stdio.h>
#include <ctype.h>

#define SIZE 80
int main ( )
{
char letter[SIZE] ;
int count ;
/ * read in the line */
for (count = 0; count < SIZE; ++count)
letter[count] = getchar();
/* display the line in upper case */
for (count = 0; count < SIZE; ++count)
put char ( toupper ( letter[count])) ;
}
PASSING AN ARRAY TO A FUNCTION
It is possible to pass an array to a function as an argument. When
declaring a one-dimensional array as a formal argument, the array
name is written with a pair of empty square brackets. The size of the
array is not specified within the formal argument declaration.

Considering the fragment of a program below:

float average(int a, float x[ ]) ; /* function prototype * /
int main( )
int n; /* variable DECLARATION */
float avg ; /* variable DECLARATION */
float list[100]; /* array DEFINITION */
.....
avg = average(n, list ) ;
.....
 POINTERS

A pointer is a variable that represents the location (rather than

the value) of a data item, such as a variable or an array element.
Pointers are used frequently in C, as they have a number of
useful applications. For example, pointers can be used to pass
information back and forth between a function and its reference
point.

A pointer is a variable that contains the address of a variable.

Pointers are also closely associated with arrays and therefore
provide an alternate way to access individual array elements.
 So if c is a char and p is a pointer that points to it, it can be
represented by:

To set a pointer to a variable’s address use & before the variable as

in,
x = &y;

In this example, x will now point to y, that is, x stores y’s address, where
& is a unary operator, called the address operator, that evaluates
the address of its operand.

x, a pointer to y, referred to as a pointer variable. since it “points”

to the location where y is stored in memory.

Note, however, that x represents y’s address, not its value.

To get the value that x points to, use * (as in *x), where * is a
unary operator that operates only on a pointer variable, called
the indirection (or dereferencing) operator, because it requires
a second access, that is, its a form of indirect addressing
All pointers are typed based on the type of entity that they point
to, e.g int *x;
So, if we write x = &y and U = *x, then U and y will both
represent the same value i.e the value of y will indirectly be
assigned to U.

Ex: Consider the simple C program shown below.

#include <stdio.h>
int main( )
int u1 , u2;
int a = 3;
int *b;
u1 = 2 * (a + 5 ) ; /* ordinary expression */
 b = &a; /* b points to a */
u2 = 2 * (*b + 5 ) ; /* equivalent expression */
printf("\nu1=%d u2=%d", u1 , u2);
}

This program involves the use of two integer expressions. The

first, 2 * (a + 5), is an ordinary arithmetic expression whereas the
second, 2 * ( *b + 5 ) , involves the use of a pointer. The
expressions are equivalent, since a and *b each represents the
same integer value.

The following output is generated when the program is executed.

u1= 16 u2=16
 EXAMPLE CODES
int x = 1, y = 2, z[10]; // z[10] is an array with 10 elements
int *ip; // ip is a pointer to an int, so it can point to x, y, or an element of z
ip = &x; // ip now points at the location where x is stored
y = *ip; // set y equal to the value pointed to by ip, or y = x
*ip = 0; // now change the value that ip points to to 0, so now x = 0
// but notice that y is unchanged
ip = &z[0]; // now ip points at the first location in the array z
*ip = *ip + 1; // the value that ip points to (z[0]) is incremented

int x, *y, z, *q;

x = 3;
y = &x; // y points to x
printf("%d\n", x); // outputs 3
printf("%d\n", y); // outputs x’s address, will seem like a random number to us
printf("%d\n", *y); // outputs what y points to, or x=3
printf("%d\n", *y+1); // outputs 4 (print out what y points to + 1)
printf("%d\n", *(y+1)); // this outputs the item after x in memory – what is it?
z = *(&x); // z equals 3 (what &x points to, which is x)
q = &*y; // q points to 3 (note *& and &* cancel out)
 USING POINTERS WITH ARRAYS
Considering ip = &z[0];
-this sets the pointer to point at the first element of the array
What about accessing z[1]?
⚫ 1 can be added to the location pointed to by ip i.e, *(ip+1)

⚫ Array Example Using a Pointer

int x[4] = {12, 20, 39, 43}, *y;
y = &x[0]; // y points to the beginning of the array
printf("%d\n", x[0]); // outputs 12
printf("%d\n", *y); // also outputs 12
printf("%d\n", *y+1); // outputs 13 i.e (12 + 1)
printf("%d\n", (*y)+1); // also outputs 13
printf("%d\n", *(y+1)); // outputs x[1] or 20
y+=2; // y now points to x[2]
printf("%d\n", *y); // prints out 39
*y = 38; // changes x[2] to 38
printf("%d\n", *y-1); // prints out x[2] – 1 = 37
*y++; // sets y to point at the next array element
printf("%d\n", *y); // outputs x[3]=43
(*y)++; // sets what y points to to be 1 greater
printf("%d\n", *y); // outputs the new value of x[3] =44