C Basics (Part 1)

Structure of a C Program

• Sequence of statements, grouped into 1 or more functions
  • function: a subprogram. a section of a program performing a specific task
  • Every function body is defined inside a block (see below)
• For a C executable, exactly one function called main()
• Can consist of multiple files and typically use libraries
• Statement -- smallest complete executable unit of a program
  • Declaration statement
  • Execution statement
  • Compound statement -- any set of statements enclosed in set braces { } (often called a block)
  • Simple C statments end with a semi-colon. (A block does not typically need a semi-colon after it, except in special circumstances).
• Library
  • usually pre-compiled code available to the programmer to perform common tasks
  • Compilers come with many libraries. Some standard for all compilers, and some may be system specific
  • Two parts
    • Interface: header file, which contains names and declarations of items available for use
    • Implementation: pre-compiled definitions, or implementation code. In a separate file, location known to compiler
  • Use the #include directive on the header file to make a library part of a program (satisfies declare-before-use rule)

Building and Running a C Program

1. Pre-processing
   • The #include directive is an example of a pre-processor directive (anything starting with #).
   • #include <stdio.h> tells the preprocessor to copy the standard I/O library header file into the program
2. Compiling
   • Syntax checking, translation of source code into object code (i.e. machine language). Not yet an executable program.
3. Linking
   • Puts together any object code files that make up a program, as well as attaching pre-compiled library implementation code (like the standard I/O library implementation, in this example)
   • End result is a final target -- like an executable program
4. Run it!

Variables

• Name -- chosen by the programmer (aka identifier)
• Type -- specified in the declaration of the variable
• Size -- determined by the type
• Value -- the data stored in the variable's memory location
• Address -- the starting location in memory where the value is stored

Identifiers

• User-defined identifiers can consist of letters, digits, and underscores
• Must start with a non-digit
• Identifiers are case sensitive (count and Count are different variables)
• Reserved words (keywords) cannot be used as identifiers
  • A list of reserved keywords in C++ can be found on page 44 in the textbook

Style-conventions (for indentifiers)

• Don't re-use common identifiers from standard libraries (like printf)
• Start names with a letter, not an underscore. System identifiers and symbols in preprocessor directives often start with the underscore.
• Pick meaningful identifiers -- self-documenting

    numStudents, firstName		// good
    a, ns, fn				// bad
  

• a couple common conventions for multiple word identifiers
  1. numberOfMathStudents
  2. number_of_math_students

Declaring Variables

• Declare Before Use: Variables must be declared before they can be used in any other statements
• Declaration format: typeName variableName1, variableName2, ...;

   int numStudents;	// variable of type integer
   double weight;		// variable of type double
   char letter;		// variable of type character
  
   // Examples of multiple variables of the same type in single
   //  declaration statements
  
   int test1, test2, finalExam;
   double average, gpa;
  

Atomic Data Types

• integer types
  • char - 1 byte on most systems
    • typically used for representing characters
    • stored with an integer code underneath (ASCII on most computers today)
  • short - (usually at least 2 bytes)
  • int - (4 bytes on most systems)
  • long - (usually 4 or more bytes)
  • The integer types have regular and unsigned versions
    • The keyword unsigned used as a type by itself is a shortcut for unsigned int
• floating point types - for storage of decimal numbers (i.e. a fractional part after the decimal)
  • float
  • double
  • long double
• Special Note:
  • C++ added in a type called bool, which stands for "boolean"
  • The bool type has two possible values, true and false
  • C did not originally include the bool type, but some later implementations allow it (added into the 1999 standard, but not all compilers allow it in C)
  • Using bool helps improve readability. Easy to implement such a type, even if not built-in

Sizes

• Sizes for these types are implementation dependent
• numerical types above listed in smallest to largest order
• can use built-in sizeof() function to find out sizes of types or variables for a system
• For most computers today: char typically 1 byte; int typically 4 bytes

Initializing Variables

• To declare a variable is to tell the compiler it exists, and to reserve memory for it
• To initialize a variable is to load a value into it for the first time
• If a variable has not been initialized, it contains whatever bits are already in memory at the variable's location (i.e. a garbage value)
• One common way to initialize variables is with an assignment statement. Examples:

   int numStudents;
   double weight;
   char letter;
  
   numStudents = 10;
   weight = 160.35;
   letter = 'A'; 
  

• Variables of built-in types can be declared and initialized on the same line, as well

   int numStudents = 10;
   double weight = 160.35;
   char letter = 'A';
  
   int test1 = 96, test2 = 83, finalExam = 91;
   double x = 1.2, y = 2.4, z = 12.9;
  

More Declaration Examples, using various types
 

Constant Variables

• A variable can be declared to be constant. This means it cannot change once it's declared and initialized
• Use the keyword const
• MUST declare and initialize on the same line

   const int SIZE = 10;
   const double PI = 3.1415;
  
   // this one is illegal, because it's not
   //  initialized on the same line
   const int LIMIT;			// BAD!!!
   LIMIT = 20;		
  

• A common convention is to name constants with all-caps (not required)

Symbolic Constants (an alternative)

• A symbolic constant is created with a preprocessor directive, #define. (This directive is also used to create macros).
• Examples:

    #define PI 3.14159
    #define DOLLAR '$'
    #define MAXSTUDENTS 100
  

• The preprocessor replaces all occurrences of the symbol in code with the value following it. (like find/replace in MS Word). This happens before the actual compilation stage begins

Questions to consider

• What's the difference between these?

    #define SIZE 10
    const int SIZE = 10;
  

• Why use a constant variable (or symbolic constant)? i.e. what's the advantage?
• When is use of a constant a good idea? When is it not worthwhile?

Other Basic Code Elements

Literals

• integer literal -- an actual integer number written in code (4, -10, 18)
• floating point literal -- an actual decimal number written in code (4.5, -12.9, 5.0)
• character literal -- a character in single quotes: ('F', 'a', '\n')
• string literal -- a string in double quotes: ("Hello", "Bye", "Wow!\n")

Escape Sequences

• String and character literals can contain special escape sequences
• They represent single characters that cannot be represented with a single character from the keyboard in your code
• The backslash \ is the indicator of an escape sequence. The backslash and the next character are together considered ONE item (one char)
• Some common escape sequences are listed in the table below
   

  Escape Sequence	Meaning
  \n	newline
  \t	tab
  \r	carriage return
  \a	alert sound
  \"	double quote
  \'	single quote
  \\	backslash

Comments

• Block style

      /* This is a comment.
         It can span multiple lines  */ 
  

• Line comments -- use the double-slash //

      int x;    // This is a comment 
      x = 3;    // This is a comment 
  

  This style of comment was not originally available in C. It was added into the language later, and most compilers now support it.