CS156 Variables: C Variables & Expressions

Basic C Program Structure

Your simplest C programs will have the following simple structure:

/*
 * Comment section
 */
… Preprocessor directives …
… Evil Global Variable Declarations …
int main( ) 
{ 
        … Local Variable Declarations …
        // Comment
        … Executable Statements …
        … Local Variable Declarations …
        // Comment
        … Executable Statements …
        return 0; 
}

C Elements: Comments

// CS156 HW3
// Author: Jack Applin
// Purpose: Demo of first program
// Input: none
// Output: prints Hello World
// This is an in-line comment.
//
/* This is a multi-line comment. */
/*
 * so is this
 */
/* and
this
as well */
// But, of course,
// so is this, sort of.

Comments are used to explain code.
Comments are for humans, not the compiler.
Put a block of comments at the top of all your .c files to document its purpose, its use, and the functions it contains.

Careful!!

Just like in Java, /* comments */ can’t be nested.
However, // comments can be nested.

// This // will // work.
// This won’t work:
/*
int a=1;
int b=2;       /* hello */
int c=3;
*/

C Elements: #include

The #include <whatever.h> syntax tells the compiler to include a set of variable and function definitions from another file.
A standard library of useful functions exists and is accessed through a set of standard .h files.
stdio.h — basic input and output (e.g., printf, scanf)
stdlib.h — many utility functions (e.g., exit, rand, malloc, strod)
math.h — mathematical functions (e.g., sqrt, pow)

C Elements: Variables

A variable is a named placeholder for a piece of information.
Each variable has a unique name.
- Should start with lowercase a–z.
- Can only contain letters (a–zA–Z), digits (0–9), or underscore (_).
- Names are case sensitive (Egg is not egg).
- Each variable has an associated type which determines what kind of information it holds.
Variable names should indicate purpose. song_count is better than s or sc.

Data types

Standard Data Types
`int`	`char`	`double` & `float`	`void`
`-20`	`'x'`	`-30.4`
`42`	`'3'`	`3.0`
`123456789`	`'\n'`	`6.022e23`

Note that a single char literal is 'x' with just a single character between the single quotes. A string literal "xyz abc" may contain 0 or more characters between the double quotes and is automatically null terminated.

C Elements: Variable Declarations

Variables must be declared before they are used. Declarations take the form DataType name;
Examples:
- double rest_mass;
- char grade;
- int intyMcIntFace;
- float x,y;
All variables have an associated scope that determines where in the program they are accessible.
Variables declared outside any function are called global variables. They are accessible anywhere.
Global variables are, generally, poor practice. They will be forbidden in many of our homework assignments.

Basic Variable Types

int — an integer type
- int zip_code; // a zip code
double — a floating point type (real number)
- double friction; // a friction coefficient
char — a single character
- char grade; // letter grade: ABCDF, but not B+

The word “decimal”

To some people, the word “decimal” refers to a digit after the decimal point: in 123.45, 4 and 5 are referred to as decimals.
That’s not how I’m using the word. I use “decimal” to mean base 10, as opposed to “octal” (base 8) or “binary” (base 2).

C Elements: Simple Expressions

Simple expressions can be formed using the operators
- a + b : Add
- a - b : Subtract
- a * b : Multiply
- a / b : Divide
- a % b : Modulus (return remainder)
Here a and b can be literals, variables or other expressions.
- That means that these things can get fairly complicated.
- Examples: 1.4*2 or var1*3.14 or 2*(var1+2)
- If a has the value 12 and b is 7, what is a % b?

Mathematicians Beware

Beware, mathematicians: some things are different:

Expression	Result
`axb`	the variable `axb`
`a x b`	a syntax error
`3d`	a syntax error
`a⋅b`	a syntax error
`d3`	the variable `d3`

C Elements: Assignment Statements

For variables to be useful we must assign a value to them:
var = expr;
The variable var must be declared before we assign a value to it.
Attempting to assign a value to an undeclared variable results in a syntax error. The compiler will let you know.

Example

#include <stdio.h>
int zip_code;       // an evil global variable
int main() { 
    double friction; // local variable for amt of friction 
    double number;   // local variable for calculation

    // assign some values
    zip_code = 44455;
    friction = 0.04;
    number = (zip_code * friction) - 3.2;

    // print number
    printf("The final number was %f\n", number);
    return 0; 
}

The final number was 1775.000000

stdio.h: printf

The printf function allows us to print to the screen.
We call it “printing” because computers used to use paper & ink terminals.
Special formatting symbols allow us to print the values of variables.
- %d — print an int variable
- %f — print a double variable
- %c — print a char variable
Special characters can be printed with escape sequences.
- \n — the newline character
- \t — the tab character
- \" — double quote

Example 2

#include <stdio.h>

int main() { 
    double friction, number;
    int numPeople = 3;

    // assign some values
    friction = 0.04;
    number = friction + 3.2 * 2;

    printf("The final number was %f\n", number);
    printf("The value of \"friction\" was %f.\n",friction );
    printf("There are %d people here.\n", numPeople );
    return 0; 
}

The final number was 6.440000
The value of "friction" was 0.040000.
There are 3 people here.

Your Dear Aunt Sally can take a hike

In elementary school, students often learn acronyms such as PEMDAS. These are useful, to a point.

Consider 1 − 2 + 3.

What’s the answer?
A comes before S in PEMDAS, right?

Expressions and Operator Precedence

Highest precedence, happens first

( )

* / %

+ -

Lowest precedence, happens last

Consider a+b*c. This expression is ambiguous unless we specify an order for the operations to be performed.
C defines a set of precedence relations for operators.
Fortunately, C uses the same precedence for common operators as does conventional mathematics. It gets a bit weird when C strays outside the realm of the usual arithmetic operators, however.

Example 3

printf("1+2*3 = %d\n",     1+2*3);
printf("(1+2)*3 = %d\n",   (1+2)*3);
printf("2*3+4*5 = %d\n",   2*3+4*5);
printf("2*(3+4)*5 = %d\n", 2*(3+4)*5);

1+2*3 = 7
(1+2)*3 = 9
2*3+4*5 = 26
2*(3+4)*5 = 70

The format HAS to match the type

printf("%d\n", 123.456);
printf("%f\n", 789);

c.c: In function 'main':
c.c:1: warning: format '%d' expects argument of type 'int', but argument 2 has type 'double'
c.c:2: warning: format '%f' expects argument of type 'double', but argument 2 has type 'int'
1310918856
123.456000

Type Conversion and Division

C automatically converts between types when types are mixed in an expression:
- integer + floating-point → floating-point
- 42 + 0.0 → 42.0 (floating-point)
- 3.0 / 1.5 → 2.0 (floating-point)
- 3 / 1.5 → 3.0 / 1.5 → 2.0 (floating-point)
Integer division return the integer part of the result (remainder is discarded). Remember this.
- 3 / 2 → 1 (int)
- 21 / 8 → 2 (int)

Type Conversion Examples

printf("%f\n", 42 + 0.0);
printf("%f\n", 3.0 / 1.5);
printf("%f\n", 3 / 1.5);
printf("%d\n", 3 / 2);
printf("%d\n", 21 / 8);

A brief note about floating-point constants

How to confuse your readers:

    x = 3. + .4;

Was that .4 or 4? Don’t make me squint to see a leading or trailing decimal point—help me out with a zero:

    x = 3.0 + 0.4;

CS156: Intro to C, Part I

Spring 2018

Variables