INS2020 – C Programming

DAY 1
 SYLLABUS

INS2020 - C Programming 06/03/2024 2

 ASSESMENT

INS2020 - C Programming 06/03/2024 3

 HISTORY OF C
1960: ALGOL (ALGORITHMIC LANGUAGE)
1967: BCPL (BASIC COMBINED
PROGRAMMING LANGUAGE)
1970: B PROGRAMMING LANGUAGE
(TYPELESS)
Later Languages
• 1979 C++ by Bjarn Stroustrup also at Bell
1972: C: BCPL PLUS B WITH TYPES
• Object orientation
1978: KERNIGHAN + RITCHIE STANDARD
FOR C • 1991 Java by Sun
• Partial compile to java bytecode: virtual machine code
1989: ANSI STANDARD FOR C
• Write once, run anywhere
• Memory manager – garbage collection
• Many JVMs written in C / C++
 LATER LANGUAGES

• 1979 C++ by Bjarn Stroustrup also at Bell

• Object orientation

• 1991 Java by Sun

• Partial compile to java bytecode: virtual machine code
• Write once, run anywhere
• Memory manager – garbage collection
• Many JVMs written in C / C++
 INTRODUCTION TO C
#include <stdio.h>
int main () {
printf(“Welcome to C programming”);
return 0;
}
 WHAT YOU NEED TO WRITE C PROGRAMS

• C complier: takes the C program you write and builds or compiles it

• Many free software packages are available: Dev-C++, Code::Block, …

7
 OUTLINE
Program Basics
A. PROGRAM SKELETON D. Variable declarations F. Formatted input/output
PREPROCESSOR DIRECTIVES 1. Memory allocation 1. Files
GLOBAL DECLARATIONS 2. printf (monitor output)
2. Atomic types
FUNCTIONS a. format strings
LOCAL DECLARATIONS void, int, float, char field specifications
STATEMENTS E. Constants b. data list
B. COMMENTS AND 3. scanf (keyboard input)
1. literal
DOCUMENTATION a. format strings
C. NAMES (IDENTIFIERS) 2. defined b. address list

RESERVED WORDS 3. memory 4. Prompting for Input

 C PROGRAM PHASES
• Editor - code by programmer
• Compiling using gcc:
• Preprocess – expand the programmer’s code
• Compiler – create machine code for each file
• Linker – links with libraries and all compiled objects to make executable

• Running the executable:

• Loader – puts the program in memory to run it
• CPU – runs the program instructions
 C PROGRAM
STRUCTURE

Preprocessor Directives • May contain

Global Declarations
preprocessor directives
• Program defined by:
Function Definitions
• global declarations
int main () {
• function definitions
Local Declarations
• Always has one
Statements
function named main,
} may contain others
Preprocessor Directives

Global Declarations PARTS OF

Function Definitions
A PROGRAM
int main () {
#include <stdio.h> Preprocessor Directive
Local Declarations

int x; Global Declaration

Statements

int main () {
}
int y; Local Declaration
Function printf("Enter x and y: ");
scanf(&x,&y); Statements
printf("Sum is %d\n",x+y);
}
 PREPROCESS #include <stdio.h> Preprocessor Directive

OR int x; Global Declaration

DIRECTIVES int main () {

int y; Local Declaration
Function printf("Enter x and y: ");
scanf(&x,&y); Statements
printf("Sum is %d\n",x+y);
}
• BEGIN WITH #
• INSTRUCT COMPILER TO PERFORM SOME TRANSFORMATION TO FILE BEFORE
COMPILING
• EXAMPLE: #INCLUDE <STDIO.H>
• ADD THE HEADER FILE STDIO.H TO THIS FILE
• .H FOR HEADER FILE
• STDIO.H DEFINES USEFUL INPUT/OUTPUT FUNCTIONS
 #include <stdio.h> Preprocessor Directive
DECLARATIO int x; Global Declaration
NS int main () {
int y; Local Declaration
Function printf("Enter x and y: ");
• GLOBAL scanf(&x,&y); Statements
• VISIBLE THROUGHOUT PROGRAM (EG: X) printf("Sum is %d\n",x+y);
}
• DESCRIBES DATA USED THROUGHOUT
PROGRAM Preprocessor Directives

• LOCAL Global Declarations

• VISIBLE WITHIN FUNCTION (EG: Y IN THE Function Definitions

MAIN) int main () {

• DESCRIBES DATA USED ONLY IN FUNCTION Local Declarations

Statements

}
 #include <stdio.h> Preprocessor Directive
FUNCTIONS int x; Global Declaration

int main () {
• CONSISTS OF HEADER AND BODY int y; Local Declaration
• HEADER: INT MAIN () Function printf("Enter x and y: ");
• BODY: CONTAINED BETWEEN { AND } scanf(&x,&y); Statements
• STARTS WITH LOCATION printf("Sum is %d\n",x+y);
}
DECLARATIONS
• FOLLOWED BY SERIES OF STATEMENTS
Preprocessor Directives
• MORE THAN ONE FUNCTION MAY BE
DEFINED Global Declarations

• STATEMENTS ENDS WITH ; Function Definitions

int main () {
• FUNCTIONS ARE CALLED (INVOKED) Local Declarations

Statements

}
 main FUNCTION

• EVERY PROGRAM HAS ONE FUNCTION MAIN

• HEADER FOR MAIN: INT MAIN ()
• PROGRAM IS THE SEQUENCE OF STATEMENTS BETWEEN THE { } FOLLOWING
MAIN
• STATEMENTS ARE EXECUTED ONE AT A TIME FROM THE ONE IMMEDIATELY
FOLLOWING TO MAIN TO THE ONE BEFORE THE }
 COMMENTS
• TEXT BETWEEN /* AND */
• USED TO “DOCUMENT” THE CODE
FOR THE HUMAN READER
• IGNORED BY COMPILER (NOT
PART OF PROGRAM)
• HAVE TO BE CAREFUL
• COMMENTS MAY COVER
MULTIPLE LINES
• ENDS AS SOON AS */
ENCOUNTERED (SO NO
INTERNAL COMMENTS - /* AN /*
INTERNAL */ COMMENT */)
#include <stdio.h>
/* This comment covers
* multiple lines
* in the program.
*/
int main () /* The main header */
{
/* No local declarations */
printf(“Too many comments\n”);
return 0;
} /* end of main */
 DOCUMENTATION

• GLOBAL - START OF PROGRAM, OUTLINES OVERALL

SOLUTION, MAY INCLUDE STRUCTURE CHART
• MODULE - WHEN USING SEPARATE FILES, INDICATION OF
WHAT EACH FILE SOLVES
• FUNCTION - INPUTS, RETURN VALUES, AND LOGIC USED IN
DEFINING FUNCTION
• ADD DOCUMENTATION FOR KEY (TOUGH TO UNDERSTAND)
COMMENTS
• NAMES OF VARIABLES - SHOULD BE CHOSEN TO BE
MEANINGFUL, MAKE PROGRAM READABLE
 IDENTIFIER

• NAMES USED FOR OBJECTS IN C

• RULES FOR IDENTIFIERS IN C:
• FIRST CHAR ALPHABETIC [A-Z,A-Z] OR
UNDERSCORE ( _ )
• HAS ONLY ALPHABETIC, DIGIT, UNDERSCORE Valid Invalid
CHARS sum 7of9
• FIRST 31 CHARACTERS ARE SIGNIFICANT c4_5 x-name
• CANNOT DUPLICATE A RESERVED WORD
A_NUMBER name with spaces
• CASE (UPPER/LOWER) MATTERS
longnamewithmanychars 1234a
TRUE int
_split_name AXYZ&
 RESERVED WORDS

• IDENTIFIERS THAT ALREADY HAVE MEANING IN C

+) 32 keywords in C.
+) used to define control structures, data types, function
declarations, and other fundamental elements of C
programming
+ Variable’s name cannot duplicate a reserved word
 PROGRAM EXECUTION

• GLOBAL DECLARATIONS SET UP

• FUNCTION MAIN EXECUTED
• LOCAL DECLARATIONS SET UP
• EACH STATEMENT IN STATEMENT SECTION EXECUTED
• EXECUTED IN ORDER (FIRST TO LAST)
• CHANGES MADE BY ONE STATEMENT AFFECT LATER STATEMENTS
 VARIABLES

• NAMED MEMORY LOCATION

• VARIABLES DECLARED IN GLOBAL OR LOCAL DECLARATION SECTIONS
• SYNTAX: TYPE NAME;
• EXAMPLES:
INT SUM;
FLOAT AVG;
CHAR DUMMY;
 DATA TYPES

• ATOMIC TYPES (CANNOT BE BROKEN DOWN)

• VOID
• CHAR
• INT
• FLOAT, DOUBLE

• DERIVED TYPES
• COMPOSED OF OTHER TYPES
 Size Format
Data Type Range
(bytes) Specifier
short int 2 -32,768 to 32,767 %hd
unsigned short int
unsigned int
2
4
0 to 65,535
0 to 4,294,967,295
%hu
%u
TYPE
• SET OF POSSIBLE VALUES
int 4 -2,147,483,648 to 2,147,483,647 %d
• DEFINES SIZE, HOW VALUES
long int 4 -2,147,483,648 to 2,147,483,647 %ld STORED, INTERPRETED

unsigned long int 4 0 to 4,294,967,295 %lu • OPERATIONS THAT CAN BE

long long int 8 -(2^63) to (2^63)-1 %lld PERFORMED ON THOSE
POSSIBLE VALUES
unsigned long long
8 0 to 18,446,744,073,709,551,615 %llu
int • DATA TYPES ARE ASSOCIATED
signed char 1 -128 to 127 %c WITH OBJECTS IN C
unsigned char 1 0 to 255 %c (VARIABLES, FUNCTIONS, ETC.)
float 4 1.2E-38 to 3.4E+38 %f
double 8 1.7E-308 to 1.7E+308 %lf
long double 16 3.4E-4932 to 1.1E+4932 %Lf
 CHARACTER TYPE

• TYPE NAME: CHAR

• POSSIBLE VALUES: KEYS THAT CAN BE TYPED AT THE KEYBOARD
• REPRESENTATION: EACH CHARACTER ASSIGNED A VALUE (ASCII VALUES), 8 BITS
• A - BINARY NUMBER 65
• A - BINARY NUMBER 97
• B - BINARY NUMBER 98
• 2 - BINARY NUMBER 50
 CHARACTER LITERALS

• SINGLE KEY STROKE BETWEEN QUOTE CHAR ‘

• EXAMPLES: ‘A’, ‘A’, ‘B’, ‘1’, ‘@’
• SOME SPECIAL CHARS:
• ‘\0’ - NULL CHAR
• ‘\T’ - TAB CHAR
• ‘\N’ - NEWLINE CHAR
• ‘\’’ - SINGLE QUOTE CHAR
• ‘\\’ - BACKSLASH CHAR
 STRING LITERALS

• NO STRING TYPE:
• UNLIKE MANY OTHER PROGRAMMING LANGUAGES, C DOES NOT HAVE A STRING TYPE TO CREATE
STRING VARIABLES;
• MUST USE THE CHAR TYPE AND CREATE AN ARRAY OF CHARACTERS TO MAKE
#include A STRING IN C:
<stdio.h>
• CONTAINED BETWEEN DOUBLE QUOTE CHARS (“)
int main() {
• EXAMPLES:
char greetings[ ] = "Hello World!";
“” - NULL STRING
“A STRING” printf("%s", greetings);
“STRING WITH NEWLINE \N CHAR IN IT”
return 0;
“STRING WITH A DOUBLE QUOTE \” IN IT” }
 LITERAL CONSTANTS

• SEQUENCES OF CHARACTERS (TOKENS) THAT CORRESPOND TO VALUES FROM

THAT TYPE
-35 IS THE INTEGER -35
3.14159 IS THE FLOATING POINT NUMBER 3.14159
‘A’ IS THE CHARACTER A

• CAN BE USED TO INITIALIZE VARIABLES

 LIMITATION

• WITH A FIXED NUMBER OF BITS, ONLY A CERTAIN NUMBER OF POSSIBLE

PATTERNS
• TAKE INT AS AN EXAMPLE:
• 16 BITS, 65,536 POSSIBLE PATTERNS
• 32768 NEGATIVE NUMBERS
• 1 ZERO
• 32767 POSITIVE NUMBERS

• OVERFLOW: ATTEMPT TO STORE A VALUE TO LARGE IN A VARIABLE (32768 IN

INT)
 CONSTANTS

• LITERAL CONSTANTS - TOKENS REPRESENTING VALUES FROM TYPE

• DEFINED CONSTANTS
• SYNTAX: #DEFINE NAME VALUE
• PREPROCESSOR COMMAND, NAME REPLACED BY VALUE IN PROGRAM
• EXAMPLE: #DEFINE MAX_NUMBER 100
 FORMATTED INPUT/OUTPUT

• INPUT COMES FROM FILES

• OUTPUT SENT TO FILES
• OTHER OBJECTS TREATED LIKE FILES:
• KEYBOARD - STANDARD INPUT FILE (STDIN)
• MONITOR - STANDARD OUTPUT FILE (STDOUT)

• GENERALLY SEND/RETRIEVE CHARACTERS TO/FROM FILES

 FORMATTED OUTPUT

• COMMAND: PRINTF - PRINT FORMATTED

• SYNTAX: PRINTF(FORMAT STRING, DATA LIST);
• FORMAT STRING ANY LEGAL STRING
• CHARACTERS SENT (IN ORDER) TO SCREEN
• EX.: PRINTF(“WELCOME TO\NC PROGRAMMING!\N”);
CAUSES
WELCOME TO
C PROGRAMMING!
TO APPEAR ON MONITOR
 FIELD SPECIFICATIONS

• FORMAT STRING MAY CONTAIN ONE OR MORE FIELD SPECIFICATIONS

• SYNTAX: %[FLAG][WIDTH][PREC][SIZE]CODE
• CODES:
• C - DATA PRINTED AS CHARACTER
• D - DATA PRINTED AS INTEGER
• F - DATA PRINTED AS FLOATING-POINT VALUE
• FOR EACH FIELD SPECIFICATION, HAVE ONE DATA VALUE AFTER FORMAT STRING,
SEPARATED BY COMMAS
 FIELD SPECIFICATION EXAMPLE

PRINTF(“%C %D %F\N”,’A’,35,4.5);
PRODUCES
A 35 4.50000
(VARIES ON DIFFERENT COMPUTERS)

CAN HAVE VARIABLES IN PLACE OF LITERAL CONSTANTS (VALUE OF VARIABLE

PRINTED)
 PRINTF NOTES

• IMPORTANT TO HAVE ONE VALUE FOR EACH FIELD SPECIFICATION

• SOME C VERSIONS ALLOW YOU TO GIVE TOO FEW VALUES (GARBAGE VALUES ARE
FORMATTED AND PRINTED)

• VALUES CONVERTED TO PROPER TYPE

• PRINTF(“%C”,97); PRODUCES THE CHARACTER A ON THE SCREEN

MORE LATER!
 FORMATTED INPUT

• COMMAND: SCANF - SCAN FORMATTED

• SYNTAX: SCANF(FORMAT STRING, ADDRESS LIST);
• FORMAT STRING A STRING WITH ONE OR MORE FIELD SPECIFICATIONS
• CHARACTERS READ FROM KEYBOARD, STORED IN VARIABLES

• SCANF(“%C %D %F”, &CVAR, &DVAR, &FVAR);

ATTEMPTS TO READ FIRST A SINGLE CHARACTER, THEN A WHOLE NUMBER, THEN A
FLOATING POINT NUMBER FROM THE KEYBOARD
 ADDRESS OPERATOR

• & - ADDRESS OPERATOR

• PUT BEFORE A VARIABLE (AS IN &CVAR)
• TELLS THE COMPUTER TO STORE THE VALUE READ AT THE LOCATION OF THE
VARIABLE
• MORE LATER!!!
 SCANF RULES

• CONVERSION PROCESS CONTINUES UNTIL

• END OF FILE REACHED
• MAXIMUM NUMBER OF CHARACTERS PROCESSED
• NON-NUMBER CHAR FOUND NUMBER PROCESSED
• AN ERROR IS DETECTED (INAPPROPRIATE CHAR)
• FIELD SPECIFICATION FOR EACH VARIABLE
• VARIABLE ADDRESS FOR EACH FIELD SPEC.
• ANY CHARACTER OTHER THAN WHITESPACE MUST BE MATCHED EXACTLY
 SCANF EXAMPLE

SCANF(“%D%C %F”,&X,&C,&Y);
AND FOLLOWING IS TYPED IN:
-543A 4.056 56

-543 STORED IN X, A STORED IN C, 4.056 STORED IN Y, SPACE AND 56 STILL WAITING

(FOR NEXT SCANF)
 PROMPTING FOR INPUT

• USING OUTPUT STATEMENTS TO INFORM THE USER WHAT INFORMATION IS

NEEDED:
PRINTF(“ENTER AN INTEGER: “);
SCANF(“%D”,&INTTOREAD);

• OUTPUT STATEMENT PROVIDES A CUE TO THE USER:

ENTER AN INTEGER: USER TYPES HERE
End Of Introduction To C

40