ICS 2175 – Introduction to

programming
Getting Started: in C
 Objective
• Intro to C
• Tools we will use
• Program file structure
• Variables
• Read from screen and print to screen
• Decisions (If)
 C Orientation
• Created in 1972 to write operating systems (Unix
in particular)
– By Dennis Ritchie
– Bell Labs
• Evolved from B
• Can be portable to other hardware (with careful
design – use Plauger’s The Standard C Library
book)
• Built for performance and memory management –
operating systems, embedded systems, real-time
systems, communication systems
 C Standardization
• 1989 ANSI and ISO -> Standard C
• 1999 C99
• 2011 C11

• Don’t get thrown when you lookup

information on websites and find conflicts
based upon standards
 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++
 A First Program
makes input
and output available
#include <stdio.h>
to us
header
int main(void)
{
printf("This is my first C program.\n");
return(0);
}

open and close braces mark statements

the beginning and end
A First Program – What Does It Do?
printf("This is my first C program.\n");
return(0);

Prints the message

This is my first C program.

Ends the program Ends the line

 Java Reminder
Program C Java

#include<stdio.h> public class HelloWorld {

public static void main(String[]

int main(void) {
args) {
hello, world
printf("Hello\n"); System.out.println("Hello");

return 0; }
} }
 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
Copyright © Pearson, Inc. 2013. All
Rights Reserved.
Copyright © Pearson, Inc. 2013. All
Rights Reserved.
 Run First Program
• Write in notepad++
• Transfer with Filezilla
• Connect to panther as terminal (putty) using
SSH (Secure Shell)
• More filename to see the file
• gcc filename -o filename without c -g (ex:
gcc hello.c -o hello -g )
• ./hello
 Using variables
#include <stdio.h>
int main(void)
{
int sum, value1, value2, value3;
float average;
value1 = 2;
value2 = 4;
value3 = 6;
sum = 2 + 4 + 6;
average = sum / 3;
printf("The average of %d , %d, %d is %f\n", value1,
value2, value3, average);
return(0);
}

Print a float value from the

rest of the parameter list
 Variables and Identifiers
• Variables have names – we call these names identifiers.
• An identifier must begin with a letter or an underscore _
• C is case sensitive upper case (capital) or lower case letters
are considered different characters. Average, average
and AVERAGE are three different identifiers.
• Numbers can also appear after the first character.
• However, C only considers the first 31 (external
identifiers) or first 63 (internal identifiers) significant.
• Identifiers cannot be reserved words (special words like
int, main, etc.)
 User Input
• Let’s rewrite the average program so it
can find the average any 3 numbers we
try:
• We now need to:
1. Find our three values
2. Add the values
3. Divide the sum by 3
4. Print the result
 Average3.c
#include <stdio.h>

int main(void)
{
int value1, value2, value3;
float sum, average;

printf("What is the first value? ");

scanf("%d", &value1);
Read The address of variable value1

printf("What is the second value? ");

scanf("%d", &value2);

Indicates that we are

reading an integer
 printf("What is the third value? ");
scanf("%d", &value3);
scanf needs the &
sum = value1 + value2 + value3; before the identifier
average = sum / 3;

printf("The average of %d , %d, %d is %f\

n", value1, value2, value3, average);
return(0);
}
 Scanf Conversion Characters
• https://wpollock.com/CPlus/
PrintfRef.htm#scanfConv
Doubles on our machine are read with a lf.
(A double is a long float.)
 Formatting %d and %f
• The specifiers %d and %f allow a programmer to
specify how many spaces a number will occupy and
how many decimal places will be used.
• %nd will use at least n spaces to display the integer
value in decimal (base 10) format.
• %w.nf will use at least w spaces to display the
value and will have exactly n decimal places.
• Example:
– printf("The average of %2d , %2d, %2d
is %5.2f\n", value1, value2, value3,
average);
 Changing the width
Number Formatting Print as:
%2d
182 182
%3d
182 182
%5d
182 ``182
%7d
182 `’’`182
%4d
-182 -182
%5d
-182 `-182
%7d
-182 ```-182
 Changing the width (continued)
Number Formatting Print as:
23 %1d 23
23 %2d 23
23 %6d ….23
23 %8d ……23
11023 %4d 11023
11023 %6d .11023
-11023 %6d -11023
-11023 %10d ….-11023
 Changing The Precision
Number Formatting Prints as:
2.718281828 %8.5f `2.71828
2.718281828 %8.3f ```2.718
2.718281828 %8.2f ````2.72
2.718281828 %8.0f ````````3
2.718281828 %13.11f 2.71828182800
2.718281828 %13.12f 2.718281828000
 Average – add comments
#include <stdio.h>
/*
* This program calculates average pay
*/
int main(void)
{
int value1, value2, value3;
float sum, average;
string
// now get the first value
;

comments
 Character Data
• All of our programs so far have used
variables to store numbers, not words.
• We can store one or more characters by
writing:
char x, s[10];
– x can hold one and only one character
– s can hold up to nine characters (reserving 1 for
ending null)
• For now, we use character data for input and
output only.
A program that uses a character variable
#include <stdio.h>

/* A very polite program that greets you by name */

int main(void)
{
char name[25];

/* Ask the user his/her name */

printf("What is your name ? ");
scanf("%s", name);

/* Greet the user */

printf("Glad to meet you, %s\n.", name);
return(0);
}
 Features so far
• Include
• Variable types: int, float, char
• Read using scanf
– requires & for address of variable being read
• Print using printf
• Format strings: %f (float), %d (int), %u
(unsigned int), %c (char), %s (character array)
• Comments /*.. */ or //
if and if-else and if-else if - else
If (boolean_expression 1)
{ /statements }
else if ( boolean_expression 2)
{ /* statements */ }
else if ( boolean_expression 3)
{ /* statements */ }
else
{ /* statements */ }
 IsItNeg.c – illustrate if
#include <stdio.h>
// Tell a user if a number is negative
int main(void)
{ float number;
/* Ask the user for a number */
printf("Please enter a number ? ");
scanf("%f", &number);
// Print whether the number is negative or not
if (number < 0){
printf("%f is a negative number\n", number); }
else {
printf("%f is NOT a negative number\n", number); }
return(0); }
 Relational operators
Operator Meaning Example
== equals x == y
!= is not equal to 1 != 0
> greater than x+1 > y
< less than x-1 < 2*x
>= greater than or x+1 >= 0
equal to
<= less than or equal -x +7 <= 10
to
 Integer Division

• Our compound interest program prints the

values for every year where every ten or
twenty years would be good enough.
• What we really want to print the results
only if the year is ends in a 5. (The
remainder from division by 10 is 5).
 Integer Division Results
8 / 3 = 2 8 % 3 = 2
2 / 3 = 0 2 % 3 = 2
49 / 3 = 16 49 % 3 = 1
49 / 7 = 7 49 % 7 = 0
‑8 / 3 = ‑2 ‑8 % 3 = ‑2
‑2 / 3 = 0 ‑2 % 3 = ‑2
‑2 / ‑3 = 0 ‑2 % ‑3 = ‑2
2 / ‑3 = 0 2 %‑3 = 2
‑49 / 3 = ‑16 ‑49 % 3 = ‑1
 Choosing Data Types
• Sizes implementation dependent in limits.h
– int -2147483648 to 2147483647
– short -32768 to 32767
– long -9223372036854775808 to
9223372036854775807
– Float 1.17x10-38 to 3.4 * 1038
• Keyword unsigned starts at 0 but goes
higher
 Declaring Constants
•There are two ways of defining constants in C: using
#define and const.
•#define is a compiler preprocessor which replaces each
occurrence of the constant's name with its value:
•The general form of the constant declaration is:
#define ConstantName ConstantValue

•Let's take a look at a few examples:

#define withholding_rate 0.8
#define prompt 'y'
#define answer "yes"
#define maxpeople 15
#define inchperft 12
#define speed_limit 55
 Declaring Constants
•The general form of the constant declaration is:
const datatype ConstantName =
ConstantValue,
AnotherConstantName =
AnotherConstantValue;

•Let's take a look at a few examples of constants:

const float withholding_rate = 0.8;
const char prompt = ‘y‘,
answer[] = “yes”;
const int maxpeople = 15,
inchperft = 12;
speed_limit = 55;
 Java Comparison Thus Far
Feature C Java
type of language function oriented / imperative object oriented
file naming Stack.java - file name matches
stack.c, stack.h
conventions name of class
basic programming
function class / Abstract Data Type
unit
portability of source
possible with discipline yes
code
portability of yes, bytecode is "write once, run
no, recompile for each architecture
compiled code anywhere"
javac Hello.java creates Java
gcc hello.c creates machine
compilation virtual machine language
language code
bytecode
segmentation fault, core dump,
buffer overflow checked run-time error exception
unpredicatable program
use int: 0 for false, nonzero for
boolean is its own type - stores
boolean type true OR include <stdbool.h> and
value true or false
use bool
character type char is usually 8 bit ASCII char is 16 bit UNICODE
built-in immutable String data
strings '\0'-terminated character array
type
accessing a library #include <stdio.h> import java.io.File;
 More Java Comparison
Feature C Java
printing to standard
printf("sum = %d", x); System.out.println("sum = " + x);
output
System.out.printf("avg = %3.2f",
formatted printing printf("avg = %3.2f", avg);
avg)
reading from stdin scanf("%d", &x); int x = StdIn.readInt();
declaring constants const and #define final
for loops for (i = 0; i < N; i++) for (int i = 0; i < N; i++)
instance variables (and array
variable auto- elements) initialized to 0, null, or
not guaranteed
initialization false, compile-time error to access
uninitialized variables
checked exception at run-time or
casting anything goes
compile-time
must explicitly cast, e.g., to convert
demotions automatic, but might lose precision
from long to int
variable declaration at beginning of a block before you use it
variable naming
sum_of_squares sumOfSquares
conventions
Credit: http://introcs.cs.princeton.edu/java/faq/c2java.html
 Summary
• Tools we will use
– Notepad++
– Filezilla
– Panther (gcc)
– Putty
• Program file structure
– #include <> or “ “
– Main function
 Summary Cont.
• Variables
– int, float, char
– unsigned keyword
– String defined as char array : char name[26]
– For bool, include stdbool.h
– Constant:
• #define name value
• const type name = ?
– Get address of variable with &
– Cast with (type) var
•
 Summary Cont.

•Read from screen and print to screen

– Scanf (control string, variable addresses)
– Printf(string, variables to insert)
– Format strings %2f, %d, %s, %u
– #include <stdio.h>
•Decisions
– If / else if / else
 Exercise
• https://prof.beuth-hochschule.de/fileadmin/
user/scheffler/Lehre/Think-C_v1.08.pdf
• Exercise 2.1