Introduction to C Programming
Basic Structure and Fundamentals

• helloworld.c - Hello World program - most basic program with only printing
• addThree.c - Program that accepts user input and prints output.
• Naming rules

Hello World

The basic form of a simple C program is as shown below. ( Line numbers have been added for future reference. )

	1/* Filename.c
	2 *
	3 * This program was written by Ima Programmer on some date
	4 * This program does something useful . . .
	5 */
	6
	7	#include <stdlib.h>       // For accessing the standard library functions
	8	#include <stdio.h>        // For standard input and output functions
	9
	10
	11	int main( ) { 			// every C program begins at main
	12
	13		printf("Hello world\n"); // this is how we print to the screen
	14		return 0;		// convention says return a code
	15
	16	} // main    

Explanation of Specific Lines

1. The symbols /* and */ enclose a block comment, which may extend over any number of lines, or which may enclose only part of a line. Additional stars at the beginning of the line remind the reader that it is still within a multi-line comment.
• EVERY well-written program should begin with a large block comment specifying the name of the file, the author of the program, when it was written, and a brief description of what the program does and why. In large projects the opening comment may include reference to external documents ( software requirements documentation ), and may include a revision history of who modified the program when and for what purposes.
7. The #include statement informs the compiler of what libraries are needed.
• stdlib.h is a header file containing necessary definitions for the use of the standard C library functions. Many systems automatically include this one, but there are exceptions, and it never hurts to include it again, just to be sure.
• stdio.h contains the definitions of standard input and output functions. It is very rare that a C program would not need this header file.
• More advanced programs may need to include other libraries, such as cmath for using trigonometric functions.
• The double slash symbol, //, is a line comment. It indicates a comment that extends to the end of the current line.
11. Line 11 says that we are starting a function named main, which is the starting point for all C programs.
• The keyword int says that main returns an integer value as its return type. ( See line 14. )
• The open brace indicates the beginning of a block of code, which must be matched by a closing brace ( on line 16. )
• In this case, main provides no arguments. In other programs you may see the following alternatives:
  • int main (void ) { - expressly states that main takes no arguments.
  • int main( int argc, char *argv[ ] ) { - Beyond the scope of this introduction.
  • int main( int argc, char *argv[ ], char ** envp ) { - Beyond the scope of this introduction.
13. "printf" is the standard library function for formatted printing
    • A simple text string can be enclosed in double quotes, as shown.
    • The \n indicates a new line character. Without this, all the printout would appear on a single line. Multiple \n characters yield blank lines.
14. Every function must have a return statement, which causes the function to end and return control to whoever called it.
• Because main was declared to have an integer return type in line 13, this function must return an integer.
• The return value from main is typically interpreted as an error code, with a value of zero indicating successful completion.
• Negative 1 is a commonly used return value used to indicate an unspecified error of some kind.
16. It is good practice to comment the closing brace of every function, and any other closing brace that is more than a few lines away from its matching opening brace. This makes it much easier to read more complex programs, which may have MANY sets of nested and consecutive braced blocks.

A Simple Sample:

• This simple program adds three numbers and reports the total.

	1	/* addThree.c
	2	 *  This program was written by John Bell in January 2013 for CS 107
	3	 *  This program asks the user for two floating point numbers and 
	4	 *  an integer, and reports their total.  Note that one of the floating
	5	 * point numbers is stored as a double precision data type.
	6	 */
	7
	8	#include <stdlib.h>		// For accessing the standard library
	9	#include <stdio.h>		// For standard input and output
	10
	11	int main(  ) 
	12	{
	13		// Declare variables to be used
	14		int number;                             // The integer
	15		float fpNumber = 0.0f;                  // The floating point number
	16		double dpNumber = 0.0, total = 0.0;     // The double and the total
	17
	18		// Explain to the user what the program does
	19		printf( "This program adds together two floating point numbers\n" );
	20		printf( "and an integer.\n" );
	21		printf( "Written January 2009 by John Bell for CS 107.\n\n" );
	22
	23		// Get user input ( and check it if possible )
	24		printf( "Please enter the first floating point number > " );
	25		scanf( "%f", &fpNumber );
	26
	27		printf( "\nPlease enter the second floating point number > " );
	28		scanf( "%lf", &dpNumber );
	29
	30		printf( "\nPlease enter the integer > " );
	31		scanf( "%d", &number );
	32
	33		// Perform necessary calculations
	34		total = fpNumber + dpNumber + number;
	35
	36		// Report results ( in a complete and well-formed format. )
	37		printf( "\nThe total of %f plus %f plus %d is %f\n", fpNumber,  
	38				dpNumber, number, total );
	39	
	40		return 0;
	41	} // main

Explanation of Specific Lines

14. Line 14 declares that this program uses a variable named "number" that is of type "int".
    • All variables in C must be declared befrore they can be used.
      • Traditional C compilers requried that all variable declarations be made before any executable statements.
      • Most C programmers continue to follow this convention, even though the restriction has been relaxed in modern compilers, and there are sometimes good reasons for declaring variables later on in the program.
    • In this example, "number" is not assigned any initial value, so it will start out with an unknown random value. In general, this is bad practice.
    • Note the semicolon at the end of the line, which is how C knows that a statement has ended.
15. Line 15 declares and initializes a variable named "fpNumber" of type float, the most basic of floating point data types.
    • This variable has been given an inital value of 0.0.
    • The letter "f" following the 0.0 indicates that this number is to be interepreted to be of type "float", as opposed to the default of "double".
16. Line 16 declares and initializes two variables of type "double", a floating-point data type with twice the numerical precision of the data type "float".
    • Scientific and engineering programs typically use doubles instead of floats, unless there is a specific reason to do otherwise.
    • These variables are also both initialized to zero.
19. "printf" is the standard library function for formatted printing
    • A simple text string can be enclosed in double quotes, as shown.
    • Note \n can be placed anywhere within the string - even at the beginning
    • Every well-written program should begin by explaining to the user what the program does.
24. Note that because this line has no "\n" at the end, the curser will be left at the end of the line with the question.
25. scanf is the standard library function for reading data in from the keyboard.
    • The % symbol is a format specifier, and indicates what type of value to read in. %f specifies to read in a float data type.
    • Note that the variable name must have an ampersand in front of it in a scanf statement. The exact reason for this will be explained in the course section on pointers.
28. The format specifier for a double precison number is %lf", as opposed to %f". ( A double is essentially a "long" float. )
31. The format specifier for an integer is "%d". ( "d" stands for "decimal" integer, as opposed to octal or hexadecimal. )
34. The equals symbol, =, as used here is an assignment, which takes the value from the right side and stores it in the left side.
    • The plus sign, +, peforms addition, and yields the sum of its two arguments.
37. Format specifiers for printing numbers are similar to those used when reading them in.
    • The first argument to printf when printing numbers is a quoted string, with % format specifiers inserted everywhere that a numerical value is desired.
    • The quoted string is followed by a comma-separated list of values ( variables and/or expressions ) to be printed, one per format specifier.
    • Note that both the float and the double type use "%f" as their format specifier when printing, as opposed to the "%f" for floats and "%lf" for doubles when scanning.
    • Note that the output of the results is a complete sentence, and includes an echoing back of the user's input.
    • Note also that a line of code may span over multiple lines in the file. C/C++ only recognizes the semi-colon as the end of a line.
    • In your program, you need each line to be on no more than 80 characters. To contine a single line of code, advance to the next line and tab in farther than the beginning line of the instruction.

Variables ( Also covered under Data Types )

• A variable is a named storage location, where data may be stored and later changed.
• An identifier is a more general term for a named location, which may contain either data or code.
  • Identifiers must begin with a letter or an underscore, preferable letters for user programs.
  • The remaining characters must be either alphanumeric or underscores.
  • Identifiers may be of any length, but only the first 31 characters are examined in most implementations.
  • Identifiers are case sensitive, so "NUMBER", "number", and "Number" are three different identifiers.
  • By convention ordinary variables begin with a lower case letter, globals with a Single Capital, and constants in ALL CAPS.
    • Multi-word variables may use either underscores or "camel case", such as "new_value" or "newValue".
  • Integers are usually assigned variable names beginning with the letters I, J, K, L, M, or N, and floating point variables are usually assigned names beginning with other letters.
  • Identifiers may not be the same as reserved words. ( See below for a full list. )
• All variables must be declared before they can be used.
  • In K&R C, all variables must be declared before the first executable statement of the program.
  • Modern C allows variables to be declared any time before they are used, but it is still normally good practice to declare all variables at the beginning of the program, unless there is a very good reason to do otherwise.
    • ( Exceptions: Loop counter variables are often declared as part of the loop structure. Occasionally it is beneficial to declare variables within a reduced scope, to be discussed later. )
• Variables may be given an initial value at the time they are declared. This is called "initialization", or "initializing the variables".
  • Initialization in C is done using an equals sign:
  • Example: double x1 = 0.0, x2 = 0.0;
  • UNINITIALIZED VARIABLES ARE DANGEROUS, AND SHOULD BE CONSIDERED TO HOLD RANDOM VALUES.
• Variables may be declared "const", meaning that their values cannot be changed.
  • const variables MUST be initialized at the time they are declared.
  • By convention, const variables are named using ALL CAPS.
  • Examples:
    • const double PI = 3.14159;
    • const int MAXROWS = 100;
  • Note: K&R C did not have the const keyword, and so the #define pre-processor macro was used to define constant values. The const qualifier is a better approach when it is available, because it allows the compiler to perform type checking among other reasons. For CS 107 we will defer the discussion of #define until we get to the chapter on the pre-processor.

Keywords

The following words are reserved, and may not be used as identifiers:

auto break case char const continue default do double else

enum extern float for goto if inline int long register

restrict return short signed sizeof static struct switch typedef union

unsigned void volatile while _Bool _Complex _Imaginary

 

Naming Conventions

In addition to the variable naming rules imposed by the compiler, there are certain conventions that are commonly followed:

• Ordinary variables normally begin with lower case letters:

int number, nStudents

• Global variables ( to be covered later ) normally begin with a single capital letter:

double Coordinate, Salary;

• Defined constants normally are in all upper case:

const double PI = 3.14159;

const int MAXROWS = 100;

• Variable names consisting of more than one word typically capitalize successive words. This is known as "camel case":

double totalOld, totalNew, sumOfAllDigits;

• Alternatively, where camel case is awkward or undesired, underscores may be used to indicate the start of words:

double totalOfX_coordinates, total_of_Y_coordinates

• Integer numbers typically begin with letters I, J, K, L, M, or N. ( Remeber the first two letters in INteger. )
• Floating point numbers typically begin with other letters:

int nStudents; // Not just students

double average, total, standardDeviation;

• In any case, variable names should be meaningful and easily understood. ( Think complete words, not just letters, and make sure the words are meaningful and not just temp1, temp2, temp3, etc. )
• Single letters may only be used for the counter of a loop (as we will see later).