Computer Programming I
C Programming
Lecture 1 – Introduction
2022 Spring, CSE2003/AIE2050
Sogang University
CSE2003/AIE2050 S'23 1
Team
• Instructor
• Prof. Joo Ho Lee (AS818, jhleecs@sogang.ac.kr)
• Teaching assistants (Class I)
• Lee, Soo-hyun (이수현), khtt1222@gmail.com
• Woo, Sun-gwon (우성원), scottwoo1122@gmail.com
• Yeen, Hueui-yeen (연희연), yeen214@gmail.com
CSE2003/AIE2050 S'23 2
Team
• Instructor
• Prof. Joo Ho Lee (AS818, jhleecs@sogang.ac.kr)
• Teaching assistants (Class II)
• Yoon, Jun (윤준영), jjun9288@gmail.com
• Her, Seunghoi (허승회), seunghoi0722@gmail.com
• Lee, Do-hun (이도훈), dlehgns1998@gmail.com
CSE2003/AIE2050 S'23 3
Organization
• 3 Credits
• Lectures held in Dasan Hall
• Class I: D105, Tuesday and Thursday 13:30-14:45
• Class II: D105, Tuesday and Thursday 15:00-16:15
• Exam
• Date and time will be announced on the cyber campus.
• Relevant to programming assignments and pen & paper assignments.
CSE2003/AIE2050 S'23 4
Exercise & Programming Assignments
• We offer MANY programming assignments during semester
• A programming assignment every week
• 10~12 programming assignments + some pen & paper assignments
• Handed out via Cyber Campus.
• Assignments are not graded, but we will give support and solutions.
• They are highly relevant to the exam.
CSE2003/AIE2050 S'23 5
Grading
• Exam (95 %)
• Midterm & final exams (45% and 50%, individually)
• Homework (0%)
• Programming and pen & paper assignments
• Relevant to exams
• Attendance (5%)
• Your attitude and attendance.
CSE2003/AIE2050 S'23 6
Cheating
• Penalty for cheating:
• Removal form course with failing grade (no exceptions)
• Permanent mark on your record
• Your instructors’ personal contempt
• Exam modality
• Offline, the place would be announced one week before.
CSE2003/AIE2050 S'23 7
References
• Essential C, Stanford C Materials
http://cslibrary.stanford.edu/101/EssentialC.pdf
• GoalKicker’s free C Porgramming Notes
https://goalkicker.com/CBook/
• (Korean) 열혈프로그래밍 C, 윤성우 저, Orange Media
• Don’t need to buy it unless you need
CSE2003/AIE2050 S'23 8
Definition of Word “Computer” before 1900
• Timelines
• Fibonacci (1200), Descartes (1620), Fermat (1630), Pascal (1650), Newton (1680),
Leibniz (1680), Euler (1750), Industrial Revolution (1760~1820), Gauss (1800),
Germain (1810), Galoise (1830)
• Computer (JOB): A person who completes mathematical calculations
• sitting, hour after hour, performing calculations by hand and recording them
in books: very painful job
• Significant role for navigation, science, engineering, and mathematics
• Slow and inaccurate due to human error
CSE2003/AIE2050 S'23 9
Pascaline: Pascal Calculator (1642)
• Mechanically operated
• One arithmetic operator can be computed
Pascal Calculator (1642) CSE2003/AIE2050 S'23 Leibniz Calculator (1670) 10
Difference Engine - Automating Computations (1822)
• Babbage wanted to build an
automated machine that replace
the “mental labor” which is math
calculation.
• Invented the “difference engine”
that calculates polynomial
Difference engine
functions mechanically in 1822.
CSE2003/AIE2050 S'23 11
Jacquard Machine (1804)
• A weaving machine that automates the patterning
• A programmable device
A series of punched card represents the Jacquard machine
pattern CSE2003/AIE2050 S'23 12
Babbage - Analytic Machine (1833)
• Propose the basic structure of computers (memory and CPU)
• CPU: perform a given instruction like variable load, store and arithmetic
operation.
• Memory: A space to store the result of the CPU
• Inspired by Jacquard machine
Computer
Programming code in 1833
const. 1 variable indices Instruction 1 load variables
const. 2 variable indices Instruction 2 Input
const. 3 variable indices Instruction 3
CPU Memory
const. 4 variable indices Instruction 4
. . . store results
. . .
Abstract CSE2003/AIE2050
overview of “Analytic
S'23
machine” 13
How computer works?
Result Buffer
Program
load 3 to the result buffer
Counter
store the result buffer to variable 0
CPU
load 4 to the result buffer
store the result buffer to variable 1
slot1 slot2
load variable 0 to CPU slot 0
load variable 1 to CPU slot 1
addition
Memory
store the result buffer to variable 0
Variable 0
instruction, variable, constant
Variable 1
Instruction series (program)
CSE2003/AIE2050 S'23 14
Programming
• Composing a series of instructions executable by a programmable
machine in order to perform a desirable computation task
• Programming language
• A notation about data and computation instruction steps
• A representation of algorithm, a computational method to solve the problem
CSE2003/AIE2050 S'23 15
C Programming Language
• High-level but low-level programming language
• Relatively lower than Python programming language
• Lower programming languages,
• Less interpretation needed
Human-intuitive
• More required details of computers
• Faster code (usually)
Machine-executable
CSE2003/AIE2050 S'23 16
Computer & Program
• Making a program → Giving sequential commands to a computer
• Computer will perform it line-by-line
Computer
Program
You
CSE2003/AIE2050 S'23 17
https://www.restaurantowner.com/public/Chef-Training-Managing-the-Recipes-and-the-Yield.cfm
Program Codes
• A sequence of computer instructions (Like a recipe)
• Specify how to perform a computation
• Computers run instructions in the program sequentially
• Computing tasks
• Mathematical: solving a systems of equations, finding the roots of a polynomial
• Symbolic: searching and replacing text in a document, and etc.
• Others.
CSE2003/AIE2050 S'23 18
Executable Program
• Computers cannot understand high-level programming language
• Compilation: program codes → executable program
• Translate high-level language (string) into machine language (binaries)
• Computer now can execute the compiled program.
• Of course, the workflow shouldn’t change during compilation!
CSE2003/AIE2050 S'23 19
Program “Hello World”
#include < stdio.h >
int main(void) {
printf("Hello World\n");
puts("Hello World\n");
return 0;
CSE2003/AIE2050 S'23 20
/* Begin with comments about file contents */
Insert #include statements and preprocessor definitions
Function prototypes and variable declarations
Define main() function {
Function body
}
Define other function {
Function body
}
Basic Structure of .c file
...
CSE2003/AIE2050 S'23 21
Comments
• Comments: /* multiple-line comment */, // One-line comment
• Can span multiple lines
/* first line
second line
third line */
• Ignored by compiler
• Use comments for additional information
/* hello.c – first program
created by your_name, 2023/02/05 */
CSE2003/AIE2050 S'23 22
The #include Macro
• Header files: constants, functions, other declarations
• #include <stdio.h> - read the contents of the header file
stdio.h
• stdio.h: standard I/O functions for console, files
#include <stdio.h> /* basic I/O facilities */
• printf, puts, scanf and other I/O functions available
CSE2003/AIE2050 S'23 23
Program 2: Add Two Numbers
#include <stdio.h>
int add(int, int);
int main() {
int a, b, sum;
a = 10;
b = 5;
sum = add(a, b);
printf("%d+%d = %d\n", a, b, sum);
return 0;
}
int add(int a, int b) {
return a + b;
}
CSE2003/AIE2050 S'23 24
Variables in Program?
• Very different from variables in mathematics
• Variable in math: some value that satisfy conditions
• y=2, x = 2x-y-1, so x is 1.5
• Variable in program: Assignable. A small object that has a piece of
memory space to store value.
• x=0; y=2; x = 2x-y-1; /* x is -3 after executing commands */
• Operator = is assignment operator, compute the result of the right hand and assign it
to the variable on the left hand.
CSE2003/AIE2050 S'23 25
Declaring Variables
• Must declare variables before use
• Variable declaration:
int n;
float phi;
• int – integer data type
• float – floating-point data type
• Other types (later)
CSE2003/AIE2050 S'23 26
Initializing Variables
• Uninitialized, variable assumes a default value
• Variables initialized via assignment operator:
n=3
• Can initialized at declaration:
float phi = 1.6180339887;
• Can declare/initialize multiple variables at once:
int a,b,c = 0, d = 4;
CSE2003/AIE2050 S'23 27
Arithmetic Expressions
• Suppose a and b are variables
• a+b,a-b,a*b, a/b, a%b: binary arithmetic
• A simple statement:
b=a+5*a/(b-2);
• Numeric literals like 2 or 5 valid in expression
• Semicolon ends statement
• x += y is equal to x = x + (y) available for -, *, /, %
CSE2003/AIE2050 S'23 28
Order of Operations:
Precedence Operator Evaluation direction
High +, - (sign) Right-to-left
*, /, % Left-to-right
+, - Left-to-right
Low =, +=, -=, *=, /=, %= Right-to-left
• Use parentheses to change order of evaluation
A+B*-C → A+(B*(-C))
(A+B)*-C → (A+B)*(-C)
CSE2003/AIE2050 S'23 29
Assume x=3.0 and y=4.0. Evaluate the statement
float z = x+4*x/(y-2);
1. Evaluate expression in parentheses
float z = x+4*x/(y-2); → float z = x+4*x/2.0;
2. Evaluate multiplies and divides, from left-to-right
float z = x+4*x/2.0; → float z = x+12.0/2.0; → float z = x+6.0;
3. Evaluate addition
float z = x+6.0; → float z = 9.0;
4. Perform initialization with assignment
z=9.0
How do I insert parentheses to get z = 7.5?
float z = (x+4*x)/(y-2);
Order of Operations
CSE2003/AIE2050 S'23 30
Function Prototypes
• Functions must be declared before use
• Declaration called function prototype
• Function prototypes:
int isEven(int); or int isEven(int n);
• Prototypes for many common functions in header files for C Standard
Library
CSE2003/AIE2050 S'23 31
Function Prototypes
Return_type function_name (arg1, arg2 …);
• Arguments: input of function, local variables
• Return value: single value returned to caller when function exits
• void – signifies no return value/arguments
int rand(void);
CSE2003/AIE2050 S'23 32
The main() Function
• main(): entry point for C program
• Simplest version: no inputs, outputs 0 when successful, and nonzero
to signal some error
int main(void);
• Two-argument form of main(): access command-line arguments
int main(int argc, char **argv);
• More on the char **argv notation later this week…
CSE2003/AIE2050 S'23 33
Our main() Function
/* The main() function */
int main(void) /* entry point */
{
/* write message to console */
puts(“hello Worlds”);
return 0; /* exit ( 0 => success) */
}
• puts(): output text to console window (standard-out, stdout) and end the line
• String literal: written surrounded by double quotes
• return 0;
exits the function, returning value 0 to caller
CSE2003/AIE2050 S'23 34
Function Definitions
Function declaration
{
declare variables;
Program statements;
}
• Must match prototype (if there is one)
• Variable names don’t have to match
• No semicolon at end
• Curly braces define a block – region of code
• Variables declared in a block exist only in the block
• Variable declarations before any other statements
CSE2003/AIE2050 S'23 35
Console I/O
• Stdout, stdin: console output and input stream
(ex. screen input and output in command prompt)
• puts(string): print string to stdout
• putchar(char): print character to stdout
• char = getchar(): return character from stdin
• string = gets(string): read line from stdin into string
• Many others – later this week
CSE2003/AIE2050 S'23 36
Preprocessor Macros
• Preprocessor macros begin with # character
#include <stdio.h>
• #define msg “Hello World”
Defines msg as “Hello World” throughout source file
• Many constants specified this way
CSE2003/AIE2050 S'23 37
Reference
• https://en.wikipedia.org/wiki/Pascal%27s_calculator
• https://en.wikipedia.org/wiki/Stepped_reckoner
• https://en.wikipedia.org/wiki/Analytical_Engine
• https://en.wikipedia.org/wiki/Difference_engine
• https://www.youtube.com/watch?v=K6NgMNvK52A
CSE2003/AIE2050 S'23 39
