1ST SEMESTER: FINALS EXAMINATION

CP1 – COMPUTER PROGRAMMING (COMP 002)

Geuel John D. Rivera | BSCS 1-5 | Prof. Arnie Fabregas

SYLLABUS RULES OR PRECEDENCE & ASSOCIATIVITY

1. Program Control Structures (Loops)
2. Array Operators Associativity
3. Functions
+ (unary), - (unary), ++, --, ! Right to left

PROGRAM CONTROL STRUCTURE

/, *, % Left to right

+, - Left to right
CONTROL STRUCTURE
● Analyzes and chooses in which direction a program <, <=, >, >= Left to right
flows based on certain parameters or conditions.
==, != Left to right
● Way to specify flow of control in programs.
● Any algorithm or program can be clearer and more && Left to right
understood if they use control structures as self-
contained modules.
|| Left to right
● Three types of logic/flow of control:
o Sequence logic/flow =, +=, -=, *=, /=, etc. Right to left
o Selection logic/conditional flow
o Iteration logic/repetitive flow
• ! operator is unary (operator with only one operand).
FLOW OF CONTROL
• All other relational, equality and logical operators
are binary.
SEQUENTIAL FLOW OF CONTROL o 0 or 0.0 or \0 or NULL = false.
● Statements in a program are normally executed one o Any non-zero = true.
after another. COMPOUND STATEMENT
● Often it is desirable to alter the sequential flow of control
● Series of declarations and statements surrounded by
to provide for a choice of action, or repetition of action.
braces. It is also known as block.
● By means of if, if-else, and switch statement, a
● Purpose:
selection among alternative actions is made.
o Grouping statements into an executable unit.
● By means of while, for and do statements, interactive o Achieve the desired flow of control in if, if-else,
actions can be taken. while, for, and switch statements.
● Syntax:
RELATIONAL, EQUALITY, LOGICAL OPERATORS compound_statement{{declaration}{statement}}

Symbol Meaning Expression Example:

#include <stdio.h>
#include <conio.h>
RELATIONAL OPERATORS void main()
{
< Less than expr < expr int a=1, b, c;
{
> Greater than expr > expr b=2;
c=3;
}
<= Less than or equal to expr <= expr getch();
}
>= Greater than or equal to expr >= expr

EQUALITY OPERATORS
CONDITIONAL STATEMENTS
== Equal expr == expr The if statement
● Form:
!= Not equal expr != expr if (expr)
statement;
EQUALITY OPERATORS ● Action: If expr is non-zero (true), then statement is
executed; otherwise statement is skipped control
! (unary) Negation !expr passes to the next statement.
● Example:
&& Logical “end” expr && expr if (grade >= 90)
printf(“Congratulations!);
|| Logical “or” expr || expr printf(“Your grade is %d\n”, grade);

Expressions in if statement is relational,

logical, equality is permissible in any domain.
1ST SEMESTER: FINALS EXAMINATION
CP1 – COMPUTER PROGRAMMING (COMP 002)
Geuel John D. Rivera | BSCS 1-5 | Prof. Arnie Fabregas

The if-else statement ● continue; Causes the current iteration of the loop to
● Form: stop and causes the next iteration of the loop to begin
if (expr) immediately. Occurs inside for, while, and do loops.
statement; ● Example:
else do {
statement2; scanf(“%d”,&num);
● Action: If expr is non-zero (true), then statement1 is
if (x < 0 )
continue;
executed and statement2 is skipped; if expr is 0 (false), printf(“%d”,x);
then statement1 is skipped and statement2 is executed. } while (x != 100);
If both cases are 0, it will pass to the next statement.
● Example: An if-else statement can be used as the statement
if (a > b) { part of another if statement, this is what you
b++; call nested if.
printf(“Value is smaller %d\n”, b);
} ● Example:
else if(x == 50) {
printf(“You got a bigger value %d\n”, a); if(y >= 120) {
sum = x + y;
An if-else statement can be used as the statement printf(“the sum of x and y is %d”, sum);
}
part of another if statement, this is what you
else {
call nested if. diff = x – y;
printf(“the difference between x and y is %d”, diff);
● Example: }
if(x == 50) { else {
if(y >= 120) { printf(“Next time”);
sum = x + y; }
printf(“the sum of x and y is %d”, sum); LOOPS
}
else { ● Repetition of action in computers where a looping
diff = x – y; control mechanism executes specific statements, which
printf(“the difference between x and y is %d”, diff); is convenient for fixing large amounts of data.
}
else { The while statement
printf(“Next time”);
}
● Form:
while(expr)
The switch statement statement;
● Form: next statement;
switch(expression) {
case <constant expression>:
● Action: Expr is evaluated. If expr is non-zero (true), then
statement is executed and passed back at the beginning
statement;
of loop; when it reaches expr as 0 (false), the control will
break;
execute the next statement.
case <constant expression>:
statement; ● Example:
break; while(number != 0) {
default: scanf (“%d”,&number);
statement; sum += number;
}
● Action: Evaluates to an int, conditional, char, or double printf(“ the sum of all numbers is %d”,sum);
value.
- Case list: consists of constants whose type matches
The for statement
that of the switch expression. (no var/expr) ● Form:
- Break: at the point, execution should jump to the end for(initialization; condition; increment)
of the switch statement. statement;
- Default: specifies an action to be taken if the value ● Action: Allows many variants, but there are three parts:
of the switch expression does not match any of the o Initialization – assignment statement that is used to
listed values. set the loop control variable.
o Condition – expression that determines when the
Unconditional Transfer Statement loop will exit.
● break(); Used to terminate a case in a switch statement; o Increment - defines how the loop control variable will
terminates loop through bypassing, but program control change each time the loop is repeated.
resumes at the next statement. ● Example:
● Example: for(x = 100; x != 65; x += 5) {
while(1) { z = sqrt(x);
scanf(“%lf”, &x); printf(“The square root of %d is %f”,x, z);
if(x < 0.0) }
break;
printf(“%f\n”, sqrt(x)); An important point above for loop is that conditional
} test is always performed at the top of the loop. This
means that the code inside the loop may not be executed
at all if the condition is FALSE to begin with. For loops
can be also nested.
1ST SEMESTER: FINALS EXAMINATION
CP1 – COMPUTER PROGRAMMING (COMP 002)
Geuel John D. Rivera | BSCS 1-5 | Prof. Arnie Fabregas
The do statement
● Form:
do {
statement;
} while(expr);
next statement;
● Action: First statement is executed and expr is
evaluated. If true, control passes back to the beginning
of the do statements and loops. If false, control passes
to the next statement.
● Example:
do {
scanf(“%d”,&num);
sum += num;
} while (num > 100);
printf(“Then sum is %d”, sum);
ARRAY
● Fixed-size, sequenced collection of elements of the
same data type.
● Sequence of data items that are of the same type, they
are indexable, and that are stored contiguously.
● Represent a large number of homogeneous values.
● Since the elements can be individually addressed, we
can refer the elements through subscripts or square
brackets.
● Example: El0, El[0]
● Loops are used to process arrays more
conveniently.
● Indexing – A convention where you refer elements
through their specific place or order with subscripts or
square brackets. (Number[i]).
DECLARATION AND DEFINITION
● Declaration and definition tells the compiler:
o The name of the array
o The type of each element
o The size or number of elements in the array.
● They are defined in the same manner as ordinary
variables, except that each array name must be
accompanied by a size specification (number of
elements).
● For one dimensional array, the size is specified by a
positive integer expression enclosed in square brackets.
● General Form:
storage class data-type array[expression];
● Example:
int ccis[5];
char mander[30];
float coke[10];
double dutch[12];
● In each case, all of the array elements are automatically
set to 0 except those that have been explicitly initialized
within the array definition.
● One dimensional array string data type – a character
in a string can be accessed either as an element in an
array by making use of a pointer to character. The
flexibility it proves makes C especially useful in writing
string processing programs.
● How strings are handled:
o When string constant is assigned to an external or
a static character array as part of the array
definition, the array size specification is usually
omitted.
o It provides a null character ‘\0’ automatically at the
end of every string.
● Example: hev[4] = “ABI”
hev[0] = “A”; hev[1] = “B”; hev[2] = “I”; hev[3] = ‘\0’
ACCESSING ELEMENTS IN ARRAYS
● C uses an index to access individual elements in an
array. The index must be integral value or an expression
that evaluates to an integral value.
● The simplest form for accessing an element is a
numeric constant.
● Example: score[20]; refer: score[0], score[1]
● The array’s name is a symbolic reference for the
address to the first byte of the array.
● The index represents an offset from the beginning of the
array to the element being referred to.
● With these two pieces of data, C can calculate the
address of any element in the array using the following
simple formula:
element address = array address + (sizeof(element) * index
For example, assume that scores is stored in memory at
location 10,000. Since scores is an integer, the size of one
element is the size of an integer. Assuming an integer size of
two, the address of the element at index 3 is:
element address = 10,000 + 2 * 3 + 10,006
STORING VALUES IN ARRAY
INITIALIZATION
● Initialization of all elements in an array can be done at
the time of declaration and definition, just as with
variables.
● For each element in the array we provide a value. The
only difference is that the values must be enclosed
in braces and, if there are more than one, separated
by commas.
● It is a compile error to specify more values than there
are elements n the array. The initial values must appear
on the order in which they will be assigned to the
1ST SEMESTER: FINALS EXAMINATION
CP1 – COMPUTER PROGRAMMING (COMP 002)
Geuel John D. Rivera | BSCS 1-5 | Prof. Arnie Fabregas

individual array elements, enclosed in braces and

separated by commas. ADVANTAGES OF USING FUNCTIONS
● General Form:
storage class data-type 1. Fits naturally with the top-down design approach. It helps
arrayname[expression] = {value1, value2,… to streamline the design of a program and prevents small
value n); details from obscuring the program logic.
● Examples: 2. Can be used more than once in a program and in
int first_array[5]; different programs, thereby sharing programming time. It
int second_array[] = {1, 2, 3, 4}; can be viewed as a block box which performs a particular
int third_array[15] = {3, 7, 4, 6, 1}; task within a program, and these blocks helps you to
accomplish various necessary tasks.
● When the array is completely initialized, it is not 3. Provides a natural method for dividing a programming
necessary to specify the size of the array. task among a team of programmers. By defining a
● If the number of value provided is less than the number function as a block box which accepts inputs and
of elements in the array, the unassigned elements are produces output, the function can be programmed as an
filled with zeros. independent entity.
4. Can be tested individually. By testing functions at a time,
INPUTTING VALUES the process of debugging an entire program is organized
● This can be done using a loop when the array is going and simplified.
to be completely filled, the most appropriate loop is the
for loop because the number of element are fixed and
known. FUNCTION DECLARATIONS
● Example: ● Contains the name of the function, type of the value to
int scores[10]; be returned (the data type will be void), and the number
… and types of the arguments that must be supplied in a
for(int i = 0; i < 10; i++) call of the function.
scanf(“%d”, &scores[i]); ● A function declaration may contain argument names.
● Even though we are dealing with array elements, the ● Syntax:
address operator (&) is still necessary in the scanf type function_name (parameter list);
call. ● Example:
● When there is a possibility that all the elements are not void ccis();
going to be filled, then one of the event-controlled loops int ccis(int bscs, int bsit);
(while or do-while) should be used. float ccis(float x, float y);
● Individual elements can be assigned values using the
assignment operator. Any value that reduces to the FUNCTION DEFINITION
proper type can be assigned to an individual array ● Code that describes what a function does.
element. ● It must not be confused with the function declaration.
● Example: ● Form:
int scores[10] = 96; Type function_name (parameter list)
● You cannot assign one array to another array, even if {
they match full in type and size. You have to copy declaration
arrays at the individual element level. local variables
● Example: statement
for(int i = 0; i < 25; i++) }
second[i] = first[i]; ● A function definition starts with the type of the function.
● If the values of an array follow a pattern, we can use a ● If no value is returned, then the value type is void.
loop to assign values. For example, the following loop ● If the type is something other than void, then the value
assigns a value that is twice the index number to array is returned by the function will be converted, if
scores. necessary, to this type.
● Example: ● The name of the function is followed by a parenthesized
for(int i = 0; i < 25; i++) list of parameter declarations. It act as a placeholder for
scores[i] = i * 2; values that are passed when the function is invoked
(formal parameters). The function body is a block, or a
FUNCTION compound statement, and it too may contain
declarations.
FUNCTION ● Example:
double twice(double x){ /*function definition*/
● Used to implement this “top-down” method of return(2.0 * x);
programming (problem decomposition). }
● A section of a program which performs a specific task.
int all_add(int a, int b, int c){ /*function definition*/
● The task assigned to a function is performed return(a + b + c);
whenever C encounters the function name. }
● A function is actually a subprogram, that performs a task
within a program and is written in a form similar to C LOCAL VARIABLES TO A FUNCTION
main program.
1ST SEMESTER: FINALS EXAMINATION
CP1 – COMPUTER PROGRAMMING (COMP 002)
Geuel John D. Rivera | BSCS 1-5 | Prof. Arnie Fabregas
● Local variables - any variables declared in the body of
function.
● Global variables – declared external to the function.
Local variables…
● Are referred to as automatic variables or the keyword
auto.
● Can be referenced only by statements that are inside the
block in which the variables are declared.
● Not known outside their own code. A block of code is
begun and terminated when an opening and closing
curly brace ( { } ) is encountered.
● Exists only while the block code in which they are
declared is executing. They are created upon entry into
its block and destroyed upon exit.
GLOBAL VARIABLE TO A FUNCTION
● They are known throughout the entire program and
maybe used in any piece of code.
● They hold their values during the entire execution of the
program.
● They are created by declaring them outside of any
function. They maybe accessed by any expression
regardless of what function that expression is in.
● The storage for global variables is in fixed region of
memory set aside for this purpose by the compiler.
● Helpful when the same amount of data is used in many
functions in your program.
AVOIDING UNNECESSARY GLOBAL VARIABLES
1. They take up memory the entire time of your program is
executing not just when they are needed.
2. Relying to global variables instead of local variables. It
makes the function less general because it relies on a
variable outside of it.
3. Overuse of global variables that can lead to program
error because of unknown and unwanted side effects.
THE return STATEMENT
● May or may not include in an expression (void data type)
● Syntax:
return; // return(expression);
● Example:
float f(char a, char b, char c){
int i;
…
return i; /*the value will be converted to float*/
} followed by arguments enclosed in parentheses.
● There can be zero or more return statements in a
function. If there is no return statement, then control
variable is passed back to the calling environment when
the closing brace of the body is encountered (“falling off
the end”).
● Example (program segment):
double value(double x){
if (x >= 0.0)
return x;
else
return -x;
} environment.
FUNCTION PROTOTYPES
● Functions should be declared before they are used.
● ANSI C provides a new function declaration syntax
called functional prototype.
● It tells the compiler the number and the type of
arguments that are to be passed to the function and the
type of the value that is to be returned by the function.
● Syntax:
type function_name(parameter type list);
● Example:
double sqrt(double);
Tells the compiler that sqrt() is a function that takes a single
argument of type double and returns a double.
● Function prototype allows the compiler to check the
code more thoroughly.
● Also, values passed to function are properly coerced.
NOTE: In C++, function prototypes are required and the
use of void in the parameter type list in both function
prototypes and the function definition is optional.
● Example:
Void func(); [equivalent to void func(void);]
PARAMETER LISTS
● A function header identified the parameters which are to
be passed to the function.
● In the header and in the actual body of the function, the
parameters used are FORMAL parameters which are
replaced by the ACTUAL parameter when the function
is called.
● Since the FORMAL parameters are eventually replaced,
they are not program variable.
● In particular, you can assign to FORMAL parameters the
names of program variable which will eventually replace
them.
FUNCTION INVOCATION AND CALL BY VALUE
● A program consists of one or more function definitions,
including main(), which serves as the entry point for
program execution.
● When encountering a function name, program control
transfers to that function, known as invocation or
calling.
● Upon completing its tasks, control returns to the calling
environment for further execution.
● Functions are invoked by specifying their names
● Arguments provided during invocation should match in
number and type (or compatible type) with the
parameters defined in the function.
● Type compatibility is enforced by the compiler when
function prototypes are employed.
● Arguments are passed "call by value," implying that
each argument's value is locally used in place of the
corresponding formal parameter.
● Function calls can originate from either the main
program or within other functions, with the function
initiating the call termed the calling function or calling
● Value parameter – copy of a variable which is private to
the function. The function is given a copy of the actual
parameter to manipulate. However, the manipulation
does not affect any of the variables in the calling
1ST SEMESTER: FINALS EXAMINATION
CP1 – COMPUTER PROGRAMMING (COMP 002)
Geuel John D. Rivera | BSCS 1-5 | Prof. Arnie Fabregas

program.
● Example:
#include <stdio.h>

// Global declaration

int sum;
void func_sample(int y);

// Program entry point

void main (){

int = 5;
printf(“The value of n here is %d”, n);

func_sample(n); // Calling the function

prinf(“The value of n is %d”, n);

} //Program termination

// Process of the global function

func_sample(int y){
y *= 3;
printf(“The new value of y is %d”, y);
}

CALL BY REFERENCE/VARIABLE PARAMETERS

● Used to change the value of variable in the calling

environment.
● The use of addresses of variables as argument to
function can produce the effect of “call by reference”
● How it works: Pointers must be used in the parameter
list in the function definition. When the function is called,
address of the variables must be passed.
● In passing a variable parameter to a function, C does not
pass the actual value, instead, it passes a pointer to a
variable being passed, that is, we pass the address of
the memory location holding the value of the variable
being passed.
● & - used as address operator, meaning “the address of”
● * - indirection operator, meaning “content of address”