The C Programming Language

The C Programming Language
An Introduction for Programmers

Prof. David Bernstein
James Madison University

Computer Science Department

bernstdh@jmu.edu

Identifiers

First Character:
- Must be a letter or underscore
Subsequent Characters:
- Can be a letter, digit, or underscore
Conventions:
- Do not use an underscore as the first character
- Limit identifiers to 31 characters

Comments

Line Based:
- Any text between a // and the end of the line is a comment
Block:
- Any text between a /* and a */ is a comment

Basic Data Types

Some Types:
- char
- double
- float
- int
- long
- short
An Important Point:
- The sizes are machine-dependent

Variables

A Restriction:
- Must be declared before they are used
Loose Syntax of Declarations:
- type identifier [= value] [,identifier [= value]]...;
Examples:
- float cost = 0.0; int lower, upper, step;

Assignment Operator

Assignment:
- Placing a value into the memory identified by a variable/constant
Syntax:
- variable = literal|expression ;
Examples:
- height = 14.0; step = 1;

Type Conversions

The General Rule:
- The only automatic conversions are those that convert a "narrower" operand into a "wider" one without loss of information
Ignoring Unsigned Operands:
- If either operand is long double convert the other to long double
- Otherwise, if either operand is double convert the other to double
- Otherwise, if either operand is float convert the other to float
- Otherwise, if either operand is long convert the other to long
Coercion Using the Cast Operator:
- (type) expression

Arithmetic Operators

Basics:
- Addition (+)
- Subtraction (-)
- Multiplication (*)
- Division (/)
Integer Operators:
- Integer Division (/)
- Modulo (%)
Others:
- Increment (++) and Decrement (--)
- Negation (-)

Relational Operators

Comparison:
- Greater than: >
- Less than: <
- Greater than or equal to: >=
- Less than or equal to: <=
Sameness:
- Equal to: ==
- Not equal to: !=

Logical Operators

Binary:
- Logical AND: &&
- Logical OR: ||
Unary
- Logical NOT: !

Bitwise Operators

Binary:
- Bitwise AND: &
- Bitwise OR: |
- Bitwise XOR: ^
- Left Shift: <<
- Right Shift: >>
Unary
- One's Complement: ~

The if Statement

Syntax:
- if (boolean_expression) statement [else statement]
Examples:
- if (score < 60) grade = 'F'; if (bmi >= 30.0) status = 'O'; else if (bmi >= 25.0) status = 'H';

while Loops

Syntax:
- while (boolean) statement
Example:
- while (width <= 10) { area = height * width; width += 1; }

do-while Loops

Syntax:
- do statement while (boolean);
Example:
- do { area = height * width; width += 1; } while (width <= 10);

for Loops

Syntax:
- for (initialization; boolean; update) statement
Example:
- for (i=0; i<size; i++) { area = i * i; }

Symbolic Names/Constants

A Note About Development:
- Source files are preprocessed before they are compiled
Defining Symbolic Names/Constants
- #define name replacement text

Enumerations

Defined:
- A list of (normally 0-based) integer constant values
Syntax:
- enum identifier {value0[=initial][, valuei]... };
Example:
- enum choices {NO, YES}; enum{JAN=1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC};

Pointers

Declaration:
- type *identifier
Void Pointers:
- Most pointers point to a particular kind of entity
- void pointers can hold any type of pointer
Operators:
- Unary Dereference: *
- Unary Address Of: &

Arrays

Defined:
- An array is a fixed-size, ordered collection of homogeneous values
Declaration:
- type identifier [ size ]
Individual Elements:
- identifier [ index ]
A Note:
- Arrays are 0-based

Strings

The Key Point:
- C does not have a string type, instead it uses arrays of characters
The Idiom:
- So that the length of the array can be determined, all "strings" have a '\0' character as their last element
"String" Literals:
- For convenience, "string" literals do not include the null character

"Strings" (cont.)

// This statement will allocate memory for // an array of 17 character (16 for the "real" // characters and 1 for the null character) and // assign the characters 'C', 'o', ... '\0' to the // elements char department[] = "Computer Science";

The const Qualifier

Syntax:
- The const qualifier can appear once in a declaration (but not after a comma)
Purpose:
- Declares the entity to be non-modifiable (sometimes called "read-only")
Details:
- For arrays, the elements are non-modifiable
- For pointers, the entity being pointed to is non-modifiable

The const Qualifier (cont.)

const int i = 5; i = 10; // Will not compile const char *department; department = "Computer Science"; // Will compile department[0] = 'X'; // Will not compile department = "Mathematics"; // Will compile const double grades[] = {90., 75.}; grades[1] = 100.; // Will not compile char course[] = "C Programming"; course = "Data Structures"; // Will not compile because the // the RHS is const but the LHS is not const char grade[] = "B-"; grade = "B+"; // Will not compile because the // LHS is const (i.e., non-modifiable)

Address Arithmetic

The Philosophy:
- Be consistent and regular; integrate pointers with arrays and address arithmetic
The Implications:
- If p is a pointer to an element of an array then p++ increments p to point to the next element

Address Arithmetic and Arrays

// Allocate memory for and initialize the array double grades[] = {90., 75., 55.}; // Assig the address of (the first element of) the array to p double *p = grades; // Change element 0 the obvious way grades[0] = 100.; // Change element 1 a less obvious way (using the address arithmetic // performed by the [] operator p[1] = 100.; // Change element 2 a less obvious way (using explicit address arithmetic) p += 2; // Change the pointer (by the size of two doubles *p = 100.; // Assign 100.0 to the address (by dereferencing p)

Address Arithmetic, the const Qualifier and "Strings"

// This statement will assign the address of the "string" // "Computer Science\0" to the pointer department. char *department = "Computer Science"; // The above isn't safe because the following will compile // and, when executed, cause a problem (e.g., a segmentation fault) // because read-only memory is being written to department[0] = 'X'; // So, it's better to do the following const char *department = "Computer Science";

Functions

Purpose:
- Encapsulate a computation
Syntax:
- type name([type parameter]...){statement...}

Functions (cont.)

Return Values:
- Typed functions indicate the value they evaluate to using a return statement
void Functions:
- Have a void type and no return statement or a return statement with no expression
Functions with No Formal Parameters:
- If the formal parameter list is empty then the actual parameter list needn't be (though the actual parameters will be ignored)
- If the formal parameter list is void then the compiler will check to make sure the actual parameter list is empty

Invoking/Executing Functions

Syntax:
- identifier([parameters])
Example:
- size = area(10.2, 20.9);

Argument Passing

The Rule:
- All arguments are passed by value
Getting Around the Rule:
- Pass a pointer
- Receive a pointer
Arrays:
- When the name of an array is used as an argument, a pointer to the beginning of the array is passed

Pointers to Functions

Two Observations:
- Functions are not variables
- One can define pointers to functions
An Example:
- void sort(void *data[], int (*comp)(void *, void *)) { // The body of the algorithm which can include statements like: if ((*comp)(data[i], data[i+1]) < 0) { } }

Structures

Defined:
- A collection of one or more (possibly heterogeneous) variables
An Example:
- struct employee { int age; double salary; };
Membership:
- The Membership Operator: .
- The Shorthand Operator: -> is short for (*pointer).member

typedef

Purpose:
- Allows the creation of new data type names
Examples:
- typedef int Length; typedef struct tnode *Treeptr; // A Treeptr is a pointer to a structure typedef struct tnode { // A Treenode is a structure char *word; int count; Treeptr left; Treeptr right; } Treenode;

Unions

Defined:
- A variable that may, at different times, hold objects of different types and sizes
An Example:
- union u_type { int ivalue; double dvalue; } u;
Intepretation:
- u will be large enough to hold the larger of an int and double