Basics of C

C Basics - C Programming Tutorial https://www3.ntu.edu.sg/home/ehchua/programming/cpp/c1_Basics.
html
yet another insignificant programming notes... | HOME
TABLE OF CONTENTS (HIDE)

1. Introduc�on to C
C Programming Language 2. Basic Syntaxes

2.1 Revision
2.2 Comments
Basics 2.3 Statements and Blocks

2.4 White Spaces and Forma�ng Source Codes
2.5 Preprocessor Direc�ves
3. Variables and Types
3.1 Variables
This chapter explains the features, technical details and syntaxes of the C programming language. I assume that you could write some
3.2 Iden�fiers
simple programs. Otherwise, read "Introduc�on to Programming in C for Novices and First-�me Programmers".
3.3 Variable Declara�on
3.4 Constants (const)
3.5 Expressions
1. Introduction to C 3.6 Assignment (=)
3.7 Fundamental Types
C Standards
3.8 Output via printf() Func�on
C is standardized as ISO/IEC 9899. 3.9 Input via scanf() Func�on
1. K&R C: Pre-standardized C, based on Brian Kernighan and Dennis Ritchie (K&R) "The C Programming Language" 1978 book. 3.10 Literals for Fundamental Types and String
2. C90 (ISO/IEC 9899:1990 "Programming Languages. C"). Also known as ANSI C 89. 4. Opera�ons
4.1 Arithme�c Operators
3. C99 (ISO/IEC 9899:1999 "Programming Languages. C")
4.2 Arithme�c Expressions
4. C11 (ISO/IEC 9899:2011 "Programming Languages. C") 4.3 Mixed-Type Opera�ons
4.4 Overflow/UnderFlow
C Features 4.5 Compound Assignment Operators
[TODO] 4.6 Increment/Decrement Operators
4.7 Implicit Type-Conversion vs. Explicit Type-Cas�ng
C Strength and Pitfall 4.8 Rela�onal and Logical Operators
5. Flow Control
[TODO]
5.1 Sequen�al Flow Control
5.2 Condi�onal (Decision) Flow Control
5.3 Loop Flow Control
2. Basic Syntaxes 5.4 Interrup�ng Loop Flow - "break
5.5 Termina�ng Program
2.1 Revision 5.6 Nested Loops
5.7 Some Issues in Flow Control
Below is a simple C program that illustrates the important programming constructs (sequen�al flow, while-loop, and if-else) and
5.8 Exercises
input/output. Read "Introduc�on to Programming in C for Novices and First-�me Programmers" if you need help in understanding
6. Wri�ng Correct and Good Programs
this program.
7. Arrays
7.1 Array Declara�on and Usage
7.2 Array and Loop
7.3 Mul�-Dimensional Array
8. Func�ons
8.1 Why Func�ons?
8.2 Using Func�ons
8.3 Func�ons and Arrays
8.4 Pass-by-Value vs. Pass-by-Reference
8.5 "const" Func�on Parameters
8.6 Mathema�cal Func�ons (Header
8.7 Genera�ng Random Numbers
8.8 Exercises
9. Characters and Strings
9.1 Character Type and Conversion in
9.2 String/Number Conversion in <stdlib.h>
9.3 String Manipula�on in <string.h>
9.4 char/string IO in <stdio.h> Header
10. File Input/Output
10.1 File IO in <stdio.h> Header
10.2 Sequen�al-Access File
10.3 Direct-Access File IO
11. Pointers and Dynamic Alloca�on
11.1 Array and Pointer
11.2 String as char pointer
12. struct, union and enum
13. Miscellaneous
13.1 Bit Opera�ons
13.2 C Library Headers
13.3 Keywords
1 /*
1 of 40 22/03/2020, 19:54
C Basics - C Programming Tutorial https://www3.ntu.edu.sg/home/ehchua/programming/cpp/c1_Basics.html
2 * Sum the odd and even numbers, respectively, from 1 to a given upperbound.
3 * Also compute the absolute difference.
4 * (SumOddEven.c)
5 */
6 #include <stdio.h> // Needed to use IO functions
7
8 int main() {
9 int sumOdd = 0; // For accumulating odd numbers, init to 0
10 int sumEven = 0; // For accumulating even numbers, init to 0
11 int upperbound; // Sum from 1 to this upperbound
12 int absDiff; // The absolute difference between the two sums
13
14 // Prompt user for an upperbound
15 printf("Enter the upperbound: ");
16 scanf("%d", &upperbound); // Use %d to read an int
17
18 // Use a while-loop to repeatedly add 1, 2, 3,..., to the upperbound
19 int number = 1;
20 while (number <= upperbound) {
21 if (number % 2 == 0) { // Even number
22 sumEven += number; // Add number into sumEven
23 } else { // Odd number
24 sumOdd += number; // Add number into sumOdd
25 }
26 ++number; // increment number by 1
27 }
28
29 // Compute the absolute difference between the two sums
30 if (sumOdd > sumEven) {
31 absDiff = sumOdd - sumEven;
32 } else {
33 absDiff = sumEven - sumOdd;
34 }
35
36 // Print the results
37 printf("The sum of odd numbers is %d.\n", sumOdd);
38 printf("The sum of even numbers is %d.\n", sumEven);
39 printf("The absolute difference is %d.\n", absDiff);
40
41 return 0;
42 }
Enter the upperbound: 1000

The sum of odd numbers is 250000.
The sum of even numbers is 250500.
The absolute difference is 500.
2.2 Comments
Comments are used to document and explain your codes and program logic. Comments are not programming statements and are ignored by the compiler, but they VERY
IMPORTANT for providing documenta�on and explana�on for others to understand your program (and also for yourself three days later).
There are two kinds of comments in C:

1. Mul�-line Comment: begins with a /* and ends with a */, and can span several lines.
2. End-of-line Comment: begins with // and lasts �ll the end of the current line.
You should use comments liberally to explain and document your codes. During program development, instead of dele�ng a chunk of statements permanently, you could
comment-out these statements so that you could get them back later, if needed.
2.3 Statements and Blocks

Statement : A programming statement is the smallest independent unit in a program, just like a sentence in the English language. It performs a piece of programming ac�on. A
programming statement must be terminated by a semi-colon (;), just like an English sentence ends with a period. (Why not ends with a period like an english sentence? This is
because period crashes with decimal point - it is hard for the dumb computer to differen�ate between period and decimal point!)
For examples,
// Each of the following lines is a programming statement, which ends with a semi-colon (;)
int number1 = 10;
int number2, number3 = 99;
int product;
product = number1 * number2 * number3;
printf("Hello\n");
Block : A block (or a compound statement) is a group of statements surrounded by braces { }. All the statements inside the block is treated as one unit. Blocks are used as the
body in constructs like func�on, if-else and loop, which may contain mul�ple statements but are treated as one unit. There is no need to put a semi-colon a�er the closing brace to
end a complex statement. Empty block (without any statement) is permi�ed. For examples,
// Each of the followings is a "complex" statement comprising one or more blocks of statements.
// No terminating semi-colon needed after the closing brace to end the "complex" statement.
// Take note that a "complex" statement is usually written over a few lines for readability.
if (mark >= 50) {
printf("PASS\n");
printf("Well Done!\n");
printf("Keep it Up!\n");
2 of 40 22/03/2020, 19:54
if (number == 88) {
printf("Got it\n");
} else {
printf("Try Again\n");
}
i = 1;
while (i < 8) {
printf("%d\n", i);
++i;
}
int main() {
...statements...
}
2.4 White Spaces and Formatting Source Codes

White Spaces : Blank, tab and new-line are collec�vely called white spaces. C ignores extra white spaces. That is, mul�ple con�guous white spaces are treated as a single white
space.
You need to use a white space to separate two keywords or tokens, e.g.,
int sum=0; // Need a white space between int and sum

double average; // Need a white space between double and average
average=sum/100.0;
Addi�onal white spaces and extra lines are, however, ignored, e.g.,
// same as above
int sum
= 0 ;
double average ;
average = sum / 100.0;
Formatting Source Codes : As men�oned, extra white spaces are ignored and have no computa�onal significance. However, proper indenta�on (with tabs and blanks) and
extra empty lines greatly improves the readability of the program, which is extremely important for others (and yourself three days later) to understand your programs. For
example, the following hello-world works, but can you understand the program?
#include <stdio.h>
int main(){printf("Hello, world!\n");return 0;}
Braces : Place the beginning brace at the end of the line, and align the ending brace with the start of the statement.
Indentation : Indent the body of a block by an extra 3 (or 4 spaces), according to its level.
For example,
/*
* Recommended Programming style.
*/
#include <stdio.h>
// blank line to separate sections of codes
int main() { // Place the beginning brace at the end of the current line
// Indent the body by an extra 3 or 4 spaces for each level
int mark = 70;

if (mark >= 50) { // in level-1 block, indent once
printf("You Pass!\n"); // in level-2 block, indent twice
} else {
printf("You Fail!\n");
}
return 0;
} // ending brace aligned with the start of the statement
Most IDEs (such as CodeBlocks, Eclipse and NetBeans) have a command to re-format your source code automa�cally.
Note: Tradi�onal C-style forma�ng places the beginning and ending braces on the same column. For example,
/*
* Traditional C-style.
*/
#include <stdio.h>
int main()
{
int mark = 70;
if (mark >= 50) // in level-1 block, indent once
{
printf("You Pass!\n"); // in level-2 block, indent twice
}
else
{
printf("You Fail!\n");
}
return 0;
3 of 40 22/03/2020, 19:54
2.5 Preprocessor Directives

C source code is preprocessed before it is compiled into object code (as illustrated).
A preprocessor direc�ve, which begins with a # sign (such as #include, #define), tells the preprocessor to perform a certain ac�on (such as including a header file, or
performing text replacement), before compiling the source code into object code. Preprocessor direc�ves are not programming statements, and therefore should NOT be
terminated with a semi-colon. For example,
#include <stdio.h> // To include the IO library header

#include <math.h> // To include the Math library header
#define PI 3.14159265 // To substitute the term PI with 3.14159265 in this file
// DO NOT terminate preprocessor directive with a semi-colon
In almost all of the C programs, we use #include <stdio.h> to include the input/output stream library header into our program, so as to use the IO library func�on to carry
out input/output opera�ons (such as printf() and scanf()).
More on preprocessor direc�ves later.
3. Variables and Types
3.1 Variables
Computer programs manipulate (or process) data. A variable is used to store a piece of data for processing. It is called variable because you can change the value stored.
More precisely, a variable is a named storage loca�on, that stores a value of a par�cular data type. In other words, a variable has a name, a type and stores a value.
A variable has a name (or iden�fier), e.g., radius, area, age, height. The name is needed to uniquely iden�fy each variable, so as to assign a value to the variable (e.g.,
radius=1.2), and retrieve the value stored (e.g., area = radius*radius*3.1416).
A variable has a type. Examples of type are,
int: for integers (whole numbers) such as 123 and -456;
double: for floa�ng-point or real numbers such as 3.1416, -55.66, having a decimal point and frac�onal part.
A variable can store a value of that par�cular type. It is important to take note that a variable in most programming languages is associated with a type, and can only store
value of the par�cular type. For example, a int variable can store an integer value such as 123, but NOT real number such as 12.34, nor texts such as "Hello".
The concept of type was introduced into the early programming languages to simplify interpreta�on of data made up of 0s and 1s. The type determines the size and layout of
the data, the range of its values, and the set of opera�ons that can be applied.
The following diagram illustrates two types of variables: int and double. An int variable stores an integer (whole number). A double variable stores a real number.
3.2 Identifiers
An iden�fier is needed to name a variable (or any other en�ty such as a func�on or a class). C imposes the following rules on iden�fiers:
An iden�fier is a sequence of characters, of up to a certain length (compiler-dependent, typically 255 characters), comprising uppercase and lowercase le�ers (a-z, A-Z),
4 of 40 22/03/2020, 19:54
digits (0-9), and underscore "_".

White space (blank, tab, new-line) and other special characters (such as +, -, *, /, @, &, commas, etc.) are not allowed.
An iden�fier must begin with a le�er or underscore. It cannot begin with a digit. Iden�fiers beginning with an underscore are typically reserved for system use.
An iden�fier cannot be a reserved keyword or a reserved literal (e.g.,int, double, if, else, for).
Iden�fiers are case-sensi�ve. A rose is NOT a Rose, and is NOT a ROSE.
Caution : Programmers don't use blank character in names. It is either not supported, or will pose you more challenges.
Variable Naming Convention

A variable name is a noun, or a noun phrase made up of several words. The first word is in lowercase, while the remaining words are ini�al-capitalized, with no spaces between
words. For example, thefontSize, roomNumber, xMax, yMin, xTopLeft and thisIsAVeryLongVariableName. This conven�on is also known as camel-case.
Recommendations
1. It is important to choose a name that is self-descrip�ve and closely reflects the meaning of the variable, e.g., numberOfStudents or numStudents.
2. Do not use meaningless names like a, b, c, d, i, j, k, i1, j99.
3. Avoid single-alphabet names, which is easier to type but o�en meaningless, unless they are common names like x, y, z for coordinates, i for index.
4. It is perfectly okay to use long names of says 30 characters to make sure that the name accurately reflects its meaning!
5. Use singular and plural nouns prudently to differen�ate between singular and plural variables. For example, you may use the variable row to refer to a single row number
and the variable rows to refer to many rows (such as an array of rows - to be discussed later).
3.3 Variable Declaration

To use a variable in your program, you need to first "introduce" it by declaring its name and type, in one of the following syntaxes:
Syntax Example
// Declare a variable of a specified type

type identifier; int option;
// Declare multiple variables of the same type, separated by commas
type identifier-1, identifier-2, ..., identifier-n; double sum, difference, product, quotient;
// Declare a variable and assign an initial value
type identifier = value; int magicNumber = 88;
// Declare multiple variables with initial values
type identifier-1 = value-1, ..., identifier-n = value-n; double sum = 0.0, product = 1.0;
Example,
int mark1; // Declare an int variable called mark1

mark1 = 76; // Use mark1
int mark2; // Declare int variable mark2
mark2 = mark1 + 10; // Use mark2 and mark1
double average; // Declare double variable average
average = (mark1 + mark2) / 2.0; // Use average, mark1 and mark2
int mark1; // Error: Declare twice
mark2 = "Hello"; // Error: Assign value of a different type
Take note that:

In C, you need to declare the name of a variable before it can be used.
C is a "strongly-type" language. A variable takes on a type. Once the type of a variable is declared, it can only store a value belonging to this par�cular type. For example, an
int variable can hold only integer such as 123, and NOT floa�ng-point number such as -2.17 or text string such as "Hello". The concept of type was introduced into the
early programming languages to simplify interpreta�on of data made up of 0s and 1s. Knowing the type of a piece of data greatly simplifies its interpreta�on and processing.
Each variable can only be declared once.
In C, you can declare a variable anywhere inside the program, as long as it is declared before used. (In C prior to C99, all the variables must be declared at the beginning of
func�ons.) It is recommended that your declare a variable just before it is first used.
The type of a variable cannot be changed inside the program.
CAUTION: Uninitialized Variables

When a variable is declared, it contains garbage un�l you assign an ini�al value. It is important to take note that C does not issue any warning/error if you use a variable before
ini�alize it - which certainly leads to some unexpected results. For example,
1 #include <stdio.h>
2
3 int main() {
4 int number; // Declared but not initialized
5 printf("%d\n", number); // Used before initialized
6 // No warning/error, BUT unexpected result
7 return 0;
8 }
3.4 Constants (const)

Constants are non-modifiable variables, declared with keyword const. Their values cannot be changed during program execu�on. Also, const must be ini�alized during
declara�on. For examples:
const double PI = 3.1415926; // Need to initialize
Constant Naming Convention: Use uppercase words, joined with underscore. For example, MIN_VALUE, MAX_SIZE.
5 of 40 22/03/2020, 19:54
3.5 Expressions
An expression is a combina�on of operators (such as addi�on '+', subtrac�on '-', mul�plica�on '*', division '/') and operands (variables or literal values), that can be
evaluated to yield a single value of a certain type. For example,
1 + 2 * 3 // give int 7
int sum, number;

sum + number // evaluated to an int value
double principal, interestRate;

principal * (1 + interestRate) // evaluated to a double value
3.6 Assignment (=)

An assignment statement:
1. assigns a literal value (of the RHS) to a variable (of the LHS); or
2. evaluates an expression (of the RHS) and assign the resultant value to a variable (of the LHS).
The RHS shall be a value; and the LHS shall be a variable (or memory address).
The syntax for assignment statement is:
Syntax Example
// Assign the literal value (of the RHS) to the variable (of the LHS)
variable = literal-value; number = 88;
// Evaluate the expression (RHS) and assign the result to the variable (LHS)
variable = expression; sum = sum + number;
The assignment statement should be interpreted this way: The expression on the right-hand-side (RHS) is first evaluated to produce a resultant value (called rvalue or right-value).
The rvalue is then assigned to the variable on the le�-hand-side (LHS) (or lvalue, which is a loca�on that can hold a rvalue). Take note that you have to first evaluate the RHS, before
assigning the resultant value to the LHS. For examples,
number = 8; // Assign literal value of 8 to the variable number

number = number + 1; // Evaluate the expression of number + 1,
// and assign the resultant value back to the variable number
The symbol "=" is known as the assignment operator. The meaning of "=" in programming is different from Mathema�cs. It denotes assignment instead of equality. The RHS is a
literal value; or an expression that evaluates to a value; while the LHS must be a variable. Note that x = x + 1 is valid (and o�en used) in programming. It evaluates x + 1 and
assign the resultant value to the variable x. x = x + 1 illegal in Mathema�cs. While x + y = 1 is allowed in Mathema�cs, it is invalid in programming (because the LHS of an
assignment statement must be a variable). Some programming languages use symbol ":=", "←", "->", or "→" as the assignment operator to avoid confusion with equality.
3.7 Fundamental Types

Integers: C supports these integer types: char, short, int, long, long long (in C11) in a non-decreasing order of size. The actual size depends on the implementa�on.
The integers (except char) are signed number (which can hold zero, posi�ve and nega�ve numbers). You could use the keyword unsigned
[char|short|int|long|long long] to declare an unsigned integers (which can hold zero and posi�ve numbers). There are a total 10 types of integers -
signed|unsigned combined with char|short|int|long|long long.
Characters: Characters (e.g., 'a', 'Z', '0', '9') are encoded in ASCII into integers, and kept in type char. For example, character '0' is 48 (decimal) or 30H (hexadecimal);
character 'A' is 65 (decimal) or 41H (hexadecimal); character 'a' is 97 (decimal) or 61H (hexadecimal). Take note that the type char can be interpreted as character in ASCII
code, or an 8-bit integer. Unlike int or long, which is signed, char could be signed or unsigned, depending on the implementa�on. You can use signed char or
unsigned char to explicitly declare signed or unsigned char.
Floating-point Numbers: There are 3 floa�ng point types: float, double and long double, for single, double and long double precision floa�ng point numbers.
float and double are represented as specified by IEEE 754 standard. A float can represent a number between ±1.40239846×10^-45 and ±3.40282347×10^38,
approximated. A double can represented a number between ±4.94065645841246544×10^-324 and ±1.79769313486231570×10^308, approximated. Take note
that not all real numbers can be represented by float and double, because there are infinite real numbers. Most of the values are approximated.
The table below shows the typical size, minimum, maximum for the primi�ve types. Again, take note that the sizes are implementa�on dependent.
Bytes Minimum Maximum

Category Type Description
(Typical) (Typical) (Typical)
Integers int Signed integer (of at least 16 bits) 4 (2) -2147483648 2147483647
(or signed int)
unsigned int Unsigned integer (of at least 16 bits) 4 (2) 0 4294967295
char Character 1
(can be either signed or unsigned depends on
implementa�on)
signed char Character or signed �ny integer 1 -128 127
(guarantee to be signed)
unsigned char Character or unsigned �ny integer 1 0 255
(guarantee to be unsigned)
short Short signed integer (of at least 16 bits) 2 -32768 32767
(or short int)
(or signed short)
(or signed short int)
6 of 40 22/03/2020, 19:54
Bytes Minimum Maximum

Category Type Description
(Typical) (Typical) (Typical)
unsigned short Unsigned short integer (of at least 16 bits) 2 0 65535
(or unsigned shot int)
long Long signed integer (of at least 32 bits) 4 (8) -2147483648 2147483647
(or long int)
(or signed long)
(or signed long int)
unsigned long Unsigned long integer (of at least 32 bits) 4 (8) 0 same as above
(or unsigned long int)
long long Very long signed integer (of at least 64 bits) 8 -263 263-1
(or long long int)
(or signed long long)
(or signed long long int)
unsigned long long Unsigned very long integer (of at least 64 bits) 8 0 264-1
(or unsigned long long
int)
Real float Floa�ng-point number, ≈7 digits 4 3.4e38 3.4e-38
Numbers (IEEE 754 single-precision floa�ng point format)
double Double precision floa�ng-point number, ≈15 digits 8 1.7e308 1.7e-308
(IEEE 754 double-precision floa�ng point format)
long double Long double precision floa�ng-point number, ≈19 digits 12 (8)
(IEEE 754 quadruple-precision floa�ng point format)
Wide wchar_t Wide (double-byte) character 2 (4)
Characters
In addi�on, many C library func�ons use a type called size_t, which is equivalent (typedef) to a unsigned int, meant for coun�ng, size or length, with 0 and posi�ve
integers.
*The sizeof Operator

C provides an unary sizeof operator to get the size of the operand (in bytes). The following program uses sizeof operator to print the size of the fundamental types.
1 /*
2 * Print Size of Fundamental Types (SizeofTypes.cpp).
3 */
5
6 int main() {
7 printf("sizeof(char) is %d bytes.\n", sizeof(char));
8 printf("sizeof(short) is %d bytes.\n", sizeof(short));
9 printf("sizeof(int) is %d bytes.\n", sizeof(int));
10 printf("sizeof(long) is %d bytes.\n", sizeof(long));
11 printf("sizeof(long long) is %d bytes.\n", sizeof(long long));
12 printf("sizeof(float) is %d bytes.\n", sizeof(float));
13 printf("sizeof(double) is %d bytes.\n", sizeof(double));
14 printf("sizeof(long double) is %d bytes.\n", sizeof(long double));
15 return 0;
16 }
sizeof(char) is 1 bytes.
sizeof(short) is 2 bytes.
sizeof(int) is 4 bytes.
sizeof(long) is 4 bytes.
sizeof(long long) is 8 bytes.
sizeof(float) is 4 bytes.
sizeof(double) is 8 bytes.
sizeof(long double) is 12 bytes.
The results may vary among different systems.
*Header <limits.h>
The limits.h header contains informa�on about limits of integer type. For example,
1 /* Test integer limits in <limits.h> header */

3 #include <limits.h> // integer limits
4
5 int main() {
6 printf("int max = %d\n", INT_MAX);
7 printf("int min = %d\n", INT_MIN);
8 printf("unsigned int max = %u\n", UINT_MAX);
9
10 printf("long max = %ld\n", LONG_MAX);
11 printf("long min = %ld\n", LONG_MIN);
12 printf("unsigned long max = %lu\n", ULONG_MAX);
13
14 printf("long long max = %lld\n", LLONG_MAX);
15 printf("long long min = %lld\n", LLONG_MIN);
16 printf("unsigned long long max = %llu\n", ULLONG_MAX);
7 of 40 22/03/2020, 19:54
17
18 printf("Bits in char = %d\n", CHAR_BIT);
19 printf("char max = %d\n", CHAR_MAX);
20 printf("char min = %d\n", CHAR_MIN);
21 printf("signed char max = %d\n", SCHAR_MAX);
22 printf("signed char min = %d\n", SCHAR_MIN);
23 printf("unsigned char max = %u\n", UCHAR_MAX);
24 return 0;
25 }
int max = 2147483647

int min = -2147483648
unsigned int max = 4294967295
long max = 2147483647
long min = -2147483648
unsigned long max = 4294967295
long long max = 9223372036854775807
long long min = -9223372036854775808
unsigned long long max = 18446744073709551615
Bits in char = 8
char max = 127
char min = -128
signed char max = 127
signed char min = -128
unsigned char max = 255
Again, the outputs depend on the system.
The minimum of unsigned integer is always 0. The other constants are SHRT_MAX, SHRT_MIN, USHRT_MAX, LONG_MIN, LONG_MAX, ULONG_MAX. Try inspec�ng this header
(search for limits.h under your compiler).
*Header <float.h>
Similarly, the float.h header contain informa�on on limits for floa�ng point numbers, such as minimum number of significant digits (FLT_DIG, DBL_DIG, LDBL_DIG for
float, double and long double), number of bits for man�ssa (FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG), maximum and minimum exponent values, etc. Try
inspec�ng this header (search for cfloat under your compiler).
Choosing Types
As a programmer, you need to choose variables and decide on the type of the variables to be used in your programs. Most of the �mes, the decision is intui�ve. For example, use
an integer type for coun�ng and whole number; a floa�ng-point type for number with frac�onal part, char for a single character, and boolean for binary outcome.
Rule of Thumb
Use int for integer and double for floa�ng point numbers. Use byte, short, long and float only if you have a good reason to choose that specific precision.
Use int (or unsigned int) for coun�ng and indexing, NOT floa�ng-point type (float or double). This is because integer type are precise and more efficient in
opera�ons.
Use an integer type if possible. Use a floa�ng-point type only if the number contains a frac�onal part.
Read my ar�cle on "Data Representa�on" if you wish to understand how the numbers and characters are represented inside the computer memory. In brief, It is important to take
note that char '1' is different from int 1, short 1, float 1.0, double 1.0, and String "1". They are represented differently in the computer memory, with
different precision and interpreta�on. For example, short 1 is "00000000 00000001", int 1 is "00000000 00000000 00000000 00000001", long long 1 is
"00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001", float 1.0 is "0 01111111 0000000 00000000
00000000", double 1.0 is "0 01111111111 0000 00000000 00000000 00000000 00000000 00000000 00000000", char '1' is "00110001".
There is a subtle difference between int 0 and double 0.0.
Furthermore, you MUST know the type of a value before you can interpret a value. For example, this value "00000000 00000000 00000000 00000001" cannot be
interpreted unless you know the type.
*The typedef Statement

Typing "unsigned int" many �me can get annoying. The typedef statement can be used to create a new name for an exis�ng type. For example, you can create a new type
called "uint" for "unsigned int" as follow. You should place the typedef immediately a�er #include. Use typedef with care because it makes the program hard to
read and understand.
typedef unsigned int uint;
Many C compilers define a type called size_t, which is a typedef of unsigned int.
typedef unsigned int size_t;
3.8 Output via printf() Function

C programs use func�on printf() of library stdio to print output to the console. You need to issue a so-called preprocessor direc�ve "#include <stdio.h>" to use
printf().
To print a string literal such as "Hello, world", simply place it inside the parentheses, as follow:
printf(aStringLiteral);
For example,
printf("Hello, world\n");
Hello, world
_
8 of 40 22/03/2020, 19:54
The \n represents the newline character. Prin�ng a newline advances the cursor (denoted by _ in the above example) to the beginning of next line. printf(), by default, places
the cursor a�er the printed string, and does not advance the cursor to the next line. For example,
printf("Hello");
printf(", ");
printf("world!");
printf("\n");
printf("Hello\nworld\nagain\n");
Hello, world!
Hello
world
again
_
Formatted Output via printf()

The "f" in printf() stands for "forma�ed" prin�ng. To do forma�ed prin�ng, you need to use the following syntax:
printf(formattingString, variable1, variable2, ...)
The forma�ngString is a string composing of normal texts and conversion specifiers. Normal texts will be printed as they are. A conversion specifier begins with a percent sign (%),
followed by a code to specify the type of variable and format of the output (such as the field width and number of decimal places). For example, %d denotes an int; %3d for an
int with field-width of 3. The conversion specifiers are used as placeholders, which will be subs�tuted by the variables given a�er the forma�ng string in a sequen�al manner. For
example,
1 /*
2 * Test formatted printing for int (TestPrintfInt.c)
3 */
5
6 int main() {
7 int number1 = 12345, number2 = 678;
8 printf("Hello, number1 is %d.\n", number1); // 1 format specifier
9 printf("number1=%d, number2=%d.\n", number1, number2); // 2 format specifiers
10 printf("number1=%8d, number2=%5d.\n", number1, number2); // Set field-widths
11 printf("number1=%08d, number2=%05d.\n", number1, number2); // Pad with zero
12 printf("number1=%-8d, number2=%-5d.\n", number1, number2); // Left-align
13 return 0;
14 }
Hello, number1 is 12345.

number1=12345, number2=678.
number1= 12345, number2= 678.
number1=00012345, number2=00678.
number1=12345 , number2=678 .
Type Conversion Code

The commonly-used type conversion codes are:
Type Type Conversion Code Type & Format

Integers %d (or %i) (signed) int
%u unsigned int
%o int in octal
%x, %X int in hexadecimal (%X uses uppercase A-F)
%hd, %hu short, unsigned short
%ld, %lu long, unsigned long
%lld, %llu long long, unsigned long long
Floa�ng-point %f float in fixed nota�on
%e, %E float in scien�fic nota�on
%g, %G float in fixed/scien�fic nota�on depending on its value
%f, %lf (printf), %lf (scanf) double: Use %f or %lf in printf(), but %lf in scanf().
%Lf, %Le, %LE, %Lg, %LG long double
Character %c char
String %s string
Notes:
For double, you must use %lf (for long float) in scanf() (or %le, %lE, %lg, %lG), but you can use either %f or %lf in printf() (or %e, %E, %g, %G, %le, %lE, %lg,
%lG).
Use %% to print a % in the forma�ng string.
For example,
int anInt = 12345;

float aFloat = 55.6677;
double aDouble = 11.2233;
char aChar = 'a';
char aStr[] = "Hello";
9 of 40 22/03/2020, 19:54
printf("The int is %d.\n", anInt);

//The int is 12345.
printf("The float is %f.\n", aFloat);
//The float is 55.667702.
printf("The double is %lf.\n", aDouble);
//The double is 11.223300.
printf("The char is %c.\n", aChar);
//The char is a.
printf("The string is %s.\n", aStr);
//The string is Hello.
printf("The int (in hex) is %x.\n", anInt);

//The int (in hex) is 3039.
printf("The double (in scientific) is %le.\n", aDouble);
//The double (in scientific) is 1.122330e+01.
printf("The float (in scientific) is %E.\n", aFloat);
//The float (in scientific) is 5.566770E+01.
Using the wrong type conversion code usually produces garbage.
Field Width
You can op�onally specify a field-width before the type conversion code, e.g., %3d, %6f, %20s. If the value to be forma�ed is shorter than the field width, it will be padded with
spaces (by default). Otherwise, the field-width will be ignored. For example,
int number = 123456;

printf("number=%d.\n", number);
// number=123456.
printf("number=%8d.\n", number);
// number= 123456.
printf("number=%3d.\n", number); // Field-width too short. Ignored.
// number=123456.
Precision (Decimal Places) for Floating-point Numbers

For floa�ng-point numbers, you can op�onally specify the number of decimal places to be printed, e.g., %6.2f, %8.3f. For example,
double value = 123.14159265;

printf("value=%lf;\n", value);
//value=123.141593;
printf("value=%6.2lf;\n", value);
//value=123.14;
printf("value=%9.4lf;\n", value);
//value= 123.1416;
printf("value=%3.2lf;\n", value); // Field-width too short. Ignored.
//value=123.14;
Alignment
The output are right-aligned by default. You could include a "-" flag (before the field width) to ask for le�-aligned. For example,
int i1 = 12345, i2 = 678;

printf("Hello, first int is %d, second int is %5d.\n", i1, i2);
//Hello, first int is 12345, second int is 678.
printf("Hello, first int is %d, second int is %-5d.\n", i1, i2);
//Hello, first int is 12345, second int is 678 .
char msg[] = "Hello";

printf("xx%20sxx\n", msg);
//xx Helloxx
printf("xx%-20sxx\n", msg);
//xxHello xx
Others
+ (plus sign): display plus or minus sign preceding the number.
# or 0: Pad with leading # or 0.
C11's printf_s()/scanf_s()
C11 introduces more secure version of printf()/scanf() called printf_s()/scanf_s() to deal with mismatched conversion specifiers. Microso� Visual C
implemented its own versions of printf_s()/scanf_s() before C11, and issues a deprecated warning for using printf()/scanf().
3.9 Input via scanf() Function

In C, you can use scanf() func�on of <stdio.h> to read inputs from keyboard. scanf() uses the type-conversion code like printf(). For example,
1 /*
2 * TestScanf.c
3 */
5
6 int main() {
7 int anInt;
8 float aFloat;
9 double aDouble;
10
10 of 40 22/03/2020, 19:54
11 printf("Enter an int: "); // Prompting message

12 scanf("%d", &anInt); // Read an int from keyboard and assign to variable anInt.
13 printf("The value entered is %d.\n", anInt);
14
15 printf("Enter a floating-point number: "); // Prompting message
16 scanf("%f", &aFloat); // Read a double from keyboard and assign to variable aFloat.
17 printf("The value entered is %f.\n", aFloat);
18
19 printf("Enter a floating-point number: "); // Prompting message
20 scanf("%lf", &aDouble); // Read a double from keyboard and assign to variable aDouble.
21 printf("The value entered is %lf.\n", aDouble);
22
23 return 0;
24 }
Notes:
To place the input into a variable in scanf(), you need to prefix the variable name by an ampersand sign (&). The ampersand (&) is called address-of operator, which will be
explained later. However, it is important to stress that missing ampersand (&) is a common error.
For double, you must use type conversion code %lf for scanf(). You could use %f or %lf for printf().
Return-Value for scanf()

The scanf() returns an int indica�ng the number of values read.
For example,
int number1 = 55, number2 = 66;

int rcode = scanf("%d", &number);
printf("return code is %d\n", rcode);
printf("number1 is %d\n", number1);
The scanf() returns 1 if user enters an integer which is read into the variable number. It returns 0 if user enters a non-integer (such as "hello"), and variable number is not
assigned.
int number1 = 55, number2 = 66;

int rcode = scanf("%d%d", &number1, &number2);
printf("return code is %d\n", rcode);
The scanf() returns 2 if user enters two integers that are read into number1 and number2. It returns 1 if user enters an integer followed by a non-integer, and number2 will
not be affected. It returns 0 if user enters a non-integer, and both number1 and number2 will not be affected.
Checking the return code of scanf() is recommended for secure coding.
3.10 Literals for Fundamental Types and String

A literal is a specific constant value, such as 123, -456, 3.14, 'a', "Hello", that can be assigned directly to a variable; or used as part of an expression. They are called literals
because they literally and explicitly iden�fy their values.
Integer Literals
A whole number, such as 123 and -456, is treated as an int, by default. For example,
int number = -123;

int sum = 4567;
int bigSum = 8234567890; // ERROR: this value is outside the range of int
An int literal may precede with a plus (+) or minus (-) sign, followed by digits. No commas or special symbols (e.g., $ or space) is allowed (e.g., 1,234 and $123 are invalid). No
preceding 0 is allowed too (e.g., 007 is invalid).
Besides the default base 10 integers, you can use a prefix '0' (zero) to denote a value in octal, prefix '0x' for a value in hexadecimal, and prefix '0b' for binary value (in some
compilers), e.g.,
int number1 = 1234; // Decimal

int number2 = 01234; // Octal 1234, Decimal 2322
int number3 = 0x1abc; // hexadecimal 1ABC, decimal 15274
int number4 = 0b10001001; // binary (may not work in some compilers)
A long literal is iden�fied by a suffix 'L' or 'l' (avoid lowercase, which can be confused with the number one). A long long int is iden�fied by a suffix 'LL'. You can also
use suffix 'U' for unsigned int, 'UL' for unsigned long, and 'ULL' for unsigned long long int. For example,
long number = 12345678L; // Suffix 'L' for long

long sum = 123; // int 123 auto-casts to long 123L
long long bigNumber = 987654321LL; // Need suffix 'LL' for long long int
No suffix is needed for short literals. But you can only use integer values in the permi�ed range. For example,
short smallNumber = 1234567890; // ERROR: this value is outside the range of short.
short midSizeNumber = -12345;
Floating-point Literals
A number with a decimal point, such as 55.66 and -33.44, is treated as a double, by default. You can also express them in scien�fic nota�on, e.g., 1.2e3, -5.5E-6, where
e or E denotes the exponent in power of 10. You could precede the frac�onal part or exponent with a plus (+) or minus (-) sign. Exponent shall be an integer. There should be no
space or other characters (e.g., space) in the number.
11 of 40 22/03/2020, 19:54
You MUST use a suffix of 'f' or 'F' for float literals, e.g., -1.2345F. For example,
float average = 55.66; // Error! RHS is a double. Need suffix 'f' for float.
float average = 55.66f;
Use suffix 'L' (or 'l') for long double.
Character Literals and Escape Sequences

A printable char literal is wri�en by enclosing the character with a pair of single quotes, e.g., 'z', '$', and '9'. In C, characters are represented using 8-bit ASCII code, and can
be treated as a 8-bit signed integers in arithme�c opera�ons. In other words, char and 8-bit signed integer are interchangeable. You can also assign an integer in the range of
[-128, 127] to a char variable; and [0, 255] to an unsigned char.
You can find the ASCII code table HERE.
For example,
char letter = 'a'; // Same as 97

char anotherLetter = 98; // Same as the letter 'b'
printf("%c\n", letter); // 'a' printed
printf("%c\n", anotherLetter); // 'b' printed instead of the number
anotherLetter += 2; // 100 or 'd'
printf("%c\n", anotherLetter); // 'd' printed
printf("%d\n", anotherLetter); // 100 printed
Non-printable and control characters can be represented by so-called escape sequences, which begins with a back-slash (\) followed by a code. The commonly-used escape
sequences are:
Escape Hex
Description
Sequence (Decimal)
\n New-line (or Line-feed) 0AH (10D)
\r Carriage-return 0DH (13D)
\t Tab 09H (9D)
\" Double-quote (needed to include " in double-quoted 22H (34D)
string)
\' Single-quote 27H (39D)
\\ Back-slash (to resolve ambiguity) 5CH (92D)
Notes:
New-line (0AH) and carriage return (0dH), represented by \n, and \r respec�vely, are used as line delimiter (or end-of-line, or EOL). However, take note that UNIX/Linux/Mac
use \n as EOL, Windows use \r\n.
Horizontal Tab (09H) is represented as \t.
To resolve ambiguity, characters back-slash (\), single-quote (') and double-quote (") are represented using escape sequences \\, \' and \", respec�vely. This is because a
single back-slash begins an escape sequence, while single-quotes and double-quotes are used to enclose character and string.
Other less commonly-used escape sequences are: \? or ?, \a for alert or bell, \b for backspace, \f for form-feed, \v for ver�cal tab. These may not be supported in some
consoles.
The <ctype.h> Header

The ctype.h header provides func�ons such as isalpha(), isdigit(), isspace(), ispunct(), isalnum(), isupper(), islower() to determine the type of
character; and toupper(), tolower() for case conversion.
String Literals
A String literal is composed of zero of more characters surrounded by a pair of double quotes, e.g., "Hello, world!", "The sum is ", "".
String literals may contains escape sequences. Inside a String, you need to use \" for double-quote to dis�nguish it from the ending double-quote, e.g. "\"quoted\"". Single
quote inside a String does not require escape sequence. For example,
printf("Use \\\" to place\n a \" within\ta\tstring\n");
Use \" to place

a " within a string
TRY: Write a program to print the following picture. Take note that you need to use escape sequences to print special characters.
'__'
(oo)
+========\/
/ || %%% ||
* ||-----||
"" ""
Example (Literals)
1 /* Testing Primitive Types (TestLiteral.c) */
3
4 int main() {
5 char gender = 'm'; // char is single-quoted
6 unsigned short numChildren = 8; // [0, 255]
7 short yearOfBirth = 1945; // [-32767, 32768]
8 unsigned int salary = 88000; // [0, 4294967295]
9 double weight = 88.88; // With fractional part
12 of 40 22/03/2020, 19:54
10 float gpa = 3.88f; // Need suffix 'f' for float

11
12 printf("Gender is %c.\n", gender);
13 printf("Number of children is %u.\n", numChildren);
14 printf("Year of birth is %d.\n", yearOfBirth);
15 printf("Salary is %u.\n", salary);
16 printf("Weight is %.2lf.\n", weight);
17 printf("GPA is %.2f.\n", gpa);
18 return 0;
19 }
Gender is m.
Number of children is 8.
Year of birth is 1945.
Salary is 88000.
Weight is 88.88.
GPA is 3.88.
4. Operations
4.1 Arithmetic Operators

C supports the following arithme�c operators for numbers: short, int, long, long long, char (treated as 8-bit signed integer), unsigned short, unsigned int,
unsigned long, unsigned long long, unsigned char, float, double and long double.
Operator Description Usage Examples

* Mul�plica�on expr1 * expr2 2 * 3 → 6; 3.3 * 1.0 → 3.3
/ Division expr1 / expr2 1 / 2 → 0; 1.0 / 2.0 → 0.5
% Remainder (Modulus) expr1 % expr2 5 % 2 → 1; -5 % 2 → -1
+ Addi�on expr1 + expr2 1 + 2 → 3; 1.1 + 2.2 → 3.3
- Subtrac�on expr1 - expr2 1 - 2 → -1; 1.1 - 2.2 → -1.1
All the above operators are binary operators, i.e., they take two operands. The mul�plica�on, division and remainder take precedence over addi�on and subtrac�on. Within the
same precedence level (e.g., addi�on and subtrac�on), the expression is evaluated from le� to right. For example, 1+2+3-4 is evaluated as ((1+2)+3)-4.
It is important to take note that int/int produces an int, with the result truncated, e.g., 1/2 → 0 (instead of 0.5).
Take note that C does not have an exponent (power) operator ('^' is exclusive-or, not exponent).
4.2 Arithmetic Expressions

In programming, the following arithme�c expression:
must be wri�en as (1+2*a)/3 + (4*(b+c)*(5-d-e))/f - 6*(7/g+h). You cannot omit the mul�plica�on symbol '*' (as in Mathema�cs).
Like Mathema�cs, the mul�plica�on '*' and division '/' take precedence over addi�on '+' and subtrac�on '-'. Parentheses () have higher precedence. The operators '+',
'-', '*', and '/' are le�-associa�ve. That is, 1 + 2 + 3 + 4 is treated as (((1+2) + 3) + 4).
4.3 Mixed-Type Operations

If both the operands of an arithme�c opera�on belong to the same type, the opera�on is carried out in that type, and the result belongs to that type. For example, int/int →
int; double/double → double.
However, if the two operands belong to different types, the compiler promotes the value of the smaller type to the larger type (known as implicit type-cas�ng). The opera�on is
then carried out in the larger type. For example, int/double → double/double → double. Hence, 1/2 → 0, 1.0/2.0 → 0.5, 1.0/2 → 0.5, 1/2.0 →
0.5.
For example,
Type Example Operation

int 2 + 3 int 2 + int 3 → int 5
double 2.2 + 3.3 double 2.2 + double 3.3 → double 5.5
mix 2 + 3.3 int 2 + double 3.3 → double 2.0 + double 3.3 → double 5.3
int 1 / 2 int 1 / int 2 → int 0
double 1.0 / 2.0 double 1.0 / double 2.0 → double 0.5
mix 1 / 2.0 int 1 / double 2.0 → double 1.0 / double 2.0 → double 0.5
Example
1 /* Testing mix-type arithmetic operations (TestMixTypeOp.c) */
3
4 int main() {
5 int i1 = 2, i2 = 4;
6 double d1 = 2.5, d2 = 5.2;
7
13 of 40 22/03/2020, 19:54
8 printf("%d + %d = %d\n", i1, i2, i1+i2); // 2 + 4 = 6

9 printf("%.1lf + %.1lf = %.1lf\n", d1, d2, d1+d2); // 2.5 + 5.2 = 7.7
10 printf("%d + %.1lf = %.1lf\n", i1, d2, i1+d2); // 2 + 5.2 = 7.2 <== mix type
11
12 printf("%d / %d = %d\n", i1, i2, i1/i2); // 2 / 4 = 0 <== NOTE: truncate
13 printf("%.1lf / %.1lf = %.2lf\n", d1, d2, d1/d2); // 2.5 / 5.2 = 0.48
14 printf("%d / %.1lf = %.2lf\n", i1, d2, i1/d2); // 2 / 5.2 = 0.38 <== mix type
15 return 0;
16 }
4.4 Overflow/UnderFlow
Study the output of the following program:
1 /* Test Arithmetic Overflow/Underflow (TestOverflow.c) */

3
4 int main() {
5 // Range of int is [-2147483648, 2147483647]
6 int i1 = 2147483647; // max int
7 printf("%d\n", i1 + 1); // -2147483648 (overflow)
8 printf("%d\n", i1 + 2); // -2147483647
9 printf("%d\n", i1 * i1); // 1
10
11 int i2 = -2147483648; // min int
12 printf("%d\n", i2 - 1); // 2147483647 (underflow)
13 printf("%d\n", i2 - 2); // 2147483646
14 printf("%d\n", i2 * i2); // 0
15 return 0;
16 }
In arithme�c opera�ons, the resultant value wraps around if it exceeds its range (i.e., overflow or underflow). C run�me does not issue an error/warning message but produces
incorrect result.
It is important to take note that checking of overflow/underflow is the programmer's responsibility, i.e., your job!
This feature is an legacy design, where processors were slow. Checking for overflow/underflow consumes computa�on power and reduces performance.
To check for arithme�c overflow (known as secure coding) is tedious. Google for "INT32-C. Ensure that opera�ons on signed integers do not result in overflow" @
www.securecoding.cert.org.
4.5 Compound Assignment Operators

Besides the usual simple assignment operator '=' described earlier, C also provides the so-called compound assignment operators as listed:
Operator Usage Description Example

= var = expr Assign the value of the LHS to the variable at the RHS x = 5;
+= var += expr same as var = var + expr x += 5; same as x = x + 5
-= var -= expr same as var = var - expr x -= 5; same as x = x - 5
*= var *= expr same as var = var * expr x *= 5; same as x = x * 5
/= var /= expr same as var = var / expr x /= 5; same as x = x / 5
%= var %= expr same as var = var % expr x %= 5; same as x = x % 5
4.6 Increment/Decrement Operators

C supports these unary arithme�c operators: increment '++' and decrement '--'.
Operator Example Result

++ x++; ++x Increment by 1, same as x += 1
-- x--; --x Decrement by 1, same as x -= 1
Example
1 /* Test on increment (++) and decrement (--) Operator (TestIncDec.cpp) */
3
4 int main() {
5 int mark = 76; // declare & assign
6 printf("%d\n", mark); // 76
7
8 mark++; // increase by 1 (post-increment)
10
11 ++mark; // increase by 1 (pre-increment)
13
14 mark = mark + 1; // also increase by 1 (or mark += 1)
16
17 mark--; // decrease by 1 (post-decrement)
19
14 of 40 22/03/2020, 19:54
20 --mark; // decrease by 1 (pre-decrement)

22
23 mark = mark - 1; // also decrease by 1 (or mark -= 1)
25 return 0;
26 }
The increment/decrement unary operator can be placed before the operand (prefix operator), or a�er the operands (pos�ix operator). They take on different meaning in
opera�ons.
Operator Description Example Result

++var Pre-Increment y = same as x=x+1; y=x;
Increment var, then use the new value of var ++x;
var++ Post-Increment y = same as oldX=x; x=x+1;
Use the old value of var, then increment x++; y=oldX;
var
--var Pre-Decrement y = same as x=x-1; y=x;
--x;
var-- Post-Decrement y = same as oldX=x; x=x-1;
x--; y=oldX;
If '++' or '--' involves another opera�on, then pre- or post-order is important to specify the order of the two opera�ons. For examples,
x = 5;
printf("%d\n", x++); // Save x (5); Increment x (=6); Print old x (5).
x = 5;
printf("%d\n", ++x); // Increment x (=6); Print x (6).
// This is confusing! Try to avoid! What is i=++i? What is i=i++?
Prefix operator (e.g, ++i) could be more efficient than pos�ix operator (e.g., i++) in some situa�ons.
4.7 Implicit Type-Conversion vs. Explicit Type-Casting

Conver�ng a value from one type to another type is called type cas�ng (or type conversion). There are two kinds of type cas�ng:
1. Implicit type-conversion performed by the compiler automa�cally, and
2. Explicit type-cas�ng via an unary type-cas�ng operator in the form of (new-type)operand.
Implicit (Automatic) Type Conversion

When you assign a value of a fundamental (built-in) type to a variable of another fundamental type, C automa�cally converts the value to the receiving type, if the two types are
compa�ble. For examples,
If you assign an int value to a double variable, the compiler automa�cally casts the int value to a double double (e.g., from 1 to 1.0) and assigns it to the double
variable.
if you assign a double value of to an int variable, the compiler automa�cally casts the double value to an int value (e.g., from 1.2 to 1) and assigns it to the int
variable. The frac�onal part would be truncated and lost. Some compilers issue a warning/error "possible loss in precision"; others do not.
1 /*
2 * Test implicit type casting (TestImplicitTypeCast.c)
3 */
5
6 int main() {
7 int i;
8 double d;
9
10 i = 3;
11 d = i; // Assign an int value to double
12 printf("d = %lf\n", d); // d = 3.0
13
14 d = 5.5;
15 i = d; // Assign a double value to int
16 printf("i = %d\n", i); // i = 5 (truncated, no warning!)
17
18 i = 6.6; // Assign a double literal to int
19 printf("i = %d\n", i); // i = 6 (truncated, no warning!)
20 }
C will not perform automa�c type conversion, if the two types are not compa�ble.
Explicit Type-Casting
You can explicitly perform type-cas�ng via the so-called unary type-cas�ng operator in the form of (new-type)operand. The type-cas�ng operator takes one operand in the
par�cular type, and returns an equivalent value in the new type. Take note that it is an opera�on that yields a resultant value, similar to an addi�on opera�on although addi�on
involves two operands. For example,
printf("%lf\n", (double)5); // int 5 -> double 5.0

printf("%d\n", (int)5.5); // double 5.5 -> int 5
double aDouble = 5.6;

int anInt = (int)aDouble; // return 5 and assign to anInt. aDouble does not change!
15 of 40 22/03/2020, 19:54
Example: Suppose that you want to find the average (in double) of the integers between 1 and 100. Study the following codes:
1 /*
2 * Testing Explicit Type Cast (Average1to100.c).
3 */
5
6 int main() {
7 int sum = 0;
8 double average;
9 int number = 1;
10 while (number <= 100) {
11 sum += number; // Final sum is int 5050
12 ++number;
13 }
14 average = sum / 100; // Won't work (average = 50.0 instead of 50.5)
15 printf("Average is %lf\n", average); // Average is 50.0
16 return 0;
17 }
You don't get the frac�onal part although the average is a double. This is because both the sum and 100 are int. The result of division is an int, which is then implicitly
casted to double and assign to the double variable average. To get the correct answer, you can do either:
average = (double)sum / 100; // Cast sum from int to double before division
average = sum / (double)100; // Cast 100 from int to double before division
average = sum / 100.0;
average = (double)(sum / 100); // Won't work. why?
Example:
1 /*
2 * Converting between Celsius and Fahrenheit (ConvertTemperature.c)
3 * Celsius = (5/9)(FahrenheitɃ32)
4 * Fahrenheit = (9/5)Celsius+32
5 */
7
8 int main() {
9 double celsius, fahrenheit;
10
11 printf("Enter the temperature in celsius: ");
12 scanf("%lf", &celsius);
13 fahrenheit = celsius * 9 / 5 + 32;
14 // 9/5*celsius + 32 gives wrong answer! Why?
15 printf("%.2lf degree C is %.2lf degree F\n", celsius, fahrenheit);
16
17 printf("Enter the temperature in fahrenheit: ");
18 scanf("%lf", &fahrenheit);
19 celsius = (fahrenheit - 32) * 5 / 9;
20 // 5/9*(fahrenheit - 32) gives wrong answer! Why?
21 printf("%.2lf degree F is %.2lf degree C\n", fahrenheit, celsius);
22 return 0;
23 }
4.8 Relational and Logical Operators

Very o�en, you need to compare two values before deciding on the ac�on to be taken, e.g., if mark is more than or equal to 50, print "PASS".
C provides six comparison operators (or rela�onal operators):
Operator Description Usage Example (x=5, y=8)

== Equal to expr1 == expr2 (x == y) → false
!= Not Equal to expr1 != expr2 (x != y) → true
> Greater than expr1 > expr2 (x > y) → false
>= Greater than or equal to expr1 >= expr2 (x >= 5) → true
< Less than expr1 < expr2 (y < 8) → false
<= Less than or equal to expr1 >= expr2 (y <= 8) → true
Each comparison opera�on involves two operands, e.g., x <= 100. It is invalid to write 1 < x < 100 in programming. Instead, you need to break out the two comparison
opera�ons x > 1, x < 100, and join with with a logical AND operator, i.e., (x > 1) && (x < 100), where && denotes AND operator.
C provides four logical operators:
Operator Description Usage

&& Logical AND expr1 && expr2
|| Logical OR expr1 || expr2
! Logical NOT !expr
^ Logical XOR expr1 ^ expr2
The truth tables are as follows:
AND (&&) true false
16 of 40 22/03/2020, 19:54
true true false

false false false
OR (||) true false
true true true

false true false
NOT (!) true false
false true
XOR (^) true false
true false true

false true false
Example:
// Return true if x is between 0 and 100 (inclusive)

(x >= 0) && (x <= 100)
// wrong to use 0 <= x <= 100

// Return true if x is outside 0 and 100 (inclusive)
(x < 0) || (x > 100) //or
!((x >= 0) && (x <= 100))
// Return true if year is a leap year

// A year is a leap year if it is divisible by 4 but not by 100, or it is divisible by 400.
((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)
Exercise: Given the year, month (1-12), and day (1-31), write a boolean expression which returns true for dates before October 15, 1582 (Gregorian calendar cut over date).
Ans: (year < 1582) || (year == 1582 && month < 10) || (year == 1582 && month == 10 && day < 15)
5. Flow Control
There are three basic flow control constructs - sequen�al, condi�onal (or decision), and loop (or itera�on), as illustrated below.
5.1 Sequential Flow Control

A program is a sequence of instruc�ons. Sequen�al flow is the most common and straight-forward, where programming statements are executed in the order that they are wri�en
- from top to bo�om in a sequen�al manner.
5.2 Conditional (Decision) Flow Control

There are a few types of condi�onals, if-then, if-then-else, nested-if (if-elseif-elseif-...-else), switch-case, and condi�onal expression.
Syntax Example Flowchart
// if-then if (mark >= 50) {

if ( booleanExpression ) { printf("Congratulation!\n");
true-block ; printf("Keep it up!\n");
} }
17 of 40 22/03/2020, 19:54
// if-then-else if (mark >= 50) {

if ( booleanExpression ) { printf("Congratulation!\n");
true-block ; printf("Keep it up!\n");
} else { } else {
false-block ; printf("Try Harder!\n");
} }
// nested-if if (mark >= 80) {

if ( booleanExpr-1 ) { printf("A\n");
block-1 ; } else if (mark >= 70) {
} else if ( booleanExpr-2 ) { printf("B\n");
} else if ( booleanExpr-3 ) { printf("C\n");
} else if ( booleanExpr-4 ) { printf("D\n");
...... } else {
} else { printf("F\n");
elseBlock ; }
}
// switch-case char oper; int num1, num2, result;

switch ( selector ) { ......
case value-1: switch (oper) {
block-1; break; case '+':
case value-2: result = num1 + num2; break;
block-2; break; case '-':
case value-3: result = num1 - num2; break;
block-3; break; case '*':
...... result = num1 * num2; break;
case value-n: case '/':
block-n; break; result = num1 / num2; break;
default: default:
default-block; printf("Unknown operator\n");
} }
"switch-case" is an alterna�ve to the "nested-if". In a switch-case statement, a break statement is needed for each of the cases. If break is missing, execu�on will flow through
the following case. You can use either an int or char variable as the case-selector.
Conditional Operator: A condi�onal operator is a ternary (3-operand) operator, in the form of booleanExpr ? trueExpr : falseExpr. Depending on the
booleanExpr, it evaluates and returns the value of trueExpr or falseExpr.
Syntax Example
booleanExpr ? trueExpr : falseExpr printf("%s\n", (mark >= 50) ? "PASS" : "FAIL");

// print either "PASS" or "FAIL"
max = (a > b) ? a : b; // RHS returns a or b
abs = (a > 0) ? a : -a; // RHS returns a or -a
Braces: You could omit the braces { }, if there is only one statement inside the block. For example,
if (mark >= 50)

printf("PASS\n"); // Only one statement, can omit { } but not recommended
else { // more than one statements, need { }
printf("FAIL\n");
printf("Try Harder!\n");
}
However, I recommend that you keep the braces, even though there is only one statement in the block, to improve the readability of your program.
Exercises
[TODO]
5.3 Loop Flow Control

Again, there are a few types of loops: for-loop, while-do, and do-while.
Syntax Example Flowchart
18 of 40 22/03/2020, 19:54
// for-loop // Sum from 1 to 1000

for (init; test; post-proc) { int sum = 0, number;
body ; for (number = 1; number <= 1000; ++number) {
} sum += number;
}
// while-do int sum = 0, number = 1;

while ( condition ) { while (number <= 1000) {
body ; sum += number;
} ++number;
}
// do-while int sum = 0, number = 1;

do { do {
body ; sum += number;
} ++number;
while ( condition ) ; } while (number <= 1000);
The difference between while-do and do-while lies in the order of the body and condi�on. In while-do, the condi�on is tested first. The body will be executed if the condi�on is true
and the process repeats. In do-while, the body is executed and then the condi�on is tested. Take note that the body of do-while will be executed at least once (vs. possibly zero for
while-do).
Suppose that your program prompts user for a number between 1 to 10, and checks for valid input, do-while with a boolean flag could be more appropriate.
// Input with validity check

bool valid = false;
int number;
do {
// prompt user to enter an int between 1 and 10
......
// if the number entered is valid, set done to exit the loop
if (number >=1 && number <= 10) {
valid = true;
}
} while (!valid); // Need a semi-colon to terminate do-while
Below is an example of using while-do:
// Game loop
bool gameOver = false;
while (!gameOver) {
// play the game
......
// Update the game state
// Set gameOver to true if appropriate to exit the game loop
......
}
Example (Counter-Controlled Loop): Prompt user for an upperbound. Sum the integers from 1 to a given upperbound and compute its average.
1 /*
2 * Sum from 1 to a given upperbound and compute their average (SumNumbers.c)
3 */
5
6 int main() {
7 int sum = 0; // Store the accumulated sum
8 int upperbound;
9
11 scanf("%d", &upperbound);
12
13 // Sum from 1 to the upperbound
14 int number;
15 for (number = 1; number <= upperbound; ++number) {
16 sum += number;
17 }
18 printf("Sum is %d\n", sum);
19 printf("Average is %.2lf\n", (double)sum / upperbound);
20
21 // Sum only the odd numbers
19 of 40 22/03/2020, 19:54
22 int count = 0; // counts of odd numbers

23 sum = 0; // reset sum
24 for (number = 1; number <= upperbound; number = number + 2) {
25 ++count;
26 sum += number;
27 }
28 printf("Sum of odd numbers is %d\n", sum);
29 printf("Average is %.2lf\n", (double)sum / count);
30 }
Example (Sentinel-Controlled Loop): Prompt user for posi�ve integers, and display the count, maximum, minimum and average. Terminate when user enters -1.
1 /* Prompt user for positive integers and display the count, maximum,
2 minimum and average. Terminate the input with -1 (StatNumbers.c) */
4 #include <limits.h> // for INT_MAX
5
6 int main() {
7 int numberIn = 0; // input number (positive integer)
8 int count = 0; // count of inputs, init to 0
9 int sum = 0; // sum of inputs, init to 0
10 int max = 0; // max of inputs, init to minimum
11 int min = INT_MAX; // min of inputs, init to maximum (need <climits>)
12 int sentinel = -1; // Input terminating value
13
14 // Read Inputs until sentinel encountered
15 printf("Enter a positive integer or %d to exit: ", sentinel);
16 scanf("%d", &numberIn);
17 while (numberIn != sentinel) {
18 // Check input for positive integer
19 if (numberIn > 0) {
20 ++count;
21 sum += numberIn;
22 if (max < numberIn) max = numberIn;
23 if (min > numberIn) min = numberIn;
24 } else {
25 printf("error: input must be positive! try again...\n");
26 }
27 printf("Enter a positive integer or %d to exit: ", sentinel);
28 scanf("%d", &numberIn);
29 }
30
31 // Print result
32 printf("\n");
33 printf("Count is %d\n", count);
34 if (count > 0) {
35 printf("Maximum is %d\n", max);
36 printf("Minimum is %d\n", min);
37 printf("Average is %.2lf\n", (double)sum / count);
38 }
39 }
Program Notes
In compu�ng, a sen�nel value is a special value that indicates the end of data (e.g., a nega�ve value to end a sequence of posi�ve value, end-of-file, null character in the null-
terminated string). In this example, we use -1 as the sen�nel value to indicate the end of inputs, which is a sequence of posi�ve integers. Instead of hardcoding the value of -1,
we use a variable called sentinel for flexibility and ease-of-maintenance.
Take note of the while-loop pa�ern in reading the inputs. In this pa�ern, you need to repeat the promp�ng and input statement.
Exercises
[TODO]
5.4 Interrupting Loop Flow - "break" and "continue"

The break statement breaks out and exits the current (innermost) loop.
The continue statement aborts the current itera�on and con�nue to the next itera�on of the current (innermost) loop.
break and continue are poor structures as they are hard to read and hard to follow. Use them only if absolutely necessary. You can always write the same program without
using break and continue.
Example (break): The following program lists the non-prime numbers between 2 and an upperbound.
1 /*
2 * List non-prime from 1 to an upperbound (NonPrimeList.c).
3 */
5 #include <math.h>
6
7 int main() {
8 int upperbound, number, maxFactor, factor;
12 // Not a prime, if there is a factor between 2 and sqrt(number)
20 of 40 22/03/2020, 19:54
13 maxFactor = (int)sqrt(number);
14 for (factor = 2; factor <= maxFactor; ++factor) {
15 if (number % factor == 0) { // Factor?
16 printf("%d ", number);
17 break; // A factor found, no need to search for more factors
18 }
19 }
20 }
21 printf("\n");
22 return 0;
23 }
Let's rewrite the above program without using break statement. A while loop is used (which is controlled by the boolean flag) instead of for loop with break.
1 /*
2 * List primes from 1 to an upperbound (PrimeList.c).
3 */
5 #include <math.h>
6
7 int main() {
8 int upperbound, number, maxFactor, isPrime, factor;
11
13 // Not prime, if there is a factor between 2 and sqrt of number
14 maxFactor = (int)sqrt(number);
15 isPrime = 1;
16 factor = 2;
17 while (isPrime && factor <= maxFactor) {
18 if (number % factor == 0) { // Factor of number?
19 isPrime = 0;
20 }
21 ++factor;
22 }
23 if (isPrime) printf("%d ", number);
24 }
25 printf("\n");
26 return 0;
27 }
Example (continue):
// Sum 1 to upperbound, exclude 11, 22, 33,...

int upperbound = 100;
int sum = 0;
int number;
for (number = 1; number <= upperbound; ++number) {
if (number % 11 == 0) continue; // Skip the rest of the loop body, continue to the next iteration
sum += number;
}
// It is better to re-write the loop as:
for (number = 1; number <= upperbound; ++number) {
if (number % 11 != 0) sum += number;
}
Example (break and continue): Study the following program.
1 /* A mystery series (Mystery.c) */

3
4 int main() {
5 int number = 1;
6 while (1) {
7 ++number;
8 if ((number % 3) == 0) continue;
9 if (number == 133) break;
10 if ((number % 2) == 0) {
11 number += 3;
12 } else {
13 number -= 3;
14 }
15 printf("%d ", number);
16 }
17 printf("\n");
18 return 0;
19 }
5.5 Terminating Program

There are a few ways that you can terminate your program, before reaching the end of the programming statements.
exit(): You could invoke the func�on exit(int exitCode), in <stdlib.h>, to terminate the program and return the control to the Opera�ng System. By conven�on,
return code of zero indicates normal termina�on; while a non-zero exitCode (-1) indicates abnormal termina�on. For example,
21 of 40 22/03/2020, 19:54
abort(): The header <stdlib.h> also provide a func�on called abort(), which can be used to terminate the program abnormally.
if (errorCount > 10) {

printf("too many errors\n");
exit(-1); // Terminate the program
// OR abort();
}
The "return" Statement: You could also use a "return returnValue" statement in the main() func�on to terminate the program and return control back to the
Opera�ng System. For example,
int main() {
...
if (errorCount > 10) {
printf("too many errors\n");
return -1; // Terminate and return control to OS from main()
}
...
}
5.6 Nested Loops

The following diagram illustrates a nested for-loop, i.e., an inner for-loop within an outer for-loop.
Try out the following program, which prints a 8-by-8 checker box pa�ern using nested loops, as follows:
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
1 /*
2 * Print square pattern (PrintSquarePattern.c).
3 */
5
6 int main() {
7 int size = 8, row, col;
8 for (row = 1; row <= size; ++row) { // Outer loop to print all the rows
9 for (col = 1; col <= size; ++col) { // Inner loop to print all the columns of each row
10 printf("# ");
11 }
12 printf("\n"); // A row ended, bring the cursor to the next line
13 }
14
15 return 0;
16 }
This program contains two nested for-loops. The inner loop is used to print a row of eight "# ", which is followed by prin�ng a newline. The outer loop repeats the inner loop to
print all the rows.
Suppose that you want to print this pa�ern instead (in program called PrintCheckerPattern.cpp):
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
# # # # # # # #
22 of 40 22/03/2020, 19:54
You need to print an addi�onal space for even-number rows. You could do so by adding the following statement before Line 8.
if ((row % 2) == 0) { // print a leading space for even-numbered rows

printf(" ");
}
Exercises
1. Print these pa�erns using nested loop (in a program called PrintPattern1x). Use a variable called size for the size of the pa�ern and try out various sizes. You should
use as few printf() statements as possible.
# * # * # * # * # # # # # # # # # # # # # # # # 1 1
# * # * # * # * # # # # # # # # # # # # # # 2 1 1 2
# * # * # * # * # # # # # # # # # # # # 3 2 1 1 2 3
# * # * # * # * # # # # # # # # # # 4 3 2 1 1 2 3 4
# * # * # * # * # # # # # # # # 5 4 3 2 1 1 2 3 4 5
# * # * # * # * # # # # # # 6 5 4 3 2 1 1 2 3 4 5 6
# * # * # * # * # # # # 7 6 5 4 3 2 1 1 2 3 4 5 6 7
# * # * # * # * # # 8 7 6 5 4 3 2 1 1 2 3 4 5 6 7 8
(a) (b) (c) (d) (e)
Hints:
The equa�ons for major and opposite diagonals are row = col and row + col = size + 1. Decide on what to print above and below the diagonal.
2. Print the �metable of 1 to 9, as follows, using nested loop. (Hints: you need to use an if-else statement to check whether the product is single-digit or double-digit, and print
an addi�onal space if needed.)
1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
......
3. Print these pa�erns using nested loop.
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# # # # # # # # # #
# # # # # # # # # #
# # # # # # # #
# # # # # # # # # #
# # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
(a) (b) (c) (d) (e)
5.7 Some Issues in Flow Control

Dangling else: The "dangling else" problem can be illustrated as follows:
if (i == 0)
if (j == 0)
printf("i and j are zero\n");
else printf("i is not zero\n"); // intend for the outer-if
The else clause in the above codes is syntac�cally applicable to both the outer-if and the inner-if. The C compiler always associate the else clause with the innermost if (i.e., the
nearest if). Dangling else can be resolved by applying explicit parentheses. The above codes are logically incorrect and require explicit parentheses as shown below.
if ( i == 0) {
if (j == 0) printf("i and j are zero\n");
} else {
printf("i is not zero\n"); // non-ambiguous for outer-if
}
Endless Loop: The following constructs:
while (1) { ...... }
is commonly used. It seems to be an endless loop (or infinite loop), but it is usually terminated via a break or return statement inside the loop body. This kind of code is hard to
read - avoid if possible by re-wri�ng the condi�on.
5.8 Exercises
[TODO]
6. Writing Correct and Good Programs

It is important to write programs that produce the correct results. It is also important to write programs that others (and you yourself three days later) can understand, so that the
programs can be maintained - I call these programs good programs.
Here are the sugges�ons:

Follow established conven�on so that everyone has the same basis of understanding.
Format and layout of the source code with appropriate indents, white spaces and white lines. Use 3 or 4 spaces for indent, and blank lines to separate sec�ons of codes.
Choose good names that are self-descrip�ve and meaningful, e.g., row, col, size, xMax, numStudents. Do not use meaningless names, such as a, b, c, d. Avoid single-
alphabet names (easier to type but o�en meaningless), except common names likes x, y, z for co-ordinates and i for index.
Provide comments to explain the important as well as salient concepts. Comment your codes liberally.
Write your program documenta�on while wri�ng your programs.
Avoid un-structured constructs, such as break and continue, which are hard to follow.
23 of 40 22/03/2020, 19:54
Use "mono-space" fonts (such as Consola, Courier New, Courier) for wri�ng/displaying your program.
Programming Errors
There are generally three classes of programming errors:
1. Compila�on Error (or Syntax Error): can be fixed easily.
2. Run�me Error: program halts pre-maturely without producing the results - can also be fixed easily.
3. Logical Error: program completes but produces incorrect results. It is easy to detect if the program always produces wrong result. It is extremely hard to fix if the program
produces the correct result most of the �mes, but incorrect result some�mes. For example,
// Can compile and execute, but give wrong result – sometimes!

if (mark > 50) {
printf("PASS\n");
} else {
printf("FAIL\n");
}
This kind of errors is very serious if it is not caught before produc�on. Wri�ng good programs helps in minimizing and detec�ng these errors. A good tes�ng strategy is
needed to ascertain the correctness of the program. So�ware tes�ng is an advanced topics which is beyond our current scope.
Debugging Programs
Here are the common debugging techniques:
1. Stare at the screen! Unfortunately, errors usually won't pop-up even if you stare at it extremely hard.
2. Study the error messages! Do not close the console when error occurs and pretending that everything is fine. This helps most of the �mes.
3. Insert print statements at appropriate loca�ons to display the intermediate results. It works for simple toy program, but it is neither effec�ve nor efficient for complex
program.
4. Use a graphic debugger. This is the most effec�ve means. Trace program execu�on step-by-step and watch the value of variables and outputs.
5. Advanced tools such as profiler (needed for checking memory leak and func�on usage).
6. Proper program tes�ng to wipe out the logical errors.
Testing Your Program for Correctness

How to ensure that your program always produces correct result, 100% of the �mes? It is impossible to try out all the possible outcomes, even for a simple program. Program
tes�ng usually involves a set of representa�ve test cases, which are designed to catch the major classes of errors. Program tes�ng is beyond the scope of this wri�ng.
7. Arrays
7.1 Array Declaration and Usage

Suppose that you want to find the average of the marks for a class of 30 students, you certainly do not want to create 30 variables: mark1, mark2, ..., mark30. Instead, You
could use a single variable, called an array, with 30 elements.
An array is a list of elements of the same type, iden�fied by a pair of square brackets [ ]. To use an array, you need to declare the array with 3 things: a name, a type and a
dimension (or size, or length). The syntax is:
type arrayName[arraylength];
I recommend using a plural name for array, e.g., marks, rows, numbers. For example,
int marks[5]; // Declare an int array called marks with 5 elements

double numbers[10]; // Declare an double array of 10 elements
// Use #define to specify the length

#define SIZE 9
int numbers[SIZE];
// Some compilers support an variable as array length, e.g.,

const int SIZE = 9;
float temps[SIZE]; // Use const int as array length
int size;
printf("Enter the length of the array: ");
scanf("%d", size);
float values[size];
Take note that, in C, the value of the elements are undefined a�er declara�on.
You can also ini�alize the array during declara�on with a comma-separated list of values, as follows:
// Declare and initialize an int array of 3 elements

int numbers[3] = {11, 33, 44};
// If length is omitted, the compiler counts the elements
int numbers[] = {11, 33, 44};
// Number of elements in the initialization shall be equal to or less than length
int numbers[5] = {11, 33, 44}; // Remaining elements are zero. Confusing! Don't do this
int numbers[2] = {11, 33, 44}; // ERROR: too many initializers
// Use {0} or {} to initialize all elements to 0

int numbers[5] = {0}; // First element to 0, the rest also to zero
int numbers[5] = {}; // All element to 0 too
Example: Array Declaration and Initialization
24 of 40 22/03/2020, 19:54
1 /* Test local array initialization (TestArrayInit.c) */

3 #define SIZE 5
4
5 int main() {
6 int i;
7
8 int a1[SIZE]; // Uninitialized
9 for (i = 0; i < SIZE; ++i) printf("%d ", a1[i]);
10 printf("\n"); // ? ? ? ? ?
11
12 int a2[SIZE] = {21, 22, 23, 24, 25}; // All elements initialized
14 printf("\n"); // 21 22 23 24 25
15
16 int a3[] = {31, 32, 33, 34, 35}; // Size deduced from init values
17 int a3Size = sizeof(a3)/sizeof(int);
18 printf("Size is %d\n", a3Size); // 5
19 for (i = 0; i < a3Size; ++i) printf("%d ", a3[i]);
20 printf("\n"); // 31 32 33 34 35
21
22 int a4[5] = {41, 42}; // Leading elements initialized, the rests to 0
24 printf("\n"); // 41 42 0 0 0
25
26 int a5[5] = {0}; // First elements to 0, the rests to 0 too
28 printf("\n"); // 0 0 0 0 0
29
30 int a6[5] = {}; // All elements to 0 too
32 printf("\n"); // 0 0 0 0 0
33
34 // Using variable as the length of array
35 const int SIZE_2 = 5;
36 int a7[SIZE_2]; // okay without initialization
37 int a8[SIZE_2] = {5, 4, 3, 2, 1}; // error: variable-sized object may not be initialized
38 }
You can refer to an element of an array via an index (or subscript) enclosed within the square bracket [ ]. C's array index begins with zero. For example, suppose that marks is an
int array of 5 elements, then the 5 elements are: marks[0], marks[1], marks[2], marks[3], and marks[4].
// Declare & allocate a 5-element int array

int marks[5];
// Assign values to the elements
marks[0] = 95;
marks[1] = 85;
marks[2] = 77;
marks[3] = 69;
marks[4] = 66;
printf("%d\n", marks[0]");
printf("%d\n", marks[3] + marks[4];
To create an array, you need to known the length (or size) of the array in advance, and allocate accordingly. Once an array is created, its length is fixed and cannot be changed. At
�mes, it is hard to ascertain the length of an array (e.g., how many students in a class?). Nonetheless, you need to es�mate the length and allocate an upper bound. This is
probably the major drawback of using an array.
You can find the array length using expression sizeof(arrayName)/sizeof(arrayName[0]), where sizeof(arrayName) returns the total bytes of the array and
sizeof(arrayName[0]) returns the bytes of first element.
C does not perform array index-bound check. In other words, if the index is beyond the array's bounds, it does not issue a warning/error. For example,
const int size = 5;

int numbers[size]; // array index from 0 to 4
// Index out of bound!

// Can compiled and run, but could pose very serious side effect!
numbers[88] = 999;
printf("%d\n", numbers[77]);
This is another pi�all of C. Checking the index bound consumes computa�on power and depicts the performance. However, it is be�er to be safe than fast. Newer programming
languages such as Java/C# performs array index bound check.
25 of 40 22/03/2020, 19:54
7.2 Array and Loop

Arrays works hand-in-hand with loops. You can process all the elements of an array via a loop, for example,
1 /*
2 * Find the mean and standard deviation of numbers kept in an array (MeanStdArray.c).
3 */
5 #include <math.h>
6 #define SIZE 7
7
8 int main() {
9 int marks[] = {74, 43, 58, 60, 90, 64, 70};
10 int sum = 0;
11 int sumSq = 0;
12 double mean, stdDev;
13 int i;
14 for (i = 0; i < SIZE; ++i) {
15 sum += marks[i];
16 sumSq += marks[i] * marks[i];
17 }
18 mean = (double)sum/SIZE;
19 printf("Mean is %.2lf\n", mean);
20
21 stdDev = sqrt((double)sumSq/SIZE - mean*mean);
22 printf("Std dev is %.2lf\n", stdDev);
23
24 return 0;
25 }
Exercises
[TODO]
7.3 Multi-Dimensional Array

For example,
int[2][3] = { {11, 22, 33}, {44, 55, 66} };
For 2D array (table), the first index is the row number, second index is the column number. The elements are stored in a so-called row-major manner, where the column index runs
out first.
Example
1 /* Test Multi-dimensional Array (Test2DArray.c) */
3 void printArray(const int[][3], int);
4
5 int main() {
6 int myArray[][3] = {{8, 2, 4}, {7, 5, 2}}; // 2x3 initialized
7 // Only the first index can be omitted and implied
8 printArray(myArray, 2);
9 return 0;
10 }
11
12 // Print the contents of rows-by-3 array (columns is fixed)
13 void printArray(const int array[][3], int rows) {
14 int i, j;
15 for (i = 0; i < rows; ++i) {
16 for (j = 0; j < 3; ++j) {
17 printf("%d ", array[i][j]);
18 }
19 printf("\n");
20 }
21 }
8. Functions
26 of 40 22/03/2020, 19:54
8.1 Why Functions?

At �mes, a certain por�on of codes has to be used many �mes. Instead of re-wri�ng the codes many �mes, it is be�er to put them into a "subrou�ne", and "call" this "subrou�ne"
many �me - for ease of maintenance and understanding. Subrou�ne is called method (in Java) or func�on (in C/C++).
The benefits of using func�ons are:

1. Divide and conquer: construct the program from simple, small pieces or components. Modularize the program into self-contained tasks.
2. Avoid repea�ng codes: It is easy to copy and paste, but hard to maintain and synchronize all the copies.
3. So�ware Reuse: you can reuse the func�ons in other programs, by packaging them into library codes.
Two par�es are involved in using a func�on: a caller who calls the func�on, and the func�on called. The caller passes argument(s) to the func�on. The func�on receives these
argument(s), performs the programmed opera�ons within the func�on's body, and returns a piece of result back to the caller.
8.2 Using Functions
Get Started with an Example

Suppose that we need to evaluate the area of a circle many �mes, it is be�er to write a func�on called getArea(), and re-use it when needed.
1 /* Test Function (TestFunction.c) */

3 const int PI = 3.14159265;
4
5 // Function Prototype (Function Declaration)
6 double getArea(double radius);
7
8 int main() {
9 double radius1 = 1.1, area1, area2;
10 // call function getArea()
11 area1 = getArea(radius1);
12 printf("area 1 is %.2lf\n", area1);
14 area2 = getArea(2.2);
15 printf("area 2 is %.2lf\n", area2);
17 printf("area 3 is %.2lf\n", getArea(3.3));
18 }
19
20 // Function Definition
21 // Return the area of a circle given its radius
22 double getArea(double radius) {
23 return radius * radius * PI;
24 }
area 1 is 3.63
area 2 is 14.52
area 3 is 32.67
In the above example, a reusable func�on called getArea() is defined, which receives a parameter (in double) from the caller, performs the calcula�on, and return a piece of
result (in double) to the caller. In the main(), we invoke getArea() func�ons thrice, each �me with a different parameter.
In C, you need to declare a func�on prototype (before the func�on is used), and provide a func�on defini�on, with a body containing the programmed opera�ons.
Function Definition
The syntax for func�on defini�on is as follows:
returnValueType functionName ( parameterList ) {

functionBody ;
}
The parameterList consists of comma-separated parameter-type and parameter-name, i.e., param-1-type param-1-name, param-2-type param-2-name,...
The returnValueType specifies the type of the return value, such as int or double. An special return type called void can be used to denote that the func�on returns no
value. In C, a func�on is allowed to return one value or no value (void). It cannot return mul�ple values. [C does not allow you to return an array!]
The "return" Statement

Inside the func�on's body, you could use a return statement to return a value (of the returnValueType declared in the func�on's header) and pass the control back to the
caller. The syntax is:
27 of 40 22/03/2020, 19:54
return expression; // Evaluated to a value of returnValueType declared in function's signature

return; // For function with return type of void
Take note that invoking a func�on (by the caller) transfers the control to the func�on. The return statement in the func�on transfers the control back to the caller.
Function Naming Convention

A func�on's name shall be a verb or verb phrase (ac�on), comprising one or more words. The first word is in lowercase, while the rest are ini�al-capitalized (known as camel-case).
For example, getArea(), setRadius(), moveDown(), isPrime(), etc.
Function Prototype
In C, a func�on must be declared before it can be called. It can be achieved by either placing the func�on defini�on before it is being used, or declare a so-called func�on
prototype.
A func�on prototype tells the compiler the func�on's interface, i.e., the return-type, func�on name, and the parameter type list (the number and type of parameters). The func�on
can now be defined anywhere in the file. For example,
// Function prototype - placed before the function is used.

double getArea(double); // without the parameter name
int max(int, int);
You could op�onally include the parameter names in the func�on prototype. The names will be ignored by the compiler, but serve as documenta�on. For example,
// Function Prototype
double getArea(double radius); // parameter names are ignored, but serve as documentation
int max(int number1, int number2);
Func�on prototypes are usually grouped together and placed in a so-called header file. The header file can be included in many programs. We will discuss header file later.
Another Example
We have a func�on called max(int, int), which takes two int and return their maximum. We invoke the max() func�on from the main().
1 /* Testing max function (TestMaxFunction.c) */

3
4 int maximum(int, int); // Function prototype (declaration)
5
6 int main() {
7 printf("%d\n", maximum(5, 8)); // Call maximum() with literals
8
9 int a = 6, b = 9, c;
10 c = maximum(a, b); // Call maximum() with variables
11 printf("%d\n", c);
12
13 printf("%d\n", maximum(c, 99)); // Call maximum()
14 }
15
16 // Function definition
17 // A function that returns the maximum of two given int
18 int maximum(int num1, int num2) {
19 return (num1 > num2) ? num1 : num2;
20 }
The "void" Return Type

Suppose that you need a func�on to perform certain ac�ons (e.g., prin�ng) without a need to return a value to the caller, you can declare its return-value type as void. In the
func�on's body, you could use a "return;" statement without a return value to return control to the caller. In this case, the return statement is op�onal. If there is no return
statement, the en�re body will be executed, and control returns to the caller at the end of the body.
Actual Parameters vs. Formal Parameters

Recall that a func�on receives arguments from its caller, performs the ac�ons defined in the func�on's body, and return a value (or nothing) to the caller.
In the above example, the variable (double radius) declared in the signature of getArea(double radius) is known as formal parameter. Its scope is within the
func�on's body. When the func�on is invoked by a caller, the caller must supply so-called actual parameters (or arguments), whose value is then used for the actual computa�on.
For example, when the func�on is invoked via "area1 = getArea(radius1)", radius1 is the actual parameter, with a value of 1.1.
Scope of Function's Local Variables and Parameters

All variables, including func�on's parameters, declared inside a func�on are available only to the func�on. They are created when the func�on is called, and freed (destroyed) a�er
the func�on returns. They are called local variables because they are local to the func�on and not available outside the func�on. They are also called automa�c variables, because
they are created and destroyed automa�cally - no programmer's explicit ac�on needed to allocate and deallocate them.
Boolean Functions
A boolean func�on returns a int value of either 0 or not 0 to the caller.
Suppose that we wish to write a func�on called isOdd() to check if a given number is odd.
1 /*
2 * Test Boolean function (BooleanfunctionTest.c).
3 */
5
6 // Function Prototype
7 int isOdd(int);
28 of 40 22/03/2020, 19:54
8
9 int main() {
10 printf("%d\n", isOdd(5)); // 1 (true)
11 printf("%d\n", isOdd(6)); // 0 (false)
12 printf("%d\n", isOdd(-5)); // 0 (false)
13 }
14
15 int isOdd(int number) {
16 if (number % 2 == 1) {
17 return 1;
18 } else {
19 return 0;
20 }
21 }
This seemingly correct codes produces false for -5, because -5%2 is -1 instead of 1. You may rewrite the condi�on:
bool isOdd(int number) {

if (number % 2 == 0) {
return false;
} else {
return true;
}
}
The above code produces the correct answer, but is poor. For boolean func�on, you should simply return the resultant value of the comparison, instead of using a condi�onal
statement, as follow:
int isEven(int number) {

return (number % 2 == 0);
}
int isOdd(int number) {

return !(number % 2 == 0); // OR return !isEven(number);
}
int main() {
int number = -9;
if (isEven(number)) { // Don't write (isEven(number) != 0)
printf("Even\n");
}
if (isOdd(number)) { // Don't write (isOdd(number) != 0)
printf("Odd\n");
}
}
8.3 Functions and Arrays

You can also pass arrays into func�on. However, you also need to pass the size of the array into the func�on. This is because there is no way to tell the size of the array from the
array argument inside the called func�on.
For example,
Example: Computing the Sum of an Array and Print Array's Contents

1 /* Function to compute the sum of an array (SumArray.c) */
3
4 // Function prototype
5 int sum(int array[], int size); // Need to pass the array size too
6 void print(int array[], int size);
7
8 // Test Driver
9 int main() {
10 int a1[] = {8, 4, 5, 3, 2};
11 print(a1, 5); // {8,4,5,3,2}
12 printf("sum is %d\n", sum(a1, 5)); // sum is 22
13 }
14
15 // Function definition
16 // Return the sum of the given array
17 int sum(int array[], int size) {
18 int sum = 0;
19 int i;
20 for (i = 0; i < size; ++i) {
21 sum += array[i];
22 }
23 return sum;
24 }
25
26 // Print the contents of the given array
27 void print(int array[], int size) {
28 int i;
29 printf("{");
30 for (i = 0; i < size; ++i) {
31 printf("%d", array[i]);
32 if (i < size - 1) {
29 of 40 22/03/2020, 19:54
33 printf(",");
34 }
35 }
36 printf("}\n");
37 }
8.4 Pass-by-Value vs. Pass-by-Reference

There are two ways that a parameter can be passed into a func�on: pass by value vs. pass by reference.
Pass-by-Value
In pass-by-value, a "copy" of argument is created and passed into the func�on. The invoked func�on works on the "clone", and cannot modify the original copy. In C, fundamental
types (such as int and double) are passed by value. That is, you cannot modify caller's value inside the func�on - there is no side effect.
Example (Fundamental Types are Passed by Value)

1 /* Fundamental types are passed by value into Function (TestPassByValue.c) */
3
4 // Function prototypes
5 int inc(int number);
6
7 // Test Driver
8 int main() {
9 int n = 8;
10 printf("Before calling function, n is %d\n", n); // 8
11 int result = inc(n);
12 printf("After calling function, n is %d\n", n); // 8
13 printf("result is %d\n", result); // 9
14 }
15
16 // Function definitions
17 // Return number+1
18 int inc(int number) {
19 ++number; // Modify parameter, no effect to caller
20 return number;
21 }
Pass-by-Reference
On the other hand, in pass-by-reference, a reference of the caller's variable is passed into the func�on. In other words, the invoked func�on works on the same data. If the invoked
func�on modifies the parameter, the same caller's copy will be modified as well.
In C, arrays are passed by reference. That is, you can modify the contents of the caller's array inside the invoked func�on - there could be side effect in passing arrays into func�on.
C does not allow func�ons to return an array. Hence, if you wish to write a func�on that modifies the contents of an array (e.g., sor�ng the elements of an array), you need to rely
on pass-by-reference to work on the same copy inside and outside the func�on. Recall that in pass-by-value, the invoked func�on works on a clone copy and has no way to modify
the original copy.
Example (Array is passed by Reference): Increment Each Element of an Array

1 /* Function to increment each element of an array (IncrementArray.c) */
3
4 // Function prototypes
5 void inc(int array[], int size);
6 void print(int array[], int size);
7
8 // Test Driver
9 int main() {
10 int a1[] = {8, 4, 5, 3, 2};
11
12 // Before increment
13 print(a1, 5); // {8,4,5,3,2}
14 // Do increment
15 inc(a1, 5); // Array is passed by reference (having side effect)
16 // After increment
17 print(a1, 5); // {9,5,6,4,3}
18 }
19
20 // Function definitions
21
22 // Increment each element of the given array
23 void inc(int array[], int size) { // array[] is not const
24 int i;
25 for (i = 0; i < size; ++i) {
26 array[i]++; // side-effect
27 }
28 }
29
30 // Print the contents of the given array
31 void print(int array[], int size) {
32 int i;
33 printf("{");
34 for (i = 0; i < size; ++i) {
30 of 40 22/03/2020, 19:54
35 printf("%d", array[i]);
36 if (i < size - 1) {
37 printf(",");
38 }
39 }
40 printf("}\n");
41 }
Array is passed into func�on by reference. That is, the invoked func�on works on the same copy of the array as the caller. Hence, changes of array inside the func�on is reflected
outside the func�on (i.e., side effect).
Why Arrays are Pass-by-Reference?

Array is designed to be passed by reference, instead of by value using a cloned copy. This is because passing huge array by value is inefficient - the huge array needs to be cloned.
8.5 "const" Function Parameters

Pass-by-reference risks corrup�ng the original data. If you do not have the inten�on of modifying the arrays inside the func�on, you could use the const keyword in the func�on
parameter. A const func�on argument cannot be modified inside the func�on.
Use const whenever possible for passing references as it prevents you from inadvertently modifying the parameters and protects you against many programming errors.
Example: Search an Array using Linear Search

In a linear search, the search key is compared with each element of the array linearly. If there is a match, it returns the index of the array between [0, size-1]; otherwise, it returns
-1 or the size of of the array (some implementa�ons deal with only posi�ve indexes). Linear search has complexity of O(n).
1 /* Search an array for the given key using Linear Search (LinearSearch.c) */
3
4 int linearSearch(const int a[], int size, int key);
5
6 int main() {
7 const int SIZE = 8;
8 int a1[] = {8, 4, 5, 3, 2, 9, 4, 1};
9
10 printf("%d\n", linearSearch(a1, SIZE, 8)); // 0
11 printf("%d\n", linearSearch(a1, SIZE, 4)); // 1
12 printf("%d\n", linearSearch(a1, SIZE, 99)); // 8 (not found)
13 }
14
15 // Search the array for the given key
16 // If found, return array index [0, size-1]; otherwise, return size
17 int linearSearch(const int a[], int size, int key) {
18 int i;
19 for (i = 0; i < size; ++i) {
20 if (a[i] == key) return i;
21 }
22 return size;
23 }
Program Notes:
[TODO]
Example: Sorting an Array using Bubble Sort

Wiki "Bubble Sort" for the detailed algorithm and illustra�on. In brief, we pass thru the list, compare two adjacent items and swap them if they are in the wrong order. Repeat the
pass un�l no swaps are needed. For example,
{8,4,5,3,2,9,4,1}
PASS 1 ...
{8,4,5,3,2,9,4,1} => {4,8,5,3,2,9,4,1}
{4,8,5,3,2,9,4,1} => {4,5,8,3,2,9,4,1}
{4,5,8,3,2,9,4,1} => {4,5,3,8,2,9,4,1}
{4,5,3,8,2,9,4,1} => {4,5,3,2,8,9,4,1}
{4,5,3,2,8,9,4,1} => {4,5,3,2,8,4,9,1}
{4,5,3,2,8,4,9,1} => {4,5,3,2,8,4,1,9}
PASS 2 ...
{4,5,3,2,8,4,1,9} => {4,3,5,2,8,4,1,9}
{4,3,5,2,8,4,1,9} => {4,3,2,5,8,4,1,9}
{4,3,2,5,8,4,1,9} => {4,3,2,5,4,8,1,9}
{4,3,2,5,4,8,1,9} => {4,3,2,5,4,1,8,9}
PASS 3 ...
{4,3,2,5,4,1,8,9} => {3,4,2,5,4,1,8,9}
{3,4,2,5,4,1,8,9} => {3,2,4,5,4,1,8,9}
{3,2,4,5,4,1,8,9} => {3,2,4,4,5,1,8,9}
{3,2,4,4,5,1,8,9} => {3,2,4,4,1,5,8,9}
PASS 4 ...
{3,2,4,4,1,5,8,9} => {2,3,4,4,1,5,8,9}
{2,3,4,4,1,5,8,9} => {2,3,4,1,4,5,8,9}
PASS 5 ...
{2,3,4,1,4,5,8,9} => {2,3,1,4,4,5,8,9}
PASS 6 ...
{2,3,1,4,4,5,8,9} => {2,1,3,4,4,5,8,9}
PASS 7 ...
{2,1,3,4,4,5,8,9} => {1,2,3,4,4,5,8,9}
PASS 8 ...
31 of 40 22/03/2020, 19:54
{1,2,3,4,4,5,8,9}
Bubble sort is not efficient, with complexity of O(n2).
1 /* Sorting an array using Bubble Sort (BubbleSort.c) */

3
4 void bubbleSort(int a[], int size);
5 void print(const int a[], int size);
6
7 int main() {
9 int a[] = {8, 4, 5, 3, 2, 9, 4, 1};
10
11 print(a, SIZE);
12 printf("\n");
13 bubbleSort(a, SIZE);
14 print(a, SIZE);
15 printf("\n");
16 }
17
18 // Sort the given array of size
19 void bubbleSort(int a[], int size) {
20 int done = 0; // terminate if no more swap thru a pass
21 int pass = 0; // pass number, for tracing
22 int temp; // use for swapping
23
24 while (!done) {
25 printf("PASS %d...\n", ++pass); // for tracing
26 done = 1;
27 // Pass thru the list, compare adjacent items and swap
28 // them if they are in wrong order
29 int i;
30 for (i = 0; i < size - 1; ++i) {
31 if (a[i] > a[i+1]) {
32 print(a, size); // for tracing
33 temp = a[i];
34 a[i] = a[i+1];
35 a[i+1] = temp;
36 done = 0; // swap detected, one more pass
37 printf("=> "); // for tracing
38 print(a, size);
39 printf("\n");
40 }
41 }
42 }
43 }
44
45 // Print the contents of the given array of size
46 void print(const int a[], int size) {
47 int i;
48 printf("{");
49 for (i = 0; i < size; ++i) {
50 printf("%d", a[i]);
51 if (i < size - 1) printf(",");
52 }
53 printf("} ");
54 }
Program Notes:
[TODO]
Example: Sorting an Array using Insertion Sort

Wiki "Inser�on Sort" for the algorithm and illustra�on. In brief, pass thru the list. For each element, compare with all previous elements and insert it at the correct posi�on by
shi�ing the other elements. For example,
{8,4,5,3,2,9,4,1}
{8} {4,5,3,2,9,4,1}
{4,8} {5,3,2,9,4,1}
{4,5,8} {3,2,9,4,1}
{3,4,5,8} {2,9,4,1}
{2,3,4,5,8} {9,4,1}
{2,3,4,5,8,9} {4,1}
{2,3,4,4,5,8,9} {1}
{1,2,3,4,4,5,8,9}
Inser�on sort is also not efficient, with complexity of O(n2).
1 /* Sorting an array using Insertion Sort (InsertionSort.c) */

3
4 void insertionSort(int a[], int size);
5 void print(const int a[], int iMin, int iMax);
6
7 int main() {
32 of 40 22/03/2020, 19:54

9 int a[] = {8, 4, 5, 3, 2, 9, 4, 1};
10
11 print(a, 0, SIZE - 1);
12 printf("\n");
13 insertionSort(a, SIZE);
15 printf("\n");
16 }
17
18 // Sort the given array of size using insertion sort
19 void insertionSort(int a[], int size) {
20 int temp; // for shifting elements
21 int i, prev, shift;
22 for (i = 1; i < size; ++i) {
23 // for tracing
24 print(a, 0, i - 1); // already sorted
25 print(a, i, size - 1); // to be sorted
26 printf("\n");
27
28 // For element at i, insert into proper position in [0, i-1]
29 // which is already sorted.
30 // Shift down the other elements
31 for (prev = 0; prev < i; ++prev) {
32 if (a[i] < a[prev]) {
33 // insert a[i] at prev, shift the elements down
34 temp = a[i];
35 for (shift = i; shift > prev; --shift) {
36 a[shift] = a[shift-1];
37 }
38 a[prev] = temp;
39 break;
40 }
41 }
42 }
43 }
44
45 // Print the contents of the array in [iMin, iMax]
46 void print(const int a[], int iMin, int iMax) {
47 int i;
48 printf("{");
49 for (i = iMin; i <= iMax; ++i) {
50 printf("%d" ,a[i]);
51 if (i < iMax) printf(",");
52 }
53 printf("} ");
54 }
Program Notes:
[TODO]
Example: Sorting an Array using Selection Sort

Wiki "Selec�on Sort" for the algorithm and illustra�on. In brief, Pass thru the list. Select the smallest element and swap with the head of the list. For example,
{8,4,5,3,2,9,4,1}
{} {8,4,5,3,2,9,4,1} => {} {1,4,5,3,2,9,4,8}
{1} {4,5,3,2,9,4,8} => {1} {2,5,3,4,9,4,8}
{1,2} {5,3,4,9,4,8} => {1,2} {3,5,4,9,4,8}
{1,2,3} {5,4,9,4,8} => {1,2,3} {4,5,9,4,8}
{1,2,3,4} {5,9,4,8} => {1,2,3,4} {4,9,5,8}
{1,2,3,4,4} {9,5,8} => {1,2,3,4,4} {5,9,8}
{1,2,3,4,4,5} {9,8} => {1,2,3,4,4,5} {8,9}
{1,2,3,4,4,5,8,9}
Selec�on sort is also not efficient, with complexity of O(n2).
1 /* Sorting an array using Selection Sort (SelectionSort.c) */

3
4 void selectionSort(int a[], int size);
5 void print(const int a[], int iMin, int iMax);
6
7 int main() {
9 int a[] = {8, 4, 5, 3, 2, 9, 4, 1};
10
12 printf("\n");
13 selectionSort(a, SIZE);
15 printf("\n");
16 }
17
18 // Sort the given array of size using selection sort
19 void selectionSort(int a[], int size) {
33 of 40 22/03/2020, 19:54
20 int temp; // for swapping

21 int i, j;
22 for (i = 0; i < size - 1; ++i) {
23 // for tracing
24 print(a, 0, i - 1);
25 print(a, i, size - 1);
26
27 // [0, i-1] already sort
28 // Search for the smallest element in [i, size-1]
29 // and swap with a[i]
30 int minIndex = i; // assume fist element is the smallest
31 for (j = i + 1; j < size; ++j) {
32 if (a[j] < a[minIndex]) minIndex = j;
33 }
34 if (minIndex != i) { // swap
35 temp = a[i];
36 a[i] = a[minIndex];
37 a[minIndex] = temp;
38 }
39
40 // for tracing
41 printf("=> ");
42 print(a, 0, i - 1);
43 print(a, i, size - 1);
44 printf("\n");
45 }
46 }
47
48 // Print the contents of the array in [iMin, iMax]
49 void print(const int a[], int iMin, int iMax) {
50 int i;
51 printf("{");
52 for (i = iMin; i <= iMax; ++i) {
53 printf("%d", a[i]);
54 if (i < iMax) printf(",");
55 }
56 printf("} ");
57 }
Program Notes:
[TODO]
"const" Fundamental-Type Function Parameters?

You could also use const for fundamental-type func�on parameters (such as int, double) to prevent the parameters from being modified inside the func�on. However, as
fundamental-type parameters are passed by value (with a cloned copy), there will never be side effect on the caller. We typically do not use the const keyword for fundamental
types. In other words, const is used to indicate that there shall NOT be side-effect.
8.6 Mathematical Functions (Header <math.h>)

C provides many common-used Mathema�cal func�ons in library <math.h>. The signatures of some of these func�ons are:
sin(x), cos(x), tan(x), asin(x), acos(x), atan(x):

Take argument-type and return-type of float, double, long double.
atan2(y, x):
Return arc-tan of y/x. Better than atan(x) for handling 90 degree.
sinh(x), cosh(x), tanh(x):

hyper-trigonometric functions.
pow(x, y), sqrt(x):

power and square root.
ceil(x), floor(x):
returns the ceiling and floor integer of floating point number.
fabs(x), fmod(x, y):

floating-point absolute and modulus.
exp(x), log(x), log10(x):

exponent and logarithm functions.
8.7 Generating Random Numbers

The stdlib.h header provides a func�on rand(), which generates a pseudo-random integral number between 0 and RAND_MAX (inclusive). RAND_MAX is a constant defined
in stdlib.h (typically the maximum value of 16-/32-bit signed integer, such as 32767). You can generate a random number between [0,n) via rand() % n.
rand() generates the same squence of pseudo-random numbers on different invoca�ons. The stblib.h also provides a srand() func�on to seed or ini�alize the random
number generator. We typically seed it with the current �me obtained via time(0) func�on (in <time.h> header), which returns the number of seconds since January 1st,
1970.
Example 1: Test rand() and srand(time(0))

1 /* Test Random Number Generation (TestRand.c) */
34 of 40 22/03/2020, 19:54
3 #include <stdlib.h> // for rand(), srand()
4 #include <time.h> // for time()
5
6 int main() {
7 // rand() generate a random number in [0, RAND_MAX]
8 printf("RAND_MAX is %d\n", RAND_MAX); // 32767
9
10 // Generate 10 pseudo-random numbers between 0 and 99
11 // without seeding the generator.
12 // You will get the same sequence, every time you run this program
13 int i;
14 for (i = 0; i < 10; ++i) {
15 printf("%d ", rand() % 100); // need <stdlib.h> header
16 }
17 printf("\n");
18
19 // Seed the random number generator with current time
20 srand(time(0)); // need <cstdlib> and <ctime> header
21 // Generate 10 pseudo-random numbers
22 // You will get different sequence on different run,
23 // because the current time is different
24 for (i = 0; i < 10; ++i) {
25 printf("%d ", rand() % 100); // need <stdlib.h> header
26 }
27 printf("\n");
28 }
Example 2: Test rand()'s Distribution

We shall test the rand()'s distribu�on by repeatedly throwing a 6-sided die and count the occurrences.
1 /* Test rand() distribution by throwing a die repeatedly (TestRandomDie.c) */

3 #include <stdlib.h> // for rand(), srand()
4 #include <time.h> // for time()
5
6 const int TOTAL_COUNT = 2000000; // Close to INT_MAX
7 const int NUM_FACES = 6;
8 int frequencies[6] = {0}; // frequencies of 0 to 5, init to zero
9
10 int main() {
11 srand(time(0)); // seed random number generator with current time
12 // Throw the die and count the frequencies
13 int i;
14 for (i = 0; i < TOTAL_COUNT; ++i) {
15 ++frequencies[rand() % 6];
16 }
17
18 // Print statistics
19 for (i = 0; i < NUM_FACES; i++) {
20 printf("%d: %d (%.2lf%)\n", i+1, frequencies[i],
21 100.0 * frequencies[i] / TOTAL_COUNT);
22 }
23 }
1: 333109 (16.66%)
2: 333113 (16.66%)
3: 333181 (16.66%)
4: 333562 (16.68%)
5: 333601 (16.68%)
6: 333434 (16.67%)
As seen from the output, rand() is fairly uniformly-distributed over [0, RAND_MAX].
8.8 Exercises
[TODO]
9. Characters and Strings

A C-string is an array of characters terminated with a null character, denoted as '\0' which is equivalent to ASCII 0. For example,
char message[] = {'H', 'e', 'l', 'l', 'o', '\0'};

char message[] = "Hello"; // same as above
Clearly, the length of array is the length of string plus 1, to account for the termina�ng null character '\0'.
You can use scanf() to input a string, and printf() to print a string, with %s conversion specifier. For example,
2 #include <string.h>
3
4 int main() {
5 char message[256];
35 of 40 22/03/2020, 19:54
6 // The length of char array shall be sufficient to hold the string

7 // plus the terminating null character '\0'
8 printf("Enter a message: ");
9 scanf("%s", message);
10 // Do not place an & before the array variable
11 printf("The message is: %s\n", message);
12 // Print up to but not including the terminating null character '\0'
13
14 // print each characters
15 int i;
16 for (i = 0; message[i] != '\0'; ++i) {
17 printf("'%c' ", message[i]);
18 }
19 printf("\n");
20
21 int len = strlen(message);
22 // Length of string does not include terminating null character '\0'
23 printf("The length of string is %d\n", len);
24 }
Enter a message: hello

The message is: hello
'h' 'e' 'l' 'l' 'o'
The length of string is 5
Take note that you need to allocate a char array that is big enough to hold the input string including the termina�ng null character '\0'.
9.1 Character Type and Conversion in <ctype.h> Header

Function Description
int isalpha(int c); [a-zA-Z] Check the character's type and return true (non-zero) or false (0)
int isdigit(int c); [0-9]
int isalnum(int c); [a-zA-Z0-9]
int isxdigit(int c); [0-9A-Fa-f]
int isspace(int c); [ \t\n]
int iscntrl(int c); Control character
int ispunct(int c); Punctua�on character
int isprint(int c); Printable character
int isgraph(int c); Graphical character
int isupper(int c); [A-Z] Check if uppercase/lowercase and return true (non-zero) or false (0)
int islower(int c); [a-z]
int toupper(int c); To Uppercase Return the uppercase/lowercase character, if c is a lowercase/uppercase character; otherwise, return c.
int tolower(int c); To Lowercase
Example: [TODO]
9.2 String/Number Conversion in <stdlib.h> Header

The stdlib.h contains func�on prototypes for conversion between string and numbers.
int atoi(const char * str); String to int Convert the str to
double atof(const char * str); String to double int/double/long/long long.
long atol(const char * str); String to long
long long atoll(const char * str); String to long long
double strtod(const char* str, char** endptr); String to double Convert the str to double/float.
float strtof(const char* str, char** endptr); String to float If endptr is not a null pointer,
it will be set to point to the first character a�er the
number.
long strtol(const char* str, char** endptr, int base); String to long Convert the str to long/unsigned long.
unsigned long strtoul(const char* str, char** endptr, int String to unsigned
base); long
Example: [TODO]
9.3 String Manipulation in <string.h> Header

char* strcpy(char* dest, const char* src); String copy Copy src into dest.
char* strncpy(char* dest, const char* src, size_t n); String copy at most n-chars Return dest.
char* strcat(char* dest, const char* src); String concatena�on Concatenate src into dest.
char* strncat(char* dest, const char* src, size_t n); String concatena�on at most n-char Return dest.
int strcmp(const char* s1, const char* s2); String compare Comparing s1 and s2.
int strncmp(const char* s1, const char* s2, size_t n); String compare at most n-char Return 0, less than 0, more than 0
if s1 is the same, less than, more than s2.
36 of 40 22/03/2020, 19:54
int strlen(const char* str); String Length Return the length of str
(excluding termina�ng null char)
char* strchr(const char* str, int c); Search string for char Return a pointer to the first/last occurrence
char* strrchr(const char* str, int c); Search string for char reverse of c in str
if present. Otherwise, return NULL.
char* strpbrk(const char* str, const char* pattern); Search string for char in pa�ern Locate the first occurrence in str
of any character in pattern.
char* strstr(const char* str, const char* substr); Search string for sub-string Return a pointer to the first occurrence
of substr in str
if present. Otherwise, return NULL.
char* strspn(const char* str, const char* substr); Search string for span of substr
char* strcspn(const char* str, const char* substr); Search string for complement span of substr
char* strtok(char* str, char *delimit); Split string into tokens
void* memcpy(void *dest, const void *src, size_t n); Memory block copy
void* memmove(void *dest, const void *src, size_t n); Memory block move
int memcmp(const void *p1, const void *p2, size_t n); Memory block compare
void* memchr(void *ptr, int value, size_t n); Search memory block for char
void* memset(void *ptr, int value, size_t n); Memory block set (fill)
Example: [TODO]
9.4 char/string IO in <stdio.h> Header

int getchar(); Get character (from stdin) Input/Output a character
int putchar(int c); Put character (to stdout) from stdin/stdout.
int getc(FILE *stream); Get character (from FILE stream) Input/Output a character
int putc(int c, FILE *stream); Put character (to FILE stream) from FILE stream.
int ungetc(int c, FILE *stream); Un-get character (to FILE stream)
char* gets(char *str); Get string (from stdin) Input/Output string

int puts(const char* str); Put string (to stdout) from stdin/stdout.
int sprintf(char *str, const char *format, ...); Forma�ed print (to string) Forma�ed string input/output.
int sscanf(char *str, const char *format, ....); Forma�ed scan (from string) Similar to printf() and scanf(),
except that the output/input comes from the str.
Example: [TODO]
10. File Input/Output

[TODO]
10.1 File IO in <stdio.h> Header

FILE* fopen(const char* filename, const char* mode); File open Open/Close a file.
int fclose(FILE *stream); File close
FILE* freopen(const char* filename, const char* mode, FILE
*stream);
int fprintf(FILE *stream, const char *format, ...); Forma�ed print to file Forma�ed file input/output.
int fscanf(FILE *stream, const char *format, ...); Forma�ed scan from Similar to printf()/scanf(),
file except that the input/output comes from file
int fgetc(FILE *stream) Get character from file Unforma�ed character/string input/output from
int fputc(int c, FILE *stream); Put character to file file
char* fgets(char *str, size_t n, FILE *stream); Get string from file
int fputs(const char *str, FILE *stream); Put string to file
size_t fread(void *ptr size_t size, size_t count, FILE *stream) File read Direct Access
size_t fwrite(const void *ptr, size_t size, size_t count, FILE File write
*stream); Get file posi�on
int fgetpos(FILE *stream, fpos_t *pos); Set file posi�on
int fsetpos(FILE *stream, const fpos_t *pos); File seek
Tell file
int fseek(FILE *stream, long offset, int origin);
long ftell(FILE *stream);
void rewind(FILE *stream); Rewind file Set the file posi�on to the beginning
int fflush(FILE *stream); File Flush
int feof(FILE *stream); Test end-of-file

int ferror(FILE *stream); Check file error
void perror(const char *str); Print error message
Open/Close File
37 of 40 22/03/2020, 19:54
To open a file, use fopen(filename, mode). The modes are:
Mode Description
"r" Read Open file for reading. The file shall exist.
"w" Write Open file for wri�ng. If the file does not exist, create a new file; otherwise, discard exis�ng contents.
"a" Append Open file for wri�ng. If the file does not exist, create a new file; otherwise, append to the exis�ng file.
"r+" Read/Write Open file for reading/wri�ng. The file shall exist.
"w+" Read/Write Open file for reading/wri�ng. If the file does not exist, create a new file; otherwise, discard exis�ng contents.
"a+" Read/Append Open file for reading/wri�ng. If the file does not exist, create a new file; otherwise, append to the exis�ng file.
"rb" "wb" "ab" "rb+" "wb+" "ab+" For binary files.
File Stream
You can use stdin, stdout, stderr to denote standard input stream (keyboard), standard output stream (console) and standard error stream (console).
10.2 Sequential-Access File
Example 1: Formatted File Input/Output

1 /* Test File IO (TestFileIO.c) */
3
4 int main() {
5 FILE *fin, *fout;
6
7 fout = fopen("test.txt", "w");
8 fprintf(fout, "%d %lf %s\n", 123, 44.55, "Hello");
9 fclose(fout);
10
11 fin = fopen("test.txt", "r");
12 int i;
13 double d;
14 char msg[80];
15 fscanf(fin, "%d %lf %s", &i, &d, msg);
16 printf("i is %d\n", i);
17 printf("d is %lf\n", d);
18 printf("msg is %s\n", msg);
19 fclose(fin);
20 }
Example 2
2 #define SIZE 80 // size of string buffer
3
4 int main() {
5 FILE * pFile;
6 char buffer[SIZE];
7
8 pFile = fopen("test.txt" , "r");
9 if (pFile == NULL) {
10 perror("Error opening file");
11 } else {
12 while (!feof(pFile)) {
13 if (fgets(buffer, SIZE, pFile) == NULL) break;
14 fputs (buffer , stdout);
15 }
16 fclose(pFile);
17 }
18 return 0;
19 }
10.3 Direct-Access File IO

[TODO]
11. Pointers and Dynamic Allocation

[TODO]
11.1 Array and Pointer

[TODO]
11.2 String as char pointer

In C, an array name is equivalent to a pointer poin�ng to the first element of the array. For example, if msg is a char array (char msg[256]), then msg is &msg[0].
We can declare and ini�alize a string via char pointer; and operate the string via char pointer.
38 of 40 22/03/2020, 19:54
2
3 int main() {
4 char *msg = "hello"; // Append a terminating null character '\0'
5 char *p;
6
7 for (p = msg; *p != '\0'; ++p) {
8 printf("'%c' ", *p);
9 }
10 printf("\n");
11 }
[TODO]
12. struct, union and enum

[TODO]
13. Miscellaneous
13.1 Bit Operations

[TODO]
13.2 C Library Headers

<stdio.h>: contains func�on prototypes for standard input/output func�ons such as printf() and scanf().
<stdlib.h>: contains func�on prototypes for conversion between numbers and texts (e.g., atoi(), atof(), strtod()); memory alloca�on (malloc(), free());
random number generator (rand(), srand()); system u�li�es (exit(), abort()).
<math.h>: contains func�on prototypes for mathema�cal func�ons (e.g., pow(), sqrt()).
<ctype.h>: (character type) contains func�on prototypes for tes�ng character proper�es (isupper(), isalpha(), isspace()) and case conversion (toupper(),
tolower()).
<limits.h>, <float.h>: contains integer and float size and limits.

<string.h>: contains func�on prototypes for string processing func�ons (e.g., strcpy(), strcat(), strcmp()).
<time.h>: contains func�on prototypes for date and �me func�ons (e.g., time()).
<assert.h>: for asser�on (to aid in diagnos�cs).
<errno.h>: for error repor�ng.
<signal.h>: for raising and handling signals.
<stdarg.h>: for handling variable argument.
<stddef.h>: contains common type defini�on such as size_t.
<locale.h>:
<setjmp.h>:
13.3 Keywords
ISO C90 (ANSI C 89) has 32 keywords:
Type: int, double, long, char, float, short, unsigned, signed, typedef, sizeof (10).
Control: if, else, switch, case, break, default, for, do, while, continue, goto (11).
Func�on: return, void (2)
Data Structure: struct, enum, union (3)
Memory: auto, register, extern, const, volatile, static (6).
ISO C99 adds 5 keywords, total of 37:

_Bool, _Complex, _Imaginary, inline, restrict (5).
ISO C11 adds 7 more keywords, total of 44:

_Alignas, _Alignof, _Atomic, _Generic, _Noreturn, _Static_assert, _Thread_local (7).
Link to "C References and Resources"
Latest version tested: Cygwin/MInGW GCC g++ 4.6.2

Last modified: June, 2013
39 of 40 22/03/2020, 19:54
Feedback, comments, corrections, and errata can be sent to Chua Hock-Chuan (ehchua@ntu.edu.sg) | HOME
40 of 40 22/03/2020, 19:54

Basics of C

Uploaded by

Copyright:

Available Formats

Basics of C

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Basics of C

Uploaded by

Copyright:

Available Formats

C Basics - C Programming Tutorial https://www3.ntu.edu.sg/home/ehchua/programming/cpp/c1_Basics.

yet another insignificant programming notes... | HOME

TABLE OF CONTENTS (HIDE)

C Programming Language 2. Basic Syntaxes

Basics 2.3 Statements and Blocks

Enter the upperbound: 1000

There are two kinds of comments in C:

2.3 Statements and Blocks

2.4 White Spaces and Formatting Source Codes

int sum=0; // Need a white space between int and sum

int mark = 70;

2.5 Preprocessor Directives

#include <stdio.h> // To include the IO library header

More on preprocessor direc�ves later.

3. Variables and Types

digits (0-9), and underscore "_".

Variable Naming Convention

3.3 Variable Declaration

// Declare a variable of a specified type

int mark1; // Declare an int variable called mark1

Take note that:

CAUTION: Uninitialized Variables

3.4 Constants (const)

const double PI = 3.1415926; // Need to initialize

int sum, number;

double principal, interestRate;

3.6 Assignment (=)

The syntax for assignment statement is:

number = 8; // Assign literal value of 8 to the variable number

3.7 Fundamental Types

Bytes Minimum Maximum

Bytes Minimum Maximum

*The sizeof Operator

The results may vary among diﬀerent systems.

1 /* Test integer limits in <limits.h> header */

int max = 2147483647

Again, the outputs depend on the system.

There is a subtle diﬀerence between int 0 and double 0.0.

*The typedef Statement

typedef unsigned int uint;

typedef unsigned int size_t;

3.8 Output via printf() Function

Formatted Output via printf()

printf(formattingString, variable1, variable2, ...)

Hello, number1 is 12345.

Type Conversion Code

Type Type Conversion Code Type & Format

int anInt = 12345;

printf("The int is %d.\n", anInt);

printf("The int (in hex) is %x.\n", anInt);

Using the wrong type conversion code usually produces garbage.

int number = 123456;

Precision (Decimal Places) for Floating-point Numbers

double value = 123.14159265;

int i1 = 12345, i2 = 678;

char msg[] = "Hello";

3.9 Input via scanf() Function

11 printf("Enter an int: "); // Prompting message

Return-Value for scanf()