Free Sony EBooks: Free ebook sample of "88 C Programs" by JT Kalnay

About This Book

This book is not organized in a traditional chapter format.

Instead I have chosen to include example programs that exhaustively illustrate the important points of C in an evolutionary manner. By working through these programs you can teach yourself C. I assume you already know how to program and are familiar with standard algorithms.

The programs that I present are not, by themselves, complete applications. The programs are “single-issue teaching programs”. Experienced programmers who are learning a new language have told me time and time again that they mainly want to see the functionality of the new syntactic and semantic elements. The programmers tell me that they will be able to think of the applicability of the feature to their project. When necessary, I provide a sample application to give a feel for how the new element might be employed.

The programs are presented in an order that presents the simplest, most straightforward aspect of a new element first. Subsequent programs present the more subtle or confusing aspects of a new element. This is a proven pedagogical approach for teaching C that I have presented to over 1,000 professionals and college students.

This book assumes that you are already a programmer and are able to learn well on your own.

Good luck in your study of C.

Table Of Contents

Simple.c simplest C program, main, program entry point

helloworld.c one printf

prog1.c more printf

prog2.c comments, case sensitivity

prog3.c variable declaration and initialization

prog4.c printf output

ops.c C operators

prog4a.c printf output

prog5.c C data types

pg34.c sizeof(var)

prog6.c operators and precedence

prog7.c mixed mode arithmetic

prog8.c modulus

steve.c relational operators

prog9a.c three types of loops

prog10.c for loop

prog11.c for loop, scanf

prog12.c nested for loops

prog13.c while loop

prog14.c while loop

prog15.c while loop, do loop

if.c if statements

16.c math.h

19.c logical operators and expressions

20.c complex decision structures

21.c switch statement

errors.c common syntax errors

22.c arrays

23.c array boundaries

25.c more array boundaries

26.c bowling scores, arrays

27.c character arrays

29.c function declaration and usage

30.c calling subroutines

31.c passing constants to subroutines

32.c passing variables to subroutines

33.c subroutine returning value

35.c multiple files compiled together

valref.c call by reference, call by value

36.c passing array to subroutines

37.c passing pointer to subroutine

38.c sorting array of integers

sortstep.c sorting example

39.c two dimensional array

twodim.c two dimensional array to subroutine

testarrays.c more arrays

testarrays1.c more arrays

prog40.c static, automatic, global

scope.c scope of variables

41.c recursion

testpop.c stack

42.c struct keyword, structures

43.c structures

45.c UNIX time.h file

46.c Arrays of Structures

47.c structures and arrays

48.c strlen string processing

49.c strcat

50.c strcmp

52.c getchar gets

53.c ctype.h, string functions

charlarge.c characters as large integers

55.c structures and strings

57.c pointers

58.c pointers

59.c pointers to structures

60.c linked list pointers

malloc, memory allocation

valref.c pointers and functions

76.c getchar, putchar

77.c file operations, fopen, fprintf, fclose, getc, putc

uitp.c file i/o and string processing

argtest.c arc, argv, dealing with command line arguments

envtest.c interface to UNIX environment

sol20.c argc, argv

78.c register const storage qualifiers

speed1.c inefficiency

speed2.c efficiency

64.c copying strings using pointers

73.c printf in depth

74.c scanf in depth

75.c scanf in depth

67.c bit operations

bits.c int octal hex binary display

71.c #ifdef conditional compile

quicksort.c quicksort pointer example

ptrtofunc.c pointers to functions

Simple.c Simplest C program possible

main ( )

{

}

main is a C keyword.

It is the program entry point.

It does not need to be in column one.

main may take arguments. We will deal with them later.

The empty round brackets ( ) indicate that we aren't going to worry about the argument list at this point.

A C comment is enclosed by /* ……. */

main ( ) /* program entry point */

{ /* start of block, start of scope */

Block body

Block blody

…

Block body

} /* end of block */

{ is the start of scope character
} is the end of scope character

{ and } are referred to as “curly brackets” in this text.

See also "simplest C program possible: Part II full ANSI! compatability" on page 20.2

hello_world.c Simple program with printf output

All C statements end with a semicolon ;

main ( )
{

/* printf is a c subroutine that you get access to through the standard io library */

/* we will cover #include <stdio.h> later */

/* in its simplest form printf takes a character string to display */

/* it may also take other arguments, we will examine these later */
/* printf returns a count of the number of characters it displayed */

/* the count can be ignored */
printf("hello world \n");

}

prog1.c More on Printf

/* stdio.h is the standard input library that provides printf, scanf, and other i/o routines */

/* #include tells the compiler where to look for input/output routines you call */

/* #include < name of .h file > will add that .h file to your compilation module */

#include <stdio.h>

int main ( )

{

/* curly brackets mark the beginning and end of the scope of a compound statement.

A compound statement may be a function body, the body of a loop, the body of a conditional,

several statements, … * /

printf("C Programming\n");

printf("C Programming\n");

}

printf("string to display"); /* string to display is inside quotations” */

/* can provide format specifiers that describe HOW to display things (e.g., as integers, as strings) */

/* if you put in a format specifier you need to provide a variable to satisfy the format specifier */

printf("string format specifier", variables to satisfy format specifiers);

progl.c supplemental variable declaration, printf output, return value

/* to compile with ansi compiler with defaults

acc prog1.c will produce a.out

if (ompile is successful no "success indicator" is generated

if errors, compiler messages will be generated

executable can be run by typing a.out */

/* to compile with ansi compiler and specify executable's name

acc -o progl prog1.c

will produce progl if (ompile is successful */

/* to pass source code through a very picky pre compiler

alint progr1.c

*/

/* curly brackets mark the beginning and end of the scope of a compound statement.

A compound statement may be a function body, the body of
a loop, the body of a conditional, several statements */

/* c is an expression language

every statement returns a value,

which may be discarded or ignored if unneeded */

/* the next program shows that printf returns the number of characters it printed. */

C Programming

value of xyz is 14

C Programming

#include <stdio.h>
int main()

{

/* int declares xyz as a variable of type integer */

int xyz;

/* xyz gets return value from printf */

xyz = printf(“C Programming\n”);

/* %i format specifier says print out the value of xyz as an integer */

printf(“value of xyz is %i \n”,xyz);

/* we can ignore the return value of printf */

/* \n is the newline character */

printf(“C Programming\n”);

} /* program exit point */

Compile, link, run sequence

You can compile C modules to produce object files

You can assemble Assembler modules to produce object files

You can also compile other (e.g., Fortran, Pascal) programs to produce object files

You can then link all these together

ACC stands for ANSI C compiler

Acc name_of_c_file produces executable a.out

.

ANSI C Compiler

c file c file

.o file object file

.asm file assembler file

Link Editor

.for file fortran file

.pas file pascal file

.

Executable

cob file COBOL file

prog2.c comments case sensitivity
#include <stdio.h>

int main ( )
{

/* comments start with slash asterisk

can span several lines, and end with asterisk slash */

int foobar; /* variable names are case sensitive */

/* all C statements except comments are case sensitive

int is OK, INT is not */

/* white space is ignored */

printf(“C Programming\n");
printf("For fun and profit\n"); /* comments can be at the end of a line */

p

Compiler Error

rintf ("Hello /* this is not a comment */ dolly \n");
print/*comment cannot be nested*/f("H1\n");

printf("abc\n"); /* comments that span lines
printf("det\n"); can cause unexpected results… */

/

Compiler Error

* the printf(“det \n”); statement would not be compiled b/c it is inside a comment! */

Printf(“value of foobar is %i\n”,Foobar);

}

Storage Classes

Table I

Type	How Declared	Where Stored	Initial Value	Scope	Lifetime
Auto	Auto keyword or in function or in block	Stack	None	Function or block	Function or block
Static internal	Static keyword in function or block	Heap	Zero if not explicitly initialized	Function or block	Entire life of program
External	Outside all functions	Heap	Zero if not explicitly initialized	Entire program	Entire life of program
Register	Register keyword	A register, if one is available	None	Same as auto	Same as auto
Static external	Static keyword outside all functions	Heap	Zero if not explicitly initialized	Same file after definition	Entire life of program

C supports different storage classes that you can force by using explicit keywords.

prog3.c variable declaration and initialization
#include <stdio.h>

int main( )
{

/* declare an integer */
int x;

/* do not count on uninitialized variables to have a certain value */

/* they could be zero and probably will be zero but, could be ??? */
printf("Unitialized x = %i\n",x);

x = 1 + 2;

printf("x with 1 + 2 = %i\n", x);

}

Different ways to declare and initialize variables

Type_of_variable name_of_variable

Int x;

Float y;

Char c;

type_of_ variable name1, name2, … ;

int x,y,z;

float f1 ,f2;

char c1, /* first char * /

c2; /* another char * /

type_of_ variable name_of_ variable = initial_value;
int a = 7;

float f1 = 6.7f;

type name = initial, name = initial, ... ;
int a = 6, b = 13, c = 12;

prog4.c printf output of variables
#include <stdio.h>

/* this program adds two integer values and */

/* displays the results */

/* it also demonstrates two ways to initialize a variable */

int main( )
{

/* declare variables */

int v l; int v2; int vsum;

/* declare and initialize variable */
int all_in_one = 5;

/* initialize values */
v l = 1;

v2 = 2;

/* compute */

vsum = v l + v2;

/* print result */
printf("The sum of %i and %i is %i\n",vI,v2,vsum);

/* display all in one */
printf("all_in_one => %i \n",all_in_one);

/* case sensitivity error, would not compile */

/* printf("all_in_one => %i \n",ALL_in_one); */

/* printf error * /

print("all_in_one => %i \n",all_in_one);

}

OPERATORS: RETURN VALUE AND SIDE EFFECTS

In C, all operators have a return value and some have "side effects"
A return value isa value given back. For example in the code:

int a;

8= 3 + 4;

The addition operator (+) returns the result of adding the values 3 and 4.

A side effect is a change in a memory location. For example:
int a;

a= 7;

The assignment operator (=) changes the memory location we call 'a' to contain the value 7.

The assignment operator also has a return value, namely the new value of a (in our case 7). In this way we can say:

int a,b,c;

a=b=c=7;

7 is assigned into c, c's new value (7) is assigned into b, etc.

NOTE: any statement that has no side effecvt and who's return value is not used adds zero value
to a program.

3 + 4;

the 3 and 4 are added returning 7 which is discarded (like all intermediate results when no longer
needed). Most compilers would flag a line like 3 + 4; with the warning:

"Statement has no effect"

mathematics operators

addition +

subtraction -
multiplication *

division /

assignment =
incrementing ++
decrementing --

ops.c program to demonstrate c operators
main ( )

{

int i.x:

i = O;

x = i++; /* post increment, return vaule is OLD value, side effect is increment*/

printf("i = %i x = %i \n",i ,x);

i =0;

x = ++i; /* pre increment, return vaule is NEW value, side effect is increment*/

printf("i = %i x = %i \n", i, x);

i = 0;

x = i--; /* post decrement, return vaule is OLD value, side effect is decrement*/

printf("i = %i x = %i \n", i, x);

i = 0;

x = --i; /* pre decrement, return vaule is NEW value, side effect is decrement */

printf("i = %i x = %i \n", i, x);

/* compound assignments: var op= value is the same as var = val op value */
i = 5;

i += 2; /* plus equals, add and assign, same as i = i + 2 */

printf("i = %i \n",i);

i = 5;

i -= 3; /* minus equals same as i = i - 3*/

printf("i = %i \n",i);

i = 5;

i *= 4; /* times equals same as i = i * 4 */

printf("i = %i \n",i);

i = 20;

i /= 2; /* divides equals same as i = i /2 */

printf("i = %i \n",i);

i = 25;

i %= 7; /* mod equals same as i = i % 7*/

printf("i = %i \n",i);

}

Sample Output From ops.c

i= 1 x = O

i=1 x = 1

i= -1 x= O

i= -1 x= -1

i = 7

i = 2

i = 20

i = 10

i = 4

Exercise 1

/* make a file named xone.c */

/* write a C program to compute the following */
/* the result of b squared - 4 times a times c */

/* where a is 5, b is 4, c is 3 */

/* print out the answer * /

/* use variables named a, band c and a variable to hold the result */

/* C does not have a built in square function

nor does it have a "to the power of” operator*/

Solution for Exercise 1

#include <stdio.h>

int main ( )

{

int a, b, c, result;

a = 5;

b = 4;

c = 3;

result = ( b * b) – (4 * a * c);

/* using the ( ) removes doubts about the order of operations... */

printf("%i squared - ( 4 * %i * %i ) => %i \n", b,a,c,result);

}

Exercise 2

/* fix this program by typing it in from scratch

find the syntax errors and fix them as you go (let the compiler find the errors)

until it compiles cleanly and runs cleanly and produces the answer 12 */

#include stdio.h

main

integer i;

do some math * /
i=1+2+3

/* do some more math

i = i + i;

print(i = %m \n, i);

}

/* desired output */
/*

i = 6 inaccurate documentation !!

*/

#include <stdio.h>
main( )

{

int i;

/* do some math * /
i = 1 + 2 + 3;

/* do some more math * /

i = i + i;

printf("i = %i \n", i);

}

/* desired output * /
/*

i = 12

*/

Precompiler:

The precompiler (sometimes called Preprocessor) is the first step in the compilation process. Its purpose is to:

1) remove comments before 'real' compilation

2) perform precompiler statements ( a-k-a Preprocessor directives)

Precompiler statements start with a # as the first non white space character on the line.

We have already seen one:
#include <stdio.h>

This statement asks the precompiler to embed the file stdio.h into our C file at the place where the directive appears.

There are several more that we will examine:

# define perform text subtitution

#if <stmt> conditional include of code

#ifdef <stmt> perform text substitution

#ifndef <stmt> if not defined, include the following code

#else else for any #if

#elseif <stmt> else if for any #if

#endif end of #if block

prog4a.c #ifdef precompiler

main ( )

{

#ifdef AAA

printf("hello from aaa\n");

#endif

#ifdef BBB

printf("hello from bbb\n");

#else

printf("What you don't like bbb?\n");

#endif

#ifndef CCC

printf("defineCCC to stop me before I print again!! \n");

#endif

}

If you compile like this: acc prog4a.c

and run a.out, you see:

What you don't like bbb?

define CCC to stop me before I print again!!!

If you compile like this: acc -DAAA prog4a.c

and run a.out, you see:

hello from aaa

What you don't like bbb?

define CCC to stop me before I print again!!!

If you compile like this: acc -DAAA -DBBB prog4a.c
and run a.out, you will see

hello from aaa

hello from bbb

define CCC to stop me before I print again!!!

If you compile like this: acc -DCCC prog4a.c
and run a.out, you will see

What you don't like bbb?

prog5.c C basic data types

/* acc prog5.c -DCASE1 -o prog5 */

/* acc prog5.c -DCASE2 -o prog5 */

main ( )

{ /* all scalar-variables may be initialized when defined */

/* program to show declaring variables */

/* and initializing variables */

#ifdef CASE 1

	char	c	=	'a';
	double d		=	1.23e+45;
	float	f	=	123.45;
	int	i	=	321;
#endif

/* EXERCISE, change these to valid values */

#ifdef CASE2

double d = 'd';
float f = 2;

int i = 1.23;
char c = d;

#endif

/* display character as character */
printf("c = %c \n",c);

/* display character as integer */
printf("c = %d \n\n",c);

/* display double in scientific */
printf("d = %e \n",d);

/* display double in float or scientific */
/* lets computer decide */

printf("d = %g \n\n",d);

/* display float as floating point */
printf("f = %f\n\n",f);

/* display integer as base ten integer */
printf("i = %i \n",i);

/* display integer as base 16 integer */
printf("i = %x \n\n",i);

}

Fundamental Data Types

To Store A Character

In C a char is just a subtype (skinny) integer. What we normally think of as a character (displayable) is simply the output to the screen from some display function. Something like 'A' is an integer in C whose value is 65 (ASCII code for A). A statement like: printf("%c", 'A');

asks C to display the character whose code is 65.

To Store Integers

char (usualy 1 byte, 8 bits)
short int (at least 2 bytes)

int (usualy the same size as a machine word)
long int (usualy at least 4 bytes perhaps bigger)

To Store Floating Point Numbers
float (at least 4 bytes, 7 significant digits)

double (at least 8 bytes, 15 significant digits, may be larger)
long double (at least 8 bytes, some compilers support 16 bytes)

To Store Unsigned Integers, Logical Values and Bit Arrays
unsigned char

unsigned short int

unsigned int

unsigned long int

To Store Explicitly Signed Ints

signed char

signed short int

signed int

signed long int

If the keyword int is removed, say from signed int, the default data type is int so the statements

signed int and signed are syntactally equivalent

built in operator sizeof(x)

sizeof( type) returns # of bytes in that type
sizeof(variable) returns number of bytes in that variable

Relationships Between Sizes of Variables

1 = sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)
sizeof(float) <= sizeof(double) <= sizeof(long double)

sizeof(char,short,int,long) = sizeof(rsigned) char,short,int,long) = sizeof(Iunsigned) c,s,i,l)

NOTE: The following items were intentionally left to the discretion of the compiler writer:

1) whether the default is signed or unsigned if the programmer does not specify it for (har, short, int or long

2) the exact number of bytes in any data type although minimum ranges have been specified

pg34.c, illustrates sizeof(var)

NOTE: sizes of different types may vary from system to system
main ( )

{

char cl; int il; short sl; unsigned ul;
long int 11;

printf("Size of character is %d \n",sizeof(cl) );
printf("Size of short int is %d \n",sizeof(sl) );
printf("Size of unsigned int is %d \n",sizeof(ul) );
printf("Size of int is %d \n",sizeof(il) );
printf("Size of long int is %d \n",sizeof(ll) );

}

/* sample output */
/*

Size of character is 1
Size of short int is 2
Size of unsigned int is 4

Size of int is 4

Size of long int is 4
*/

/* exercise:

modify this program to find out how many bytes a float and a double consume

*/

PORTABILITY CONCERNS

This is not a bad time to say a few introductory words on the issue of portability.

One of the strongest arguments for making the change to the C language is that of portability. If a program is coded to the ANSI standard, it should be -100% portable if the target platform has

an ANSI compliant C compiler available. However, there have been many groups that have learned the hard way that they need to understand, the ANSI standard in order for their programs to work correctly cross-platform.

It is extremely important to note the following in light of our discussion of data types:
a short integer will be at least 2 bytes, but may or may not be 4

an int will typically be the same size as a machine word, but will be at least 2 bytes
a long int will be at least 4 bytes, but could be longer

Any program that needs to be portable (and still function correctly) should be careful to use these data types correctly. Back in '93 a client/server software group learned this the hard way. Their program, which ran fine on an IBM mainframe, hung their PC (DOS machines) even though it had compiled without error or warning. Their program was riddled with counters of type int (keeping track of the number of records read etc.), which would keep track of counts sometimes reaching 1 million or more. Their mainframe compiler had 4 byte ints, their PC compiler had 2 byte ints.
(RANGE: 2 bytes = 0 to 65535 4 bytes = 0 to 4,294,967,764)

Suggestion: analyze your data first and ...

-if you mean to store 2 byte quantities use a short

-if you mean to store 4 byte quantities use a long

-if you need a data value the size of a machine word (and adjusts cross-platform)

use an int (handy when writing operating system code or interrupt handlers)
-analysis of the data will also help you decide whether you need specify signed or

unsigned, if there is a need to specify it please do so.

One last word for now ...

Many C compilers come with extra libraries supporting sound, fancy graphics, low-level hard-
ware I/O, etc. Please note that these 'add-in' libraries are generally not ANSI standard and are not supplied with many compilers. (does mouse control mean anything on a 3278 attached to a MVS system) It does you little good to have a program that does fancy screen I/O if it cannot be ported to another platform (unless, of course, it is strictly intended for only one platform)

Simplest C program possible: Part II

full ANSII compatability with no compiler warnings or errors

void main (void): /* prototype for main, usually not required, but guaranteed

to work with all ANSI compilers */

void main( )
{

}

OR

/* ANSI header stating return type * /

int main(void); /* prototype for main, usually not required, but guaranteed
to work with all ANSI compilers */

int main ( )
{

return 0;

}

prog6.c mathematics operators, precedence

main ( )
{

/* declare four integers and space for answers */

int a = 1; int b = 2; int c = 3; int d = 4; int ans;

/* precedence of - + *

( ) parentheses

- unary minus + unary plus

++ increment -- decrement

* multiplication

/ division

% modulo

+ addition - subtraction

== equality = equals */

/* print initial values */

printf("a => %i \t b => %i \t c => %i \t d => %i \n\n",a,b,c,d);

/* subtraction example */
ans = a - b;

printf("a - b = %i \n",ans);

/* precedence problem, want addition then multiplication */
ans = a + b * c;

printf("a + b * c = %i \n",ans);

/* precedence example */
ans = ( a + b ) * c;

printf("( a + b ) * c = %i \n",ans);

}

/* sample output */

a => 1 b=> 2 c=>3 d=>4

a – b = -1

a + b * c = 7

( a + b) * c = 9

prog7.c mixed mode arithmetic

/* program demonstrates mathematics, precedence and the difference between integer division */
/* how value is stored is determined by destination data type */

/* and floating division *}

main ( )

{

/* declare and initialize integers */ int a = 7; int b = 2; int int_ans;

/* declare and initialize floats */

float c = 7.0; float d = 2.0; float float ans;

/* print initial values */

printf("a => %i \t b => %i \t c => %f\t d => %f\n\n",a,b,c,d);

printf("integer divided by integer \n");
intans = a / b;

printf("%i / %i = %i \n\n",a,b,int_ans);

printf("float divided by float \n");
float ans = c / d;

printf("%f / %f = %f\n\n",c,d,float_ans);

intans = c / b;
floatans = c / b;

printf(“float divided by integer \n");

printf(" stored in integer %f / %i = %i \n",c,b,int_ans);
printf(" stored in float %f / %i = %f\n\n",c,b,float_ans);

printf("integer divided by a float \n");

int_ans = a / d;
float_ans = a / d;

printf(" stored in integer %i / %f = %i \n",a,d,ineans);
printf(" stored in float %i / %f = %f\n\n",a,d,floaeans);

printf(("-a = %i \n",-a);

printf("-c = %f\n",-c);

}

sample output

a => 7 b => 2 C => 7.000000 d => 2.000000

integer divided by integer

7/2 = 3 .;

float divided by float

7.000000 / 2.000000 = 3.500000

float divided by integer

stored in integer 7.000000 / 2 = 3

stored in float 7.000000 /2 = 3.500000

integer divided by a float

stored in integer 7 /2.000000 = 3

stored in float 7 /2.000000 = 3.500000

-a =-7

-c = -7.000000

prog8.c the modulus (remainder, residue) operator

/* the modulus operator only works on whole numbers*/

main ( )
{

int guzinta;

int rem;

guzinta = 25 /5;
rem = 25 % 5;

printf("5 goes into 25 %i times with remainder %i \n",guzinta, rem);

guzinta = 25 / 7;
rem = 25 % 7;

printf("7 goes into 25 %i times with remainder %i \n",guzinta.rem);

}

output you'll see

5 goes into 25 5 times with remainder 0
7 goes into 25 3 times with remainder 4

Exercise 3
/* Part 1 */

/* write a program that evaluates the following expression */

/* display the result in integer format */

/*

ans = 7 times 9 plus 19 divided by 5 modulo 2

do the multiplication first

the division second
the modulo third
and the addition last

*/

/* Part 2 */

/* write a program that evaluates the following expression */

/* use exponential formats for the numbers */

/* display the result in exponential format */

/* (.000000097 + 2010 ) / ( 89000 * 23) */

Solution for Exercise 3
main ( )

{

int ans;

float a,b,c,d;

float numerator;
float denominator;
float result;

a = 9.7e-8;

b = 2.01e3;

c = 8.9e4;

d = 23.0;

ans = ( 7 * 9 ) + ( ( 19/5 ) % 2);

printf("ans = %i \n",ans );

numerator = a + b;

denominator = c * d;

printf("numerator = %e \n",numerator);

printf("denominator = %e \n",denominator);

result = numerator / denominator;

printf("Result = %e \n",result);

}

Relational (Comparison) Operators

< less than
> greater than

= equivalent to

<= less than or equivalent to
>= greater than or equivalent to
!= not equivalent to

Relational operators are used in relational expressions. A relational expression is defined as anything that can produce a True or False answer. Falsity is defined as zero. Truth is defined as non-zero. A variable by itself can be a relational expression because its value will be examined to see if it is zero or non zero. A relational expression can exist by itself, it does not have to be examined within the context of a decision.

The relational operators return a 1 if true, 0 if false.

/* steve.c August 10, 1993 */
main ( )

{

int x, y, z;

y = 2;

/* y = 3 is a relational expression * /
/* its truth or falsity is assigned to x */

x = y == 3; /* assign to x the result of the comparison */
printf("AAA x = %i y = %i\n",x,y);

y = 3;

/* y == 3 is a relational expression * /
/* its truth or falsity is assigned to x */
x = y == 3;

printf("BBB x = %i Y = %i\n",x,y);

x == y; /* no side effect, return value not used, this does nothing */
printf("CCC x = %i y = %i\n",x,y);

x < y;

printf("DDD x = %i y = %i\n",x,y);

z = x < y;

printf("EEE z = %i x = %i Y = %i\n",z,x,y);

/* sample output */

AAA x= O y = 2
BBB x = 1 y = 3
CCC x = 1 y = 3
DDD x = 1 y = 3
EEE z = 1 x = 1 Y = 3

Run this program through alint and see that it tells you that there are several bugs.

prog9a.c three types of loops

main ( )

{

int sum;
int n;

/* sum and loop counter need to be initialized */
sum = 0; n = -5;

/* while (relational expression) */

/* while loop, check condition at top */

while ( n <= 5 )

{

sum = sum + n;
n = n + 1;

printf("n is %i sum is %i \n",n,sum);

}

printf("WHILE LOOP:sum is %i \n\n\n",sum);

/* do loop, check condition at bottom */

sum = 0; n = -5;

do

{

sum = sum + n;
n = n + 1;

printf("n is %i sum is %i \n",n,sum);

} while ( n, <= 5 );

printf("DO LOOP:sum is %i \n\n\n",sum);

/* for loop, C shorthand to get all loop things on one line */
for ( sum = 0, n = -5; n <= 5; n++ )

{

sum = sum + n;

}

/* print out the results */

printf("FOR LOOP:sum is %i \n\n",sum);

}

progl0.c for loop

/* program to calculate squares * /

main ( )
{

int square;
int n;

printf("TABLE OF SQUARES NUMBERS \n\n");
printf(''\t n \t n squared\n");
printf(''\t---\t----------\n'');

for ( n = 1; n <= 20; n++ )
{

square = n * n;

printf(''\t %i \t %i \n",n,square);

} \t is the tab character

}

TABLE OF SQUARES NUMBERS

n n squared

--- ------------

1 1

2 4

3 9

4 16

5 25

6 36

7 49

8 64

9 81

10 100

11 121

12 144

13 169

14 196

15 225

16 256

17 289

18 324

19 361

20 400

Comparison of Loop Syntax

For a = 1 to 37 by 2

Starting

Condition

Condition To

Continue

increment done after body,

before testing condition

For ( n = 1; n <= 20; n++)

n is initialized to 1 // n = 1

perform test, // if n <= 20

if true, do body

if false, skip body

after body performed, do increment //n++

Exercise: Rewrite the previous example (progl0.c) and replace the for loop with

a while loop, and then a do-while loop.

Exercise: Make the previous program do the table of squares from 10 to 50

by 2's. i.e, 10 12 14 16 ...

Exercise: Make the previous program do the table of squares from 33 to -7

by -3's i.e. 33, 30,27,24 ...

prog11.c for loop scanf input

/* program to calculate squares * /

/* introduces scanf for user input */

main ( )
{

int square;
int cube;
int n;

int user number;

printf("How far do you want to go to? \n");

scanf("%i",&user_number);

printf(''\nYou entered %i \n\n",user_number);

printf("TABLE OF SQUARES & CUBES\n\n");

printf("\t n \t n squared \t n cubed\n");
printf(''\t---\t-----------\t ---------\n");

for (n = 1; n <= user_number; n++)

{

square = n * n;

cube = square * n;

printf(''\t %i \t %i \t\t %i\n",n,square,cube);

}

}

/* EXERCISE: remove the & from &user_number, you will experience a core dump. This is because scanf requires the & on the variable to read the data into. It needs to be passed the address of where to write to */

/* UNIX PROGRAMMER'S HINT: when you have a program with a scanf in it,
do a grep on the file with the scanf as the string to search for. Double check that every scanf has an & associated with it. If you know C shell programming, make a shell script to do the grep and print only the lines that have scanfs and not & */

If the & is left off, and if you use the highest warning level, the compiler should warn you that
you are trying to use the value of the variable user_number before it has been set.

TRY TO GET INTO THE HABIT OF READING ALL WARNINGS FROM THE COMPILER! IT IS CONSIDERED GOOD PRACTICE THAT YOUR PROGRAM WHEN 'DONE' SHOULD CAUSE NO WARNINGS.

EXERCISE: see how large a number you can input and still get the square and cube of. Try to make the integer result go out of range

SCANF "Feature" or "Bug"

scanf always leaves a carriage return in the input stream. If you are mixing line input via scanf and character input via getchar, you will have to eat the
carriage return left behind by the scanf or you will have to flush the input stream

89

cr

23

cr

'p'

cr

Using scanf for Input

scanf(" format_specifier" , address of variable to satisfy format_specifier);

prog12.c nested for loops

''Ukranian doll for loops" ''Matreshka''

/* program to calculate squares * /

/* introduces nested for loop */

main ( )

{

int square, n, user_number, counter, i;

/* this loop will be done four times */

/* counter will take on the values, 1 234 */

for (counter = 1; counter < 5; counter++ )

{

printf("How far do you want to go to? \n");

scanf("%i",&user_number);

printf(''\tYou entered %i \n\n",user_number); /* \f form feed */

printf("TABLE OF SQUARES \n\n");

printf(''\t n \t n squared\n");

printf(''\t---\t----------\n'');

/* this loop will be done user_number times */

/* n will take on values 1 through user_number */

for (n = 1; n <= user_number; n++ )

{

square = n * n;

printf(''\t %i \t %i \n",n,square);

} /* end of n loop */

} /* end of counter loop * /

printf(''\n\n'');

/*COMMON PROGRAMMING MISTAKES */

for ( i = 0; i < 5; i++ )

{

printf("outer i = %i \n",i);

/* using same loop counter in a nested loop */

for ( i = 6; i < 9; i++ )

{

printf("inner i = %i \n",i);

}

printf(“\n\n”);

for ( i = 0; i < 5; i++ )
{

printf("outer i = %i \n",i);

/* changing value of loop variable */

i += 7;

}

} /* end main */

Assume i and j are ints
What Would be Printed?
for ( i = 0; i < 5; i ++ )

{ for (j = 5; j > 3; j-- )
{

printf("%i %i\n" .i.j);
}

}

Assume x and m are ints
x = 5;

while ( x < 10) {

m = x * 10;
do {

printf("%i %i \n" .x.m);
m=m+ (m/2);

} while ( m < 200 );
x = x + 2;

}

prog13.c while loop

/* while loop * /

/* introduces \a, ansi alert character* /

main ( )
{

int i;

int sum = 0;

i = -5;

while ( i <= 5 )

{

printf(“\a i = %i \n",i);

sum += i;

i++;

}

printf("Sum from -5 to 5 is %i \n",sum);

/* COMMON PROGRAMMING MISTAKE */
/* Infinite LOOP */

i = 1;

EVERY C statement returns a value that may be used or ignored

THE RETURN value of an assignment statement is the value assigned
while ( i = 1 )

{

printf(" i = %i \n",i);

i++;

printf(" i = %i \n",i);

}

/* UNIX PROGRAMMER HINT */

/* BEFORE COMPILING, AND ESPECIALLY BEFORE RUNNING */
/*

grep your file for all lines that have if, while, for in them
double check that you have = where = is needed, and not =
many programmers replace == with some other defined value
see #define statement later

*/

/* add this line to top of program
#define MYEQ ==

then change the = in the while ( i = 1 ) to while ( i MYEQ 1 ) */

prog14.c while loop for secret number guessing

/* while loops */

/* program to ask for guesses until they get it right */

main ( )

{

int guess = -1;

int secret = 7;

int count of'guesses = 0;

printf("Try to pick a number from 1 to 10 \n");

/* possible infinite loop if user is real idiot */

while ( guess != secret)

{

count of'guesses++:

printf("Enter a guess \n");

scanf ("%i",&guess);

printf(''\n You entered %i \n" ,guess);

} /* end while */

printf(“You got it after %i tries \n",count_of_guesses);

}

prog15.c while loop vs. do loop

/* program to let user guess secret number */

/* shows difference between while loop and do loop */

main ( )

{

int guess;

int secret = 7;

int count_of_guesses = 1;

printf("Try to pick a number from 1 to 10 \n");

/* possible infinite loop if user is real idiot */

/* need to preinitialize value for while loop */

printf("Enter guess #%i\n",count_oCguesses);

scanf ("%i",&guess);

printf(''\n You entered %i \n" ,guess);

while ( guess ! = secret)

{

printf("WRONG\n");

CONTROL will return from the system statement when the entire

command has been completed. IF THE command was placed in the background
control will return as soon as the placement has occurred

system ("usr/demo/SOUND/play lusr/demo/SOUND/sounds/laugh.au");
count_ of_guesses++:

printf("Enter guess #%i\n",count_of_guesses);
scanf ("%i",&guess);

printf(''\nYou entered %i \n",guess);

} /* end while */

printf("You got it after %i tries \n",count_oCguesses);

printf("Try to pick a number from 1 to 10 \n");
count_of_guesses = 0;

secret = 3;

/* do not need to preinitialize value for do loop */
do

{

count_of_guesses++;

printf("Enter guess #%i\n",count_of_guesses);
scanf ("%i",&guess);

printf(“\n You entered %i \n" ,guess);

if ( guess != secret)
{

printf("WRONG\n");

system (“/usr/demo/SOUND/play /usr/demo/SOUND/sounds/laugh.au");

} while ( guess != secret );

printf("You got it after %i tries \n",count_of_guesses);

}

Exercise 4

/* write a program to compute and print the first ten * /
/* factorial numbers */

/* desired output is a table */

/* 1! 1 */

/*2! 2 */

/*3! 6 */

/* ... */

/* 10! 3628800 * /

If your program is more than 15 lines(of code, not counting comments) it is going the wrong
direction.

HINT: mathematical identity N! = (N-I)! * N

Solution for Exercise 4

main ( )

{

int i, factorial;

factorial = 1;

for ( i = 1; i <= 10; i++)

{

factorial = factorial * i;

printf(“%i!/t%i\n”,i, factorial);

}

}

Exercise 5

/* write a c program to input an integer as an integer* /

/* print out the number, one digit per line */

/* i.e. input 1234 */

/* output 4 */

/* 3 */

/* 2 */

/* 1 */

Solution for Exercise 5

main( )
{

int i;

int outnum;

printf("Input number please \n");
scanf("%i" ,&i);

while (i > 0)
{

outnum = i % 10;
printf("%i\n" ,outnum);
i = i / 10;

}

}

C if if else

if .c
main ( )

{

int i;

printf("enter a number \n");

scanf("%i",&i);

if (i < 100)

{

printf("%i is less than one hundred \n",i);

}

printf("After the first if statement\n");

if (i < l0)
{

printf("%i is less than ten \n",i);

}

else

{

printf("%i is greater than or equal to ten\n",i);

}

}

if ( relationalexpression )

{

execute if re TRUE

•••

}

else /* must follow immediately */

{

execute if re FALSE

}

prog16.c math.h include file

/* if statement */

/* math.h contains mathematical functions like sqrtO */

#include <math.h>

main ( )

{

float number;
float square_root;

printf(''\n\nType in a number \n");
scanf("%f”,&number);

printf(''\nYou entered %f\n",number);

if ( number < 0 )
{

printf("Can't get square root of negative number \n");

}

else

{

square_root = sqrt(number);

printf("The square root of %f is %f\n",number,square_root);

}

printf'(“Program completed \n");

}

/* EXERCISE remove the #include <math.h> line and see what you get */

/* some (but not all) of the math functions available

for a complete list, consult your compiler's documentation

ceil(x) floor(x)

sin(x) cos(x) tan(x) asin(x) acos(x) atan(x)
sinh(x) cosh(x) tanh(x)

exp(x) log (x) loglO(x) pow(x,y)

*/

prog19.c logical operators and relational expressions

/* precedence of logical operators and brackets * /
/*

< less than

<= less than or equal to

> greater than

>= greater than or equal to

== equality

!+ inequality

&& logical and

|| logical or

main ( )

{

int score;

printf("Enter the score\n");
scanf("%i",&score);

printf("You entered %i\n",score);

if ( score < 0 || score> 100 )

printf(“Impossible score\n”);

else

{

if ( score >= 0 && score < 50 )

printf("F\n");

else

{

if ( score >= 50 && score < 70)

printf(“D\n”);

else

{

if ( score >= 70 && score < 80)

printf(“C\n”);

else if ( score >= 80 && score < 90)

printf(“B\n”);

else if (score >= 90 && score <= 100)

printf(”A\n”);

else

printf(“no way to get here \n”);

}

}

}

}

if ( relational expression)

relational expression evaluates to TRUE or FALSE

if ( ( r e l) || ( r e 2) )

|| is the logical or operator

re1	re2	result
t	t	t
t	f	t
f	t	t
f	f	f

if ( relational expression)

relational expression evaluates to TRUE or FALSE

if ( ( re1) && ( re2) )

&& is the logical and operator

rel	re2	result
t	t	t
t	f	f
f	t	f
f	f	f

prog20.c complex decision structures

#define IBM 1

#define MER 2

#define MMD 3

#define QUIT 4

main ( )
{

int stock symbol;

char p_or_c;

char cr;

printf(''\nEnter stock symboI\n");

printf(" 1 IBM\n"); printf("2 MER \n”);

printf("3 MMD\n"); printf("4 QUIT \n”);

scanf("%i",&stock_symbol );

scanf("%c",&cr);

printf("You entered %i\n",stock_symbol);

if ( stock symbol == IBM )

printf("%.2f\n",53.25);

else if ( stock_symbol == MER)

printf("%.2f\n",71.75);

else if ( stock_symbol == QUIT )

printf("YOU SELECTED QUIT\n");
else if ( stocksymbol == MMD )

{

printf("(P)referred or (C)ommon?\n");

scanf("%c",&p_or_c );

scanf("%c",&cr);

if (p_or_c == 'P' )
{

printf("Preffered 22.5\11");

}

else if (p_or_c == 'c' )
{

printf(“Common 21.25\11");

else

printf("Unknown character \n");

}

else

printf("Unknown symboI\n");

}

switch (discreet valued variable)

{

case discreet value:

•••

•••

break;

case discreet value:

•••

•••

break;

•••

•••

default:

•••

•••

break;

}

prog21.c switch statement

#include <string.h>

#include <ctype.h>

#define IBM 1
#define MER 2

#define MMD 3
#define QUIT 4

int stock_symbol;
char p_or_c;

char cr;

printf(“\nEnter stock symbol\n");

printf(" 1 IBM\n");

printf("2 MER\n");

printf("3 MMD\n");

printf("4 QUTI\n");

scanf("%i",&stock_symbol );
scanf("%c",&cr);

printf(“You entered %i\n",stock_symbol);

switch ( stock_symbol )

{

case IBM:

Continue reading this ebook at Smashwords.
Download this book for your ebook reader.
(Pages 1-108 show above.)