Computer Programming (3)

administrivia

Web Page - http://www.cs.tau.ac.il/~efif/courses/ComputerProgramming

homework issues
- you can use the lab
- you can use your home computer
- you can use your friend’s computer
- you can use any computer you like
  - but if it’s not the lab’s computer, it’s up to you to get and use the software
- how to turn homework in
  - email the files to Itay Dar, daritay@post.tau.ac.il

let’s look at that temperature example again

/*
 * Print a Fahrenheit-to-Celsius
 * conversion table
 */

#include <stdio.h>

int main (void)
{
  int fahr;
  int celsius;
  int lower = 0;
  int upper = 300;
  int step = 20;

  fahr = lower;
  while (fahr <= upper) {
    celsius = 5 * (fahr – 32) / 9;
    printf (“%d\t%d\n”, fahr, celsius);
    fahr = fahr + step;
  }

  return 0;
}

can we make it make sense?

take it for granted that it works
does it make any sense?
why is it done this way?

how would you do it?

Say I told you to calculate this table
for each Fahrenheit temperature
- 0 to 300° F
- in steps of 20° F
you have a calculator
you know that
- C = 5/9 (F - 32)

what might you do?

write the list of Fahrenheit temperatures
- the left column of the table
for each temperature in the table
- plug it into the equation
- calculate a Celsius temperature
- write it in the table to the right of the F temperature

a few constraints the computer has

it only does one thing at a time
it only remembers things if they’re in memory
we don’t know how to print like this
- printf doesn’t jump around
- it prints each line sequentially, left-to-right
- you can’t go back

the program approaches it differently

start with the first F temperature (0)
do each line fully
- calculate a celsius equivalent
- print out the whole line
  - Fahrenheit and Celsius temperatures
now increment the last Fahrenheit temperature by 20
if we haven’t gone over our limit, go back to step 2

the program once more

 
/*
 * Print a Fahrenheit-to-Celsius
 * conversion table
 */

#include <stdio.h>

int main (void)
{
  int fahr;
  int celsius;
  int lower = 0;
  int upper = 300;
  int step = 20;

  fahr = lower;
  while (fahr <= upper) {
    celsius = 5 * (fahr – 32) / 9;
    printf (“%d\t%d\n”, fahr, celsius);
    fahr = fahr + step;
  }

  return 0;
}

more data types

signed/unsigned
conversion between types

signed/unsigned

why bother?
- clarity
- increased range

clarity

some data is inherently unsigned
- unlike temperatures
- number of things
  - you can’t have –3 oranges
- dates
  - -10/-13/-1999?

increased range

remember what I said about ranges
- a byte can hold 256 values
  - 0 – 255
  - -128 – 127
why is this?
- n bits can represent a range of 2ⁿ numbers
  - n bits can represent a number from 0 to 2ⁿ-1
- a byte has 8 bits
  - 8 bits can represent a number from 0 to 255
  - but then we can’t represent negative numbers
1 0 0 1 1 1 0 1

negative numbers

let’s “steal” one bit to indicate +/-
- say, 0 is positive, 1 is negative
  - that way, a positive number is the same as an unsigned number
- we’re left with 7 bits for the number
  - 7 bits can represent a number from 0 to 2⁷-1 (which is 127)
  - so this way, we could have 0 – 127, either + or –
1 0 0 1 1 1 0 1

it doesn’t exactly work that way

but it’s similar
- one bit is a “sign bit”
- the others represent values
- the details aren’t important

signed/unsigned

only integer types can be unsigned
- unsigned char
- unsigned short
- unsigned int
- unsigned long
unsigned arithmetic works kind of funny
unsigned int i = 0; i = i – 1;
- in this case, i will probably be 4,294,967,296!
  - it “wraps around”

type conversions

C can sometimes convert between different types for you
- often it’s just common sense
- smaller to larger
  - char to int
  - int to long
- less precise to more precise
  - float to double
  - int to double

the program slightly modified

limited precision

 
/*
 * Print a Fahrenheit-to-Celsius
 * conversion table
 */

#include <stdio.h>

int main (void)
{
  int fahr;
  int celsius;
  int lower = 0;
  int upper = 300;
  int step = 20;

  fahr = lower;
  while (fahr <= upper) {
    celsius = (5 / 9) * (fahr – 32);
    printf (“%d\t%d\n”, fahr, celsius);
    fahr = fahr + step;
  }

  return 0;
}

the output will look like:

what does this mean?

we can do things like this:
int i; double x; i = 1; x = i;

constants: what is a constant?

something whose value can’t change
- not a variable
could be:
- a literal value we use in our code
  - numbers
  - strings
  - characters
- a variable whose value doesn’t change
- a symbolic name we use in place of a literal value

numerical constants

always has a data type
- usually implied
- sometimes explicit
the computer can sometimes convert data types
- from “smaller” to “larger”
  - short to int
  - int to long
  - float to double
from less accurate to more accurate
- int to double

using numerical constants

you don’t usually have to worry about what type a constant is
i = 34; double pi = 3.1415; double radius = 4;
- we won’t bother with explicit types for constants
  - i.e., all those L and F suffixes

examples

1234
- data type is int
1234L
- explicitly declares it to be a long
- but usually not necessary to do this
1234.0
- data type is double

character constants

just as char is an integral type, character constants are integers too
a character surrounded by single quotes
- ‘x’
for unprintable characters, we use “escape sequences”

escape sequences

used to represent characters that don’t correspond to a printable character
- start with a backslash \
\n newline

\t tab

\\ backslash

\’ single quote

\” double quote

\0 nul character

escape sequences

we’ve already seen two of these
- “Hello, world!\n”
  - adds a newline to our output
  - otherwise, subsequent output would be on the same line
- “%d\t%d\n”
  - we used this to print out a table of temperatures
  - lined up the right column
don’t stress about these… we’ll use them as we need them

character constants are integers

the following lines of code have the same effect
- they’re both legal
- but the second is unlikely to be used (unless doing character manipulation)
i = 110; i = ‘n’;

declarations

what is an declaration?
- how we introduce an identifier
- specifies the interpretation and attributes of an identifier
  - in other words, tells the computer what an identifier means
    - variable
    - function
    - various other things
  - let’s focus on variables right now

variables

so, what is a variable?
sometimes called an object
- though less so these days, since it’s not the same as the objects in “object-oriented” programming
- your text defines object as “a named region of storage”
- ANSI standard:
  “A region of data storage in the execution environment, the contents of which can represent values. … objects are composed of contiguous sequences of one or more bytes, the number, order, and encoding of which are either explicitly specified or implementation-defined.”

variables

so variables are memory regions you can use to hold data while your program is running.
for your convenience, you give them names (instead of having to know the address)
because different types of data are different sizes, the computer needs to know what type each variable is
- so it can reserve the memory you need

back to declarations

so all this means that before you can use a variable, you need to tell the compiler:
- its name
- its data type
- anything else that the compiler needs to know
  - storage class
- right now, we’ll just stick to the first two

why declare variables?

easier for the compiler
- it doesn’t have to guess what you want
- it can reserve the right amount of memory
- machine code can be different for some different data types
discipline
- forces you to think about what you need
- this is a subtle issue, we’ll revisit it

declaration rules

each declaration consists of:
- a data type
  - int, double, char…
- a list of variable names
  - remember the rules for identifiers
    - letters, digits, underscore
    - can’t start with a digit
    - case sensitive
- optional initialization
- ends with a semicolon

simple declaration examples

char c;
int i;
double d;
int lower, upper, step;

initialization?

sets the initial value of the variable
- this doesn’t mean it can’t change subsequently
- must be a constant expression
  - a constant
  - an expression whose value is constant
char c = ‘x’; int i = 37; double d = 12.34; int lower=0, upper=300, step=20;

initialization and data types

the initializer must be:
- of the same data type as the variable, or
- of a data type the compiler can convert into the data type of the variable
Good:
int i = 3; double a = 19.38; double b = 12;
Less good:
char c = 3.1415;

placement of declarations

placement in program is significant
- at beginning of statement block
  - this is what we’ve seen so far
- outside a function - global variable
- parameter declaration - in function declaration

variables in statement blocks

what statement blocks have we seen so far?

after all, we haven’t yet even talked about statement blocks!

/*
 * HelloWorld: A simple C program
 */

#include <stdio.h>

int main (void)
{
  printf (“Hello, world!\n”);
  return 0;
}

statement blocks are surrounded by { }

another statement block

/*
 * Print a Fahrenheit-to-Celsius
 * conversion table
 */

#include <stdio.h>

int main (void)
{
  int fahr;
  int celsius;
  int lower = 0;
  int upper = 300;
  int step = 20;

  fahr = lower;
  while (fahr <= upper) {
    celsius = 5 * (fahr – 32) / 9;
    printf (“%d\t%d\n”, fahr, celsius);
    fahr = fahr + step;
  }

  return 0;
}

back to variables and statement blocks

so any statement block can start with some variable declarations
- but those variables are only available to the code inside the statement block
  - this is a concept called scope…

global variables

variables that are defined outside of any functions
potentially available to all functions
- there are some rules here
analogy:
- account slips: local variables
- web page: global variable

function parameters

we haven’t talked about functions much yet
parameters are data you give to a function each time it is invoked
- remember my driving analogy of a function
  - adjust speed to X mph
  - the same instructions, no matter what X is each time
- remember how we have used printf:
  printf (“Hello, world!\n”);
  printf (“i is %d\n”, i);
  printf (“%d\t%d\n”, fahr, celsius);
we’ll talk about parameters more when we get into functions

shell commands

Command	Operation
`ls`	List files
`cp <fromFile> <toFile>`	Copy fromFile to toFile
`mv <fromFile> <toFile>`	Move fromFile to toFile
`rm <theFile>`	Remove theFile
`mkdir <theDir>`	Create theDir
`cd <theDir>`	Change directory to theDir
`cat <theFile>`	Display theFile
`less <theFile>`	Display theFile one page at a time
`more <theFile>`	Display theFile one page at a time
`man <theCommand>`	Manual page for theCommand

Maintained by Efi Fogel. Last modified: October 29 2002.

\n	newline
\t	tab
\\	backslash
\’	single quote
\”	double quote
\0	nul character