C Now

C Program Framework

A Simplified C Pattern

Disclaimer

This "Short Course" does not cover all aspects of the C language. Shortcut aspects are either not covered, or are mentioned only briefly. All options are not included.
The purpose is to describe a simplified subset of C, which can be used to write most programs.

Overview of C

C is a programming language developed, but not owned, by Dennis M. Ritchie of Bell Laboratories.
C is a compiled language.
C is portable at the source code level only.
C compilers are available for at least almost all general purpose computers.
All executable statements in C are in functions.
C is weakly typed.
C uses structural typing.

framework.c:

/**********************************************************
 * File Name:   framework.c
 * Description: 
 *                
 * Version:     
 * Author:      
 * Date:        
 **********************************************************/

/* Global Declarations                       */

int main (int, char * []) {
  /* Local Declarations                      */

  /* Initialization                          */

  /* Algorithm                               */
  
  /* Finalization                            */

  /* Report to system                        */
}

C Syntax

General

C is free form - that is, spaces and line have no special meaning to the compiler, except to separate elements of the program.
For the sake of readibility and clarity, style rules should impose a format on programs.
C is case sensitive - that is, upper case (capital) and lower case letters are considered to be different.
For the sake of readibility and clarity, identifiers should not usually differ in case only.

Comments

Comments are treated as white space (e.g., blanks) by the compiler, and are otherwise ignored.
Comments begin with a slash star (/*) and end with a star slash (*/).
Example:
/* This is a "multiline" comment. */
Example:
/* This is a multiline comment */
Multiline comments cannot be nested:
Example:
/* This is /* illegal */ in C */
Style: Comments should explain why something is being done, not what is being done. (The code tells what is being done.)

Identifiers

Identifiers begin with a letter, which can be followed by letters or numbers.
Identifiers cannot contain spaces.
Certain words are reserved in C, and cannot be used as identifiers.
Examples:
Demo Welcome width area
Invalid:
Demo program (has an embedded space) 2color (begins with a digit)

Variables

Variables must be declared.
The declaration of a variable must appear in the source code before its use.

Variable Declarations

Framework:
<type> <name> ;
Example:
int Width;
The name of a variable is a C identifier.
Style: The name of a variable should suggest its function.
Style: The name of a variable should not be the same as the name of a standard C type.
Style: Each variable declaration should be on a separate line.

Types

C types include a few basic types and a large number of types which are part of standard C packages.

Basic Types

The basic C types include int, unsigned int, and double (yes, there are other basic types.)
The int type should be used for integers (counts which can be negative), and for type compatiblity with library functions.
The unsigned int type should be used for cardinal numbers (counts which cannot be negative) and ordinals.
The double type should be used for real numbers (measurements).

Function Definitions

Framework:
<type> <name> (<argument list>) { <function body> }
Style: The body of a class should be indented.
The type of a function is the type of the value returned by the function.
The type of a function can be any C type. The keyword void can also be used as the type of a function: This indicates that no value is returned by the function.
The name of a function is a C identifier.
Style: The name of a function should suggest its function.

Argument Lists

The argument list declares the arguments which are passed to the function.
Framework:
<type> <name> , <type> <name> , ...
Example:
int width, int height
If there are no arguments, there should be no argument list, but the parentheses are still required.

Function Body

The function body can contain variable declarations and executable statements.
Framework:
<variable declarations>

<executable statements>
Style: The declarations of method variables should appear before the executable statements.
Function variables are declared in the same way as class variables.
Style: The body of a function should be indented.

Executable Statements

C statements include expression statements, compound statements, if statements, and while statements. (Yes, there are other kinds of statements.)

Expression Statements

Framework:
<expression> ;
Style: Each expression statement should be on a separate line.

Expressions

C expressions can be
- Varable Names
- Literal Constants
- Unary Operations
- Binary Operations
- Function Calls

Literal Constants

Integer constants can be any decimal number, with no decimal point.
Real constants can be any decimal number, with a decimal point.
Boolean constants can be either of the words true or false.
Examples:
45 (integer) 45.0 (double) true (boolean)

Unary Operations

C unary operations include:
- ++ (increment)
- -- (decrement)
- - (minus)
- ! (not)

The Increment Operator

The operand of the increment operator is a numeric variable.
The increment operator, ++, can appear either before or after a variable name.
When ++ appears before a variable name, it is the preincrement operator.
The result of a preincrement operation is one more than the previous value of the variable.
As a side effect, the value of the variable is increased by 1.
When ++ appears after a variable name, it is the postincrement operator.
The result of a postincrement operation is the same as the previous value of the variable.
The type of the result is the same as the type of the operand.
As a side effect, the value of the variable is increased by 1.

The Decrement Operator

The operand of the decrement operator is a numeric variable.
The decrement operator, --, can appear either before or after a variable name.
When -- appears before a variable name, it is the predecrement operator.
The result of a predecrement operation is one less than the previous value of the variable.
As a side effect, the value of the variable is decreased by 1.
When -- appears after a variable name, it is the postdecrement operator.
The result of a postdecrement operation is the same as the previous value of the variable.
The type of the result is the same as the type of the operand.
As a side effect, the value of the variable is decreased by 1.

The Minus Operator

The operand of the minus operator is a numeric value (it can be an expression).
The minus operator, -, appears before the operand.
The result of a minus operation is the value of the operand with its sign changed.
The type of the result is the same as the type of the operand.
There is no side effect.

The Not Operator

The operand of the not operator is an integer value (it can be an expression).
The not operator, !, appears before the operand.
The result of a not operation the is 1 (true) if the value of the operand is 0 (false,) and 1 (true) if the value of the operand is non-zero (true.)
The type of the result is int.
There is no side effect.

Binary Operations

C binary operations include:
- The assignment operator (=)
- Arithmetic operators (+ - * / %)
- Comparison operators (== != > < >= <=)
- Boolean operators (&& ||)

The Assignment Operator

The left operand of the assignment operator is a variable name.
The right operand of the assignment operator is an expression.
The types of the left and right operands should be the same.
The result of an assignment operation is the same as the value of the right operand.
The type of the result is the same as the type of the left operand.
As a side effect, the value of the left operand is changed to the value of the right operand.

The Numeric Operators

The operands of the numeric operators are numeric expressions.
The types of the left and right operands should be the same.
The type of the expression is the same as the type of the operands.
The + - * / operators have their usual meanings.
The % operator results in the remainder of a division operation (the quotient is discarded).
There is no side effect.
More exactly, numeric types can be converted automatically by the compiler.

The Comparison Operators

The operands of the comparison operators are numeric expressions.
The types of the left and right operands should be the same.
The type of the expression is int, regardless of type of the operands.
The > < >= <= operators have their usual meanings.
The == operator is the equality operator.
The != operator is the inequality operator.
There is no side effect.
More exactly, numeric types can be converted automatically by the compiler.

The Boolean Operators

The operands of the boolean operators are int expressions.
The type of the expression is int.
The result of the && (and) operator is 1 (true) iff both of the operands are non-zero (true.)
The result of the && (and) operator is 0 (false) iff either of the operands if zero (false.)
The result of the || (or) operator is 1 (true) iff either of the operands are non-zero (true.)
The result of the || (or) operator is 0 (false) iff both of the operands are zero (false.)
The boolean operators short circuit - that is, if the result can be determined from the left operand alone, the right operand is not evaluated.
There is no side effect.

Compound Statements

Framework:
{ <executable statements> }
Style: The body of a compound statement should be indented.

If Statements

Framework 1:
if ( <int expression> ) { <executable statements> }
Framework 2:
if ( <int expression> ) { <executable statements> } else { <executable statements> }
Style: The body of an if statement should be indented.

While Statements

Framework:
while ( <int expression> ) { <executable statements> }
Style: The body of a while statement should be indented.

C Now Home

Tutorial Index