Introduction to C Language

ELET 2300

Student’s Handout

University of Houston

College of Technology

Dr. Heidar Malki

· Turbo C

- Command line system

- Integrated Development Environment or IDE

In this system all the necessary operations for the program development are available in unified

screen display with menus and windows.

· History of C

C is created by Dennis Ritchie of Bell labs in 1972. It came from Thompson’s B language.

· General features:

1) C is designed to work with hardware

2) C offers many programming shortcuts

· Advantages of C:

1) Design features

2) Efficiency

3) Portability

4) Power and flexibility

5) Programming orientation

6) Well structured

Potentially Disadvantageous

 

· Why use C

It provides the convenience of high level langauge such as BASIC or Pascal, while allowing the close control of a computer’s hardware and peripheral that assembly language does.

· What equipment you need to use

1) Hardware

- IBM PC, XT, AT or compatible or IBM PS/2 series

- Mainframe, UNIX system

2) Software

- Operating system: MS-DOS or PC-DOS

- UNIX system: vi or emacs editor

- Compiler for PC: Microsoft C/C++ or Turbo C/C++

for Mainframe: UNIX operating system

- with 2 windows: Edit window (top)

Message window (bottom)

- You can start typing your program.

key.

During compiling, two more files will be generated

· Debugging a program

Once you compile a program, you may get either of these cases

- Errors

- Success

Once you have error message on the bottom of the window press any key, you will see edit window with your program, and one character (or the entire line) will be highlighted.

Steps of programming

1) Define the program objectives

2) Design the program

3) Write the code

4) Compile

5) Run the program

6) Test and debug the program

7) Maintain and modify the program.

 Back to Top

Basic structure of C programs

#include <stdio.h>

void main(void)

{

printf("This is an example of a C program.\n");

/* simple.c */

#include <stdio.h>

void main (void)

{ int num; /* define a variable called num */

num = 1; /* assign a value to num */

printf("I am a simple "); /* use the printf() function */

printf("computer. \n");

printf("My favorite number is %d because ", num);

printf("it is first. \n");

I am a simple computer.

printf(" My favorite number is %d because ",num);

/* A Sample Program

Meant to illustrate the format of a C listing */

#include <stdio.h> /* Compiler directive */

void main(void) /* Beginning of function */

{ int quiz; /* Declaration of a variable */

quiz = 20; /* Assignment */

/* Displays on screen */

printf("A perfect quiz is %i points.\n", quiz);

printf("Will I get perfect scores?\n");

A perfect quiz is 20 points.

· Declarations

In C all variables must be declared and you must show what "type" each variable is:

int num, sum, all;

· Data types can be classified into:

1) Integers

2) Characters

3) Floating points

· Name choice: preferably up to 8 characters and use meaningful names

names $johnson

array1 1array

You need to be carefull for a system with upper limit of 8 characters.

· Reasons to declare variables

1) It is easier for a reader to understand about the program.

2) It encourages you to plan before you start writing a program

3) It helps prevent misspelled variable names

Ex:

float diameter=20.0;

/* two_func.c */

#include <stdio.h>

void main (void)

{ printf("This program will call another function.\n");

printf("What’s your name?\n");

name();

printf("Yes, I got your name. \n ");

}

void name (void)

{

printf("My name is John! \n ");

printf("You have a nice name. \n ");

/* A program to print a triangle */

#include <stdio.h>

void triangle (void) {

printf(" *\n ***\n*****\n");

}

void main (void) {

printf("Wait for it folks...\n");

triangle();

printf("That's all folks!\n");

Wait for it folks...

*

***

*****

· Debugging

- Syntax errors are result of not following C’s rules

- Semantic errors or logical errors

are errors in meaning. You need to multiply A1 and A2, but instead you multiply them, you add them together.

/* nogood.c a program with errors */

#include <stdio.h>

void main (void)

(

int n, int n2, int n3;

n=5;

n2=n*n;

n3=n2*n2;

printf(" n=%d, n squared=%d, n cubed=%d \n ", n, n2, n3);

- Compile for syntax error

- Trace a program for semantic/logical errors

- Debug programs

Data on C

· int :

The int type is signed integer, which means it must be whole number and can be positive, negative, or zero.

Ex: int : 42, -32, 0

range : -32768 to +32767 on IBM PC

byte: 2 byte word (16 bits) to store an int.

Initializing a variable:

Type int constant:

Normally, C assumes integers as decimal.

#include <stdio.h>

void main (void)

{ int ten = 10;

printf("%d minus %d is %d \n ", ten, 2, ten-2);

void main (void)

{ int x = 100;

printf("Dec=%d, Octal=%o, Hex=%x \n ", x, x, x);

Other integer types

2) long int

#include <stdio.h>

void main (void)

{ int i = 32767;

printf("%d, %d, %d \n ", i, i+1, i+2);

Type of characters

are used to store characters such as letters and punctuation marks.

Octal ASCII code

Special escape sequences see p.61

Back to Top

Ex: Writing an interactive program.

#include <stdio.h>

void main (void)

{ char ch;

printf("please enter a character\n");

scanf("%c", &ch);

printf("The code for %c is %d. \n ", ch, ch);

Please enter a character

B <cr>

· Type float and double

Allows you to represent decimal fractions and scientific notation to express very large and very small numbers.

Number Scientific Notation Exponential Notation

10000000 = 1.0x10⁶ = 1.0 e6

532.23 = 5.3223 x 10² = 5.3223 e2

.00011 = 1.1x10^-4 = 1.1 e-4

32 bits are used to store floating point numbers

- double floating point type use 64 bits

- long double floating point type provide even more precision than double

float area;

double mass;

long double national_gross;

include <stdio.h>

void main (void)

{ float time = 27.250000;

printf("time = %f \n ", time);

/*a number following the decimal point is for the field_width. */

time = 27.250000

#include <stdio.h>

void main (void)

{ float f, g, radius, Avogadro;

f = 2.8;

g = -1.684;

radius = f + g;

Avogadro = 6.02e23;

printf("%f %6.3f %8.2f\n", radius, -12.81963, Avogadro / 1e19);

printf("%e %6.3e %8.2e\n", radius, -12.81963, Avogadro / 1e19);

printf("%g %6.3g %8.2g\n", radius, -12.81963, Avogadro / 1e19);

}

1.116000 -12.820 60200.00

1.11600e+00 -1.28e+01 6.0e+04

1.116000 -12.820 60200.00

1.116000e+00 -1.282e+01 6.02e+04

Ex: Field width

printf("age is %2d ", age);

#include <stdio.h>

void main (void)

{ float salary;

printf("Enter your desired monthly salary: ");

printf("$_________\b\b\b\b\b\b\b\b\b\b ");

scanf("%f ", &salary);

printf("\rGee!\n ");

printf("\n\t $%.2f a month is $%.2f a year. ", salary, salary*12.0);

Enter your desired monthly salary: $3000.00

#include <stdio.h>

void main (void) {

int dollars, cents;

cents = 12705;

dollars = cents / 100;

cents = cents % 100;

printf("$%d.%2.2d\n", dollars, cents);

$127.05

A possible problem using scanf:

printf("Enter your desired monthly salary: \n ");

Solution:

fflush () will flush the content of the buffer.

Character Strings and Formatted Input/Output

· Character strings:

- Strings are stored in an array of char type.

- An array is an ordered sequence of data elements of one type.

· Type of arrays:

- One dimensional

- Two dimensional

- Multi dimensional

· How to declare strings

/* praise.c */

#include <stdio.h>

#define PRAISE "my Dear, that’s a good name! "

void main (void)

{

char name[50];

printf("What’s your name?\n ");

scanf("%s", name);

printf("Hello, %s %s \n ", name, PRAISE);

What’s your name?

Steve <cr>

Hello, Steve my Dear, that’s a good name!

Preprocessor directives:

symbolic representation for constants.

your file at the location of the directive.

· How to read the phrase as string:

· String vs Character

String 1) is enclosed by double quotation marks.

#define PRAISE "my Dear, that’s a good name!"

length = 28.

#define PRAISE "my Dear, that’s a good name!"

...

size = sizeof(PRAISE); size = 29

int_size = sizeof(int); int_size = 2

string.

#include <stdio.h>

#define PRAISE "my Dear, that’s a good name!"

void main (void)

{ char name[50];

printf("What’s your name? \n");

scanf("%s", name);

printf("Hello, %s %s \n", name, PRAISE);

printf("Your name has %d letters. It occupies %d"

"memory cells.\n", strlen(name), sizeof(name));

printf("The phrase of PRAISE has %d letters",strlen(PRAISE));

printf("and occupies %d memory cells.\n",sizeof(PRAISE));

What’s your name?

Steve <cr>

Hello, Steve my Dear, that’s a good name!

Your name has 5 letters occupies 50 memory cells.

Back to top

· Constant and the C preprocessor

PI = 3.14159;

#define BEE ‘B‘

If you have different programs that use the same set of constants.

/* printout.c */

#include <stdio.h>

#define PI 3.141593

void main (void)

{ int number = 5;

float ouzo = 13.5;

int cost = 3100;

printf("The %d women drank %f glasses of ouzo.\n", number, ouzo);

printf("The value of PI is %f \n. ", PI);

printf("Farewell! Thou art too dear for my possessing,\n");

printf("%c%d\n", ‘$‘, 2*cost);

The 5 women drank 13.500000 glasses of ouzo.

The value of PI is 3.141593.

Farewell! Thou art too dear for my possessing,

See table 4.2 & 4.3 for conversion specification modifiers.

#include <stdio.h>

void main (void)

{

int data1 = 100;

float data2 = 1256.56;

printf("%2d\n", data1);

printf("%10d\n", data1);

printf("%-10d\n", data1);

printf("%3.1f\n", data2);

printf("%10.3e\n", data2);

printf("%10.2\n", data2);

printf("%010.2\n", data2);

100

_______100

100_______

1256.6

1.257e+03_

___1256.56

void main (void)

{ printf("%x %X %#x \n ", 31, 31, 31);

printf("**%d ** %d**%d**\n", 42, 42, -42);

printf("**%5d**%5.3d**%05d**%05.3d**\n", 6, 6, 6, 6);

1f 1F 0x1f

**42 ** 42**-42**

It returns the number of characters it printed. The counts includes all the printed characters, including

the spaces and the unseen newline character.

void main (void)

{ int n = 212;

int rv;

rv = printf("%d F is water’s boiling point.\n", n);

printf("The printf function printed %d characters. \n", rv);

212 F is water’s boiling point.

* Can be used as a field width argument in the printf ().

#include <stdio.h>

void main (void)

{ unsigned width, precision;

int number = 256;

double weight = 242.5;

printf("What field width? \n");

scanf("%d", &width);

printf("The number is: %*d \n", width, number);

printf("Now enter a width and precision\n");

scanf("%d %d", &width, &precision);

printf("weight = %*.*f\n", width, precision, weight);

What field width

6

The number is:___256

Now enter a width and a precision

8 3

It is useful, if a program needs to read just certain items from a file that has data arranged in a standard format.

converts string input into various forms of integer, floating point number, characters, and string.

Rules: For reading values for one of the basic variables types, preceed the variable name with & ,

except for a string variable.

#include <stdio.h>

void main (void)

{ int event;

char heat;

float time;

printf("Type event number, heat letter and time ");

scanf("%d %c %f ", &event, &heat, &time);

printf("The wining time is heat %c ", heat);

printf("of event %d was %.2f. ", event, time);

Type event number, heat letter and time 4 B 36.34

- scanf reads input one character at a time and it skips over whitespace character until it finds a non

whitespace character.

- scanf can’t read more than one word for one %s specifier.

- scanf() places the string in the designated array, it adds the termination ‘\0‘ to convert the input to a C

string.

· scanf return value

- scanf returns the value 0 when you type a nonnumeric string when the function expects a number.

- scanf return EOF if it detects the condition known as end of file.

- %*d couses that function to skip over corresponding input.

#include <stdio.h>

void main (void)

{ int n;

printf("Please enter three integers:\n ");

scanf("%*d %*d %d", &n);

printf("The last integer was %d\n ", n);

Please enter three integers

25 35 40 <cr>

Macro: is simply a string of tokens that will be substituted for another string of tokens.

#include <stdio.h>

#define SQUARE(x) x*x

#define PI 3.141592

#define CIRCLE_AREA(r) PI*SQUARE(r)

void main (void)

{ float area;

float radius;

printf("Give me a radius =>");

scanf("%f", &radius);

area = circle_area(radius);

printf("The area of a circle with a radius of %f \n", radius);

printf("is %f square units. ", area);

Give me a radius => 3

The area of a circle with a radius of 3.000000

the returns key is struck.

#include <stdio.h>

void main (void)

{

char name[81];

puts("Enter your name:");

gets(name);

puts("Greetings, ");

puts(name);

Enter your name:

Jack Jefferson <cr>

Greeting,

ch = (char)getchar(); /*takes a character from keyboard and store it in ch*/

#include <stdio.h>

void main (void)

{ int num = 336;

int mnum = -336;

printf("%d %u %d %u \n", num, num, mnum, mnum);

printf(%d %c \n", num num);

printf(%ld %d \n", 65616, 65616);

336 336 -336 65200

336 P

#include <stdio.h>

void main (void)

{ float z, a, b, f, h, x;

printf("Enter your data below:\n");

printf("a: "); scanf("%f", &a); fflush(stdin);

printf("b: "); scanf("%f", &b); fflush(stdin);

printf("f: "); scanf("%f", &f); fflush(stdin);

printf("h: "); scanf("%f", &h); fflush(stdin);

printf("x: "); scanf("%f", &x); fflush(stdin);

z = (a+b)*(a+b) / (f - (x+1)/(h-4));

printf("z = %f\n", z);

Enter your data below:

a: 4.0

b: -6.0

f: 9.0

h: 7.0

x: 4.0

Back to top

Operators in C

1) Assignment operator: =

sum = total;

2) Addition operator: +

3) Subtraction operator: -

4) Sign operators: - and + (is also called unary operator)

5) Multiplication operator: *

6) Division operator: /

int divide;

float division;

/* poor form */

divide = 5/3; => gives you divide=1

/* better form */

· Operator precedence

sum = 11 + 12 / 3

sum = 11 + 4

top = score = -7 * 6 + (4 + 3 * 5)

top = score = -7 * 6 + (4 + 15)

top = score = -7 * 6 + 19

top = score = -42 + 19

· Modulus operator: %

It gives the remainder that results when the integer to its left is divided by the integer to its right.

Modulus operator doesn’t work with floating point numbers.

· The incrementing operator: ++

It increments variable’s value by one.

· The decrementing operator: --

It decrements variable’s value by one

#include <stdio.h>

#define OFFSET 32.0

#define SCALE 1.8

void main (void)

{

float centigrade, fahrenheit;

printf("Centigrade Fahrenheit\n");

centigrade = 0.0;

while(centigrade < 200.0)

{ /* start of while loop */

fahrenheit = SCALE * centigrade + OFFSET;

printf("%10.1f %15.2f\n ", centigrade, fahrenheit);

centigrade = centigrade + 1;

} /* end of while loop */

....

centigrade = 0.0;

while(centigrade < 200.0)

{ fahrenheit = scale * centigrade + OFFSET;

printf("%10.1f %20.2f\n", centigrade, fahrenheit);

centigrade++;

g = 4 and a = 2

g = 2 and a = 2

precedence of ++ and -- operators are ranked after parantheses:

x = 3;

y = 6;

result = (3 + 6) / 4

result = 9 / 4

When using ++ and -- operator follow the following rules:

1) Don’t use ++ or -- operator on a variable that is part of more than one argument of a statement.

2) Don’t use increment(++) or decrement(--) operators on a variable that appears more than once in an expression.

n = 3;

y = n++ + n++;

y = 6 or y = 7

Expression and statement

- Expression: an expression is a combination of operators and operands

if(a > 5)

- Compound statements (Blocks)

A compound statement is two or more statements grouped together by enclosing them in braces.

sum = 0;

initial = 0;

while(initial++ < 5)

{ sum = sum + initial;

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

}

initial ++: ++initial:

sum = 1 sum = 1

sum = 3 sum = 3

sum = 6 sum = 6

sum = 10 sum = 10

sum = 15

1) In any operation involving two types, both values are converted to the "higher" ranking of the two

types.

2) In an assignment statement, the final result of the calculations is converted to the type that is being

assigned a value promotion or demotion.

int i;

i = 1.6 + 1.7;

The cast operator converts the following value to the type specified by the

enclosed keyword(s).

Ex:

Loops and conditional statement in C

· The if statement

Form: if (expression)

statement;

#include<stdio.h>

void main (void)

{ char ch;

scanf("%c", &ch);

if (ch == ‘y‘)

printf("you typed y\n");

form: if (expression)

statement1;

else

statement2;

#include <stdio.h>

void main (void)

{ char ch;

scanf("%c", &ch);

if(ch == ‘y‘)

printf("You typed ‘y‘.\n");

else

printf("You didn’t type ‘y ‘.\n");

if(x>0)

{ printf("incrementing x:\n");

x++; }

else

· Nested if statement

form: if expression1

if expression

#include <stdio.h>

void main (void)

{ int x, y;

if(x>0)

if(y<10)

printf("your number is between 1-9 ");

#include <stdio.h>

void main (void)

{ float number;

printf("\nGive me a number from 1 to 10 => ");

scanf("%f", &number);

if(number > 5.0)

printf("Your number is greater than 5 \n");

else

printf("Your number is less than or equal to 5 \n");

printf("The value of your number was %f" number);

#include <stdio.h>

#define SPACE ‘ ‘

void main (void)

{ char ch;

ch = (char) getchar();

while(ch!=‘\n‘) /* while not end of line */

{ if (ch == SPACE)/* leave the space */

putchar(ch); /* character unchanged */

else

putchar(ch+1); /* print other character */

ch = getchar();

}

while((ch=getchar()) != ‘\n‘)

{ if (ch == SPACE)

putchar(ch);

else

putchar(ch+1);

if (number > 6)

if (number < 12)

printf("You are close! \n");

else

Output

5 (none) Sorry you lose a turn

10 You are close! You are close!

if(number > 6)

{ if (number < 12)

printf("you are close!\n");

}

else

Back to top

Back to top

Form 3

if (expression1)

statement1

else if (expression2)

statement2

else

statement3

#include <stdio.h>

void main (void)

{ float num1, num2;

char op;

while(1)

{ printf("Type number, operator, number\n");

scanf("%f %c %f", &num1, &op, &num2);

if(op==‘+‘)

printf("=%f", num1+num2);

else if(op==‘-‘)

printf("=%f", num1-num2);

else if(op==‘*‘)

printf("=%f", num1*num2);

else if(op==‘\‘)

printf("=%f", num1\num2);

printf("\n\n");

}

The else-if construction is a reformating of nested if-else statement.

Order of evaluation: they are evaluated from left to right. Evaluation stops as soon as something is discovered that renders the expression false.

Priorities of logical operators:

! (same as increment operator)

&& (above assignment)

#include <stdio.h>

#define PERIOD ‘.‘

void main (void)

{ char ch;

int char_count = 0;

while((ch= (char) getchar()) != PERIOD)

if (ch!=‘ ‘ && ch != ‘\n‘ && ch!=‘\t‘)

char_count++;

printf("There are %d non-white space characters\n ", char_count);

logical operators <cr>

combine relationships. <cr>

There are 36 non-whitespace charaters <output from computer>

#include <stdio.h>

void main (void)

{ int charcnt = 0;

int wordcnt = 0;

char ch;

printf("Type in a phrase:\n");

while((ch=getchar()) != ‘\r‘)

{ charcnt++;

if(ch==‘ ‘)

wordcnt++;}

printf("character count is : %d\n", charcnt);

printf("Word count is %d\n ", wordcnt+1);

Type in a phrase

cat and dog <cr>

character count is 11

switch(integer expression)

{ case 1: statement1;

break;

case2: statement2;

break;

case 3: statement3;

break;

default: statement4;

The switch labels must be type integer constant or constant expressions. You can’t use a variable for a label. The expression in the parantheses should be one with an integer value. Break is used to escape from a loop.

#include <stdio.h>

void main (void)

{ float num1, num2;

char op;

while(1)

{ printf("type number, operator, number \n");

scanf("%f %c %f", &num1, &op, &num2);

switch(op)

{ case ‘+‘: printf("=%f", num1+num2);

break;

case ‘-‘: printf("=%f", num1-num2);

break;

case ‘*‘: printf("=%f", num1*num2);

break;

case ‘/‘: printf("=%f", num1/num2);

break;

default: printf("Unkown operator ");

}

printf("\n\n");

}

#include <stdio.h>

void main (void)

{ int i = 0;

while(i<3)

{ switch(i++)

{ case 0: printf("Merry");

case 1: printf("Merr");

case 2: printf("Mer");

default:printf("Oh no!"); }

putchar(‘\n‘);

}

MerryMerrMerOh no!

MerrMerOh no!

The continue statement

This statement can be used in the three loop forms but not in a switch. Continue causes the rest of an iteration to be skipped and the next iteration to be started.

while((ch= (char) getchar()) != ‘\n‘)

if(ch==‘\t‘)

break;

while((ch= (char) getchar()) != ‘\n‘ && ch!=‘\t‘)

while((ch= (char) gethcar()) != ‘\n‘)

{ if (ch== ‘\t‘)

continue;

putchar(ch);

while((ch= (char)getchar()) != ‘\n‘)

if(ch != ‘\t‘)

judiciously. If you have goto all over your program, then there is no meaning for the C language to

have a loop structure.

...

if(ibex > 14)

goto exp1;

sheds = 2;

goto exp2;

exp1: sheds = 3;

if(ibex > 14)

sheds = 3;

else

sheds = 2;

help = 2 * sheds;

/* Program to read hours worked for each of a company's employees, and print the salary owing to each one. */

#include <stdio.h>

void main (void)

{ float hours, salary;

printf("Enter hours worked for an employee (-1 to finish): ");

scanf("%f", &hours);

while (hours != -1.) {

if (hours <= 40.)

salary=hours*25.; /*$25/hour up to 40 hours*/

else

salary = 40. * 25. + (hours - 40.) * 35.;

/*$25/hour for first 40, then $35/hour*/

printf("Salary is %.2f\n\n", salary);

printf("Enter hours worked for an employee (-1 to finish): ");

scanf("%f ", &hours);

}

}

Output

Enter hours worked for an employee (-1 to finish): 30

Salary is 750.00

Enter hours worked for an employee (-1 to finish): 40

Salary is 1000.00

Enter hours worked for an employee (-1 to finish): 1

Salary is 25.00

Enter hours worked for an employee (-1 to finish): 0

Salary is 0.00

Enter hours worked for an employee (-1 to finish): -1

#include <stdio.h>

void main(void)

{ float weight, price = .2;

printf("Enter weight of apple: ");

scanf("%f", &weight);

printf("Ajax ");

if (weight > 10.)

{ printf("Premium ");

price += .1; }

else

if (weight > 8.) /* Brace not necessary */

printf("Juicy ");

else

if (weight > 6.)

{ printf("Snack ");

price -= .05; }

else

{ printf("Cooking ");

price -= .1; }

printf("Apple. $%4.2f.\n", price);

Enter weight of apple: 6

Ajax Cooking Apple. $0.10.

Enter weight of apple: 10

#include <stdio.h>

void main(void)

{ float weight, price = .2;

printf("Enter weight of apple: ");

scanf("%f", &weight);

printf("Ajax ");

if (weight > 10.)

{ printf("Premium ");

price += .1; }

else if (weight > 8.)

{ printf("Juicy "); /* Brace necessary? */

} /* Brace necessary? */

else if (weight > 6.)

{ printf("Snack ");

price -= .05; }

else

{ printf("Cooking ");

price -= .1; }

printf("Apple. $%4.2f.\n", price);

Enter weight of apple: 6

Ajax Cooking Apple. $0.10.

Enter weight of apple: 10

#include <stdio.h>

void main(void)

{ float price;

char grade;

printf("Enter grade of apple: ");

scanf(" %c", &grade);

printf("Ajax ");

switch (grade)

{ case 'P':

case 'p':

price = .3;

printf("Super ");

break;

case 'J':

case 'j':

price = .2;

printf("Excellent ");

break;

case 'S':

case 's':

price = .15;

printf("Delicious ");

break;

default:

price = .1; }

printf("Apple. $%4.2f.\n", price);

Enter grade of apple: p

Ajax Super Apple. $0.30.

Enter grade of apple: J

Ajax Excellent Apple. $0.20.

Enter grade of apple: s

Ajax Delicious Apple. $0.15.

Enter grade of apple: Q

Ajax Apple. $0.10.

Looping

While loop

Form:

while (expresssion)

body of while loop

#include <stdio.h>

void main (void)

{ long num;

long sum = 0L;

int status;

printf("Please enter an integer to be summed ");

printf("Enter ‘q‘ to quit\n");

status = scanf("%ld", &num);

while(status == 1)

{ sum = sum + num;

printf("Please enter next integer to be summed ");

printf("Enter ‘q‘ to quit \n ");

status = scanf("%ld", &num);

}

printf("Those integers sum to %ld\n ", sum);

Note:

The return value of scanf: 1 if it receives an integer, 0 if it receives an non-numeric

while ((scanf("%ld", &num)) == 1)

{

/* Loop statements */

PseudoCode: is writing the program in simple english before you write the actual computer code.

index = 1;

while(index < 5)

#include <stdio.h>

void main (void)

{ int count = 0;

int total = 0;

while (count < 10)

{ total += count; /* total = total + count; */

printf("count=%d, total=%d\n ", count++, total); }

count=0, total=0

count=1, total=1

count=2, total=3

count=3, total=6

count=4, total=10

count=5, total=15

count=6, total=21

count=7, total=28

count=8, total=36

· Important points about while loop

n=10;

2) If a while loop begins without braces {}, then the single statement immediately following the test

condition is part of the loop.

3) Be carefull where you place the semicolons.

#include <stdio.h>

void main (void)

{ int n=0;

while(n<3)

printf("n is %d\n ", n); /*part of the loop*/

n++; /*NOT part of the loop*/

printf("That’s all this program does\n");

n is 0

n is 0

In the absence of a compound statement, the loop ends at the first semicolon.

#include <stdio.h>

void main (void)

{ int n = 0;

while(n++ < 3);

printf("n is %d\n ", n);

printf("That’s all this program does. \n");

n is 4

x=0 if y<2

· The for loop

The for loop contain three expression seperated by semicolons

1) initialization statement

2) a test condition

3) end statement, increment or decrement statement

#include <stdio.h>

void main (void)

{ int num;

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

for(num=0; num<=6; num++)

n n squared

0 0

1 1

2 4

: :

#include <stdio.h>

void main (void)

{ int count, total;

for(count=0, total=0; count<5; count++)

{ total += count; /*same as: total=total+count*/

printf("count=%d, total=%d\n", count, total);

}

count=0, total=0

count=1, total=1

count=2, total=3

count=3, total=6

#include <stdio.h>

void main (void)

{ char ch;

for (ch=‘a‘; ch<=‘z‘; ch++)

printf("The ascii value for %c is %d\n", ch, ch);

The ascii value for a is 97

The ascii value for b is 98

:

Note: Characters are stored as integers.

#include <stdio.h>

void main (void)

{ float debt;

/* same: debt *= 1.1 */

for(debt=100.0; debt<150.0; debt=debt*1.1)

printf("Your debt is now $%.2f\n", debt);

Your debt is now $100.00

Your debt is now $110.00

Your debt is now $121.00

Your debt is now $133.00

#include <stdio.h>

void main (void)

{ for( ; ; )

I want some action

I want some action

I want some action

It goes on forever, since empty test is considered to be true.

#include <stdio.h>

void main (void)

{ int num;

for (printf("Keep entering numbers!\n"); num!=6;)

scanf("%d", &num);

printf("That’s the one I want! \n");

Keep entering numbers!

5

9

10

6

That’s the one I want!

sum *= 10; => sum = sum * 10;

sum -= 10; => sum = sum - 10;

sum /= 10; => sum = sum / 10;

Ex:

Back to top

Ex: How to calculate quarterly and yearly interest rate

#include <stdio.h>

void main(void)

{ float rate, balance, interest;

float yearly_interest;

float total_interest;

int year, quarter;

printf("Enter interest rate (zero to quit): ");

scanf("%f", &rate);

while (rate != 0)

{ if (rate < 5 || rate > 20)

printf("Out of the reasonable range.\n");

else

{ printf("\nStart Interest End\n");

balance = 1000;

total_interest = 0;

for (year = 1; year <= 3; ++year)

{ printf("Year %i\n", year);

yearly_interest = 0;

for(quarter=1;quarter<=4;++quarter)

{ printf(" %i %7.2f",quarter, balance);

interest=balance*rate/100*.25;

yearly_interest += interest;

balance += interest;

printf(" %7.2f %7.2f\n", interest, balance); }

printf("Total interest for the year: $%.2f\n",

yearly_interest);

total_interest += yearly_interest;

}

printf("\nEnding balance: $%.2f. Interest earned: $%.2f.\n\n",

balance, total_interest);

}

printf("Enter interest rate (zero to quit): ");

scanf("%f", &rate);}

}

Output

Enter interest rate (zero to quit): 12.5

Start Interest End

Year 1

1 1000.00 31.25 1031.25

2 1031.25 32.23 1063.48

3 1063.48 33.23 1096.71

4 1096.71 34.27 1130.98

Total interest for the year: $130.98

Year 2

1 1130.98 35.34 1166.33

2 1166.33 36.45 1202.77

3 1202.77 37.59 1240.36

4 1240.36 38.76 1279.12

Total interest for the year: $148.14

Year 3

1 1279.12 39.97 1319.09

2 1319.09 41.22 1360.32

3 1360.32 42.51 1402.83

4 1402.83 43.84 1446.66

Total interest for the year: $167.54

Ending balance: $1446.66. Interest earned: $446.66.

Enter interest rate (zero to quit):0

do-while: the condition is evaluated after the loop is executed rather than before. The loop must be

executed at least once.

do

{ statement1;

statement2;

} while(expression);

#include <stdio.h>

void main (void)

{

int count = 0;

int total = 0;

do

{ total += count;

printf("Count=%d, total=%d\n", count++,

total);

} while (count < 10);

count=0, total=0

count=1, total=1

:

#include <stdio.h>

void main(void)

{ float price;

short quantity;

char answer;

printf("Enter 0,0 to quit.\n");

do

{ printf("Enter 'price,quantity': ");

scanf("%f,%hi", &price, &quantity);

printf("The total for this item is "

"$%6.2f.\n", price * quantity);

printf("Another (Y/N)? ");

scanf(" %c", &answer);

}while (answer == 'Y' || answer == 'y');

printf("Thank you for your patronage.\n");

Enter 0,0 to quit.

Enter 'price,quantity': 100,30

The total for this item is $3000.00.

Another (Y/N)? y

Enter 'price,quantity': 25, 75

The total for this item is $1875.00.

Another (Y/N)? n

Which loop: while or do-while?

entry-condition: while

exit-condition: do-while

Which loop: for loop or while?

The for loop involves initialization and updating a variable. Use while loop when the conditions are

for(count=1; count<=100; count++)

Nested loops

A nested loop is a loop that is inside another loop.

#include <stdio.h>

#define ROWS 6

#define COL 6

void main (void)

{ int row, col;

for (row=0; row<ROWS; row++)

{ for(col=0; col<COL; col++)

printf("%d", col);

printf("\n");

}

012345

012345

012345

012345

012345

#include <stdio.h>

#define ROWS 6

#define CHARS 6

void main (void)

{ int row;

char ch;

for (row=0; row<ROWS; row++)

{ for (ch=‘A‘+ row; ch<‘A‘+CHARS; ch++)

printf("%c", ch);

printf("\n");

}

BCDEF

CDEF

DEF

EF

ARRAYS

An array is a collection of data objects of the same type stored sequentially in memory.

int temper [7];

char alpha[26];

float average[30];

#include <stdio.h>

void main (void)

{ int temper[7];

int day, sum;

for(day=0; day<7; day++)

{printf("Enter temperature for day %d: ",day);

scanf("%d", &temper[day]);

}

sum=0;

for (day=0; day<7; day++)

sum+=temper[day];

printf("Average is %d.", sum/7);

Enter temperature for day 0: 74

:

Enter temperature for day 6: 69

#include <stdio.h>

#define LIM 40

void main (void)

{ float temper[LIM];

float sum=0.0;

int num, day=0;

do

{ printf("Enter temperature for day %d: ", day);

scanf("%f", &temper[day]);

} while(temper[day++] > 0);

num=day-1;

for(day=0; day<num; day++)

sum+=temper[day];

printf("Average is %f ", sum/num);

Enter temperature for day 0: 71.3

Enter temperature for day 1: 80.9

Enter temperature for day 2: 89.2

Enter temperature for day 3: 0

C does not warn you when an array subscript exceeds the size of the array.

do

{ if (day>=LIM)

{ printf("Buffer full.\n");

day++; }

break;

}

printf("Enter temperature for day %d: ", day);

:

Storage Classes

Initialization and storage classes

-External

-Static How widely known as data item is to various functions in a

-Automatic program and for how long it is kept in memory.

-Automatic (local) variables and arrays are private to a function. When a function finishes and returns to the calling function, the space used to hold its variables is freed.

void main (void)

{ int powers[5]={1,2,6,6,7};

:

Because the array is defined inside main(), it is an automatic array.

-External variables and arrays (global)

An external variable or external array is one defined outside a function.

#include <stdio.h>

int report;

int powers[5]={1,2,6,6,7};

void main (void)

{

:
}

int nxt_func(int n)

{

:

}

External variables and arrays are:

1) known to all functions following them in a file

2) they persist as long as the program runs

3) They are initialized to zeros by default, therefore it is initialized to 0.

Static variables and arrays

int account (int n, int m)

{ static int beans[2]={34, 33};

:

}

1) lifetime: The lifetime of a variable is the length of time it retain aparticular value.

2) visibility or scope: of a variable refers to which parts of program will be able to recognize it.

Why storage classes are necessary

1) use memory more efficiently

2) run faster

3) less prone to programming errors

Lifetime of Automatic Variables

func( )

{ int alfa;

auto int beta;

register int gamma;

- A register variable is a special kind of automatic variable. The compiler will assign it to one of the CPU

registers leading to faster operation provided a register is available.

- They (registers) are created when the function containing them is called, and destroyed when the

function terminates.

Lifetime of static variables

A static variable is known only to the function in which it is defined, but unlike automatic variables, it does not disappear when the function terminates.

func( )

{ static int delta;

:

Static initialization:

Static variables or arrays are initialized to zero you don’t explicitly initialize them to some other value.

External static variables

Declare a static variable outside any function.

- The difference between an ordinary external and an external static variable lies is the scope.

static randx =1;

int rand( )

External variables

int names;

double mass;

void main(void)

{ extern int names;

extern double mass;

including the extern keyword allows a function to use an external variable even if it is defined in a file or in a different file.

int name; /*global variable*/

int num; /*global variable*/

int magic(void); /*function prototyping*/

void main (void)

{ extern int name; /*Same as name in global*/

int num; /*different num than in global*/

: /*and it is auto*/

}

int magic(void)

{ auto int num; /*different num than in global*/

: /*and it is explicitly auto*/

name = .....; /*no need declaration of name*/

/*by default it is the global name*/

The keyword extern always indicates that a declaration is not a definition, since it instructs the compiler to look elsewhere.

void main(void)

{...}

Ex: correction of the above example

int term;

void main(void)

{...

Storage class Keyword Lifetime duration Scope

automatic auto Temporary(function) local

Register register Temporary(function) local

Static static Persistent(program) local

External extern Persistent(program) global(all files)

void main(void)

{ ...

}

int theta; /*global variable*/

func( )

{ ...

The variable theta will be visible only to the function func( ), and will be invisible to main( ) .

#include <stdio.h>

extern void trystat(void);

void main(void)

{ int count;

for (count =1; count <=3; count++)

{ printf("Here comes iteration%d:\n", count);

trystat();

}

}

extern void trystat(void)

{ int tade =1;

static int stay =1;

printf("fade=%d and stay=%d\n",fade++,stay++);

}

Output

Here comes iteration 1:

fade =1 and stay =1

Here comes iteration 2:

fade =1 and stay =2

Here comes iteration 3:

#include <stdio.h>

extern void static_demo (void);

static int i = 10;

void main (void)

{ printf("The value of i in function main() is:%4d\n\n",i);

i++;

static_demo();

printf("The value of i in function main() is:%4d\n\n",i);

}

extern void static_demo (void)

{ i+=5;

printf("The value of i in function static_demo() is:%4d\n\n", i);

}

The value of i in function main() is: 10

The value of i in function static_demo() is: 16

The value of i in function main() is: 16

Ex: Storage classes

#include <stdio.h>

/*user defined function prototypes*/

extern void static_demo1(void);

extern void static_demo2(void);

/*external variable declarations*/

static int i = 10;

extern int k;

void main (void)

{i++;

printf("The value of i in function main() is:%4d\n\n",i);

k++;

printf("The value of k in function main() is:%4d\n\n",k);

static_demo1();

printf("The value of i in function main() is:%4d\n\n",i);

printf("The value of k in function main() is:%4d\n\n",k);

k += i;

printf("The value of k in function main() is:%4d\n\n",k);

static_demo2();

printf("The value of i in function main() is:%4d\n\n",i);

printf("The value of k in function main() is:%4d\n\n",k);

}

static int j =5;

extern void static_demo1(void)

{i+=5;

printf("The value of i in function static_demo1() is:%4d\n\n",i);

j-=i;

printf("The value of j in function static_demo1() is:%4d\n\n",j);

}

int k=5;

extern void static_demo2(void)

{i+=5;

printf("The value of i in function static_demo2() is:%4d\n\n",i);

j-=i;

printf("The value of j in function static_demo2() is:%4d\n\n",j);

k=i+j;

 printf("The value of k in function static_demo2() is:%4d\n\n",k);

The value of i in function main() is: 11

The value of k in function main() is: 6

The value of i in function static_demo1() is: 16

The value of j in function static_demo1() is: -11

The value of i in function main() is: 16

The value of k in function main() is: 6

The value of k in function main() is: 22

The value of i in function static_demo1() is: 21

The value of j in function static_demo1() is: -32

The value of k in function static_demo1() is: -11

The value of i in function main() is: 21

The value of k in function main() is: -11

void main(void)

{ int k ;

...

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

{ extern int i;

k+=i;

i++;

}

}

int i;

The following program fragment uses two "static" variables. The one in the main program is explicitly initialized and the other is initialized to 0 by the compiler.

visibility of i in main() :function main()

visibility of i in function-1() :function function-1()

lifetime of i in main() :global

lifetime of i in function-1() :global

initial value of i in main() :10

extern void function_1(void);

void main(void)

{ static int i=10;

...

function_1();

i++;

function_1();

...

}

extern void function_1(void)

{ static int i;

i++;

...

}

The following program fragment illustrates extern variable i which is defined in module 1, and how to make this variable visible in module 2.

visibility of i :functions main() and function_1()

lifetime of i :global

/* MODULE 1 */

extern void function_1(void);

int i =10; /*definition of variable i*/

void main(void)

{ i++;

...

function_1();

...

function_2();

}

extern void function_1(void)

{ i+=5;

...

visibility of i : all function that may be defined in this module

lifetime of i : global

/* MODULE 2 */

extern void function_2(void);

/*reference to variable i in MODULE 1*/

extern int i;

extern void function_2(void)

{ i+=20;

...

function_1();

...

}

The following program fragment shows variables i and j defined with static storage class, but with different visibility. Variable k is defined so that it can be made visible in other modules (module two in this case) by using the extern keyword.

visibility of i : functions main(), func_1(), func_2()

visibility of j : functions func_1(), func_2()

visibility of k : function func_2()

Lifetime of i : global

Lifetime of j : global

Lifetime of k : global

Initial value of i : 10

Initial value of j : 0

/* Module 1 */

extern void func_1(void);

extern void func_2(void);

static int i = 10;

void main (void)

{ i++;

...

func_1();

...

func_2();

...

}

static int j;

extern void func_1(void)

{ i += 5;

j = ++I + 10;

...

}

int k = 12;

extern void func_2(void)

{ i += 5;

j = j+10;

k ++;

To write a function with a return value

1) When you define a function, state the type of value it returns

2) Use the keyword return to indicate the value to be returned

#include <stdio.h>

void main (void)

{ double x, xpow;

double power(double a, int b);

int n;

printf("Enter a number and the positive ");

printf("integer power to which\n the number ");

printf("will be raised. Enter ‘q‘ to quit.\n");

while(scanf("%lf %d ", &x, &n) == 2)

{ xpow = power(x, n);

printf("%.3e to the power %d is %.3e\n", x, n, xpow);

}

}

double power (double a, int b)

{ double powr=1;

int i;

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

powr *=a;

return powr; /* return the value of power */

Enter a number and the positive integer power to which

the number will be raised. Enter ‘q’ to quit.

2.2 5 <cr>

2.200e+000 to the power 5 is 5.154e+001

8.0 <cr>

8 <cr>

8.000e+000 to the power 8 is 1.678e+007

144 2 <cr>

1.440e+002 to the power 2 is 2.074e+004

static matrix[3][4]={{2,4,5,6},{3,5,6,8},{8,9,10,11}};

Initializing Arrays

Ex: This program makes change; you type in a price in cents, and the program tells you how many half-

dollars, quarters, dimes, nickels, and pennies it take to make up this amount.

#include <stdio.h>

#define LIM 5

int table[LIM] = {50, 25, 10, 5, 1};

void main (void)

{ int dex, amount, quantity;

printf("Enter amount in cents: ");

scanf("%d", &amount);

for (dex=0; dex<LIM; dex++)

{ quantity = amount/table[dex];

printf("Value of coint=%2d, ",table[dex]);

printf("Number of coints=%2d\n", quantity);

amount=amount%table[dex];

}

Enter amount in cents: 143

value of coint=50, number of coints=2

value of coint=25, number of coints=1

value of coint=10, number of coints=1

value of coint=5, number of coints=1

Array initialization:

You can’t initialize a local (automatic) array. Because C doesn’t create such an array until the function

void main (void)

{ int array[10];

:

If the array was declared an external or static variable, it will be initialized to zero.

int threed[3][2][4]={{{1,2,3,4},{5,6,7,8}},

{{6,7,8,9},{4,5,6,7}},

{{7,2,6,3},{0,1,9,4}}};

It’s in the 3rd group <-- -->the 2nd of the 2 dim array

| |

int threed[2][1][0] = 0;

|

-->the 1st element in 1-dim

Back to top

I/O functions:

Functions that transport data to and from your program.

printf(), scanf(), getchar(), and putchar()

ex: getchar() and putchar()

#include <stdio.h>

void main (void)

{ char ch;

while((ch=getchar()) != ‘#‘)

putchar(ch);

Hello, there I would <CR> (what you type)

Hello, there I would (what you see)

like a #3 bag of potatoes. <CR>

Question: Why do you have to type a whole line before the input is echoed?

Is there any better way to terminate input?

Buffers

- Unbuffered or direct: it is immediate echoing of what you type.

- Buffered: the character you type are collected and stored in an area of temporary storage called buffer.

Terminating keyboard input

Files: A file is a block of memory in which information is stored

- low level I/O host operating system

- Standard I/O package: getchar(), putchar(), printf(), and scanf()

C treats input and output devices the same as it treats regular files on storage device.

* The keyboard and display devices are treated as files that are opened automatically by every C

program.

How to detect end-of-files to terminate keyboard input?

1) to place a special character at the end of the file: ^Z

2) to store information on the size of the file: 200 bytes

- C uses the getchar() function to return a special signal when the end of file is detected, regardless of the method actually used to find the end of the file (EOF).

EOF is defined in stdio.h file as follow:

#define EOF -1

#include <stdio.h>

void main (void)

{ int ch;

/*character variable may be represented by*/

/*unsigned integer in the range of 0 to 255*/

while((ch=getchar()) != EOF)

putchar();

}

1) stdio.h takes care of EOF

2) putchar() prints out the character equivalent

3) Unix system: Control D Microcomputer: Control Z

Redirection and files

A C program using the standard I/O package looks to the standardinput as a source of input, which is the stream we earlier identified as stdin.

Two methods to work with files:

1) using special functions that open files, close files, read files.

2) redirecting input & output a long different channels.

Sample1.C

It causes the words file to be associated with the stdin stream, chanelling the file contents into Sample1.

-File words is the I/O "device"

You type the text file and end it with Control Z on DOS or Control D on Unix

To see the content of file mywords:

- type mywords on DOS

- type mywords on Unix

Combine Redirection

Rules of redirection

1. A redirection operator connects an executable program with a file (not a file with another file).

2. Input cannot be taken from more than one file, nor can output be directed to more than one file using

these operators.

#include <stdio.h>

void main (void)

{ int ch;

int rows, cols;

void display(char c, int n, int m);

while((ch=getchar()) != EOF)

{ scanf("%d %d", &rows, &cols);

display(ch, rows, cols);

}

}

void display(char c, int n, int m)

{ int row, col;

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

{ for(col=1; col<=m; col++)

putchar(c);

putchar(‘\n‘);

}

a 2 3

aaa

aaa

b12

[blank lines]

bb

[control z]

while((ch=getchar()) != EOF)

{ if (ch!= ‘\n‘ && ch!=‘ ‘ && ch!=‘\t‘)

{ if (scanf("%d %d", &rows, &cols) != 2)

break;

display(ch, rows, cols);

}

b 1 2 c 3 5

Enter the letter of your choice:

a. advice b. bell

Goals

1) The program works well when the user follows instruction

2) The program works well when the user fails to follow instruction

pseudo code:

show choices

get response

while response is not acceptable, prompt for more response

int getchoice()

{ int ch;

printf("Enter the letter of your choice:\n ");

printf("a. advice b. bell \n ");

printf("c. count d. quit \n ");

ch = getchar();

while(ch<‘a‘ || ch>‘d‘)

{ printf("Please respond with a, b, c, or"

" d.\n ");

ch = getchar();

}

return ch;

Problem: Every newline generated by the enter key is treated as an erroneous response.

int getfirst()

{ int ch;

ch = getchar();

while(getchar() != ‘\n‘)

;

#include <stdio.h>

void main (void)

{ int choice;

int getchoice(void);

void count();

while ((choice=getchoice()) != ‘d‘)

{ switch(choice)

{ case ‘a’: printf("Buy low, sell high\n");

break;

case ‘b’: putchar(‘\7’);

break;

case ‘c’: count();

break;

default: printf("Program error");

break; }

}

}

void count(void)

{ int n, i ;

printf("Count how far? Enter an integer: \n");

if(scanf("%d", &n) != 1)

{ printf("Please use digits next time, this " "time ");

printf("I will use the integer 5\n");

n=5; }

for(i=1; i<=n; I++)

printf("%d\n", I);

while(getchar()!=‘\n’)

; /* discard newline, bad input */

}

Functions

Frequently asked questions about functions:

1) Can I call a function more than once?

2) Can one function contain calls to another?

3) Can a function contains more than one statement?

4) Can a function contains call to itself?

Major points to know about functions

Function Prototyping (ANSI):

is a function declaration that specifies the data types of the argurments, the return type, and the number of arguments

int imax ( int, int);

int imax ( int a, int b);

Traditional C:

int imin ( ) ;

It does not say anything about the number or type of arguments that this function requires.

These names are dummy names and don’t have to match the names used in the function definition

1) Function Definition & Declaration

[storage class] [return type] function name ([formal parameter list])

{

:

:

Ex:

extern float func_1(void);

- Storage Class: the optional "storage class" specifies the function’s storage class, which must be either "static" or "extern". If the storage class is omitted the default is extern.

- If the storage class is specified as "static" the function is visible only to the source file in which it is defined. All other function whether they are given extern storage class explicitly or implicitly are visible throughout the source files that make up the program.

- The optional "return-type" and mandatory "function name" together specify the function return type and name. If no return type is specified the compiler assumes type int.

- The function definition must match the return type in the declaration of the function elsewhere in the program.

Ex:

result = function_1();

printf("%d", function_1());

Ex:

#define SPACE ‘ ‘

#define NAME "John"

Sample (SPACE, 65); or Sample (‘ ‘, 65);

3) Creating a function

int function_1(char ch, int num)

{ declare local variables

:

body of the function

:

}

Ex: K&R C

int function_2(ch, num)

char ch;

int num;

{

declare local variables

:

body of the function

:

Formal arguments: are declared before the brace that marks of the body of the function.

4) you can include main() and function_1() in the same file or two separate files.

- Single file is easier to compile.

- Two separate files make it simpler to use the same function in different programs

Returning a value from a function

Use keyword return followed by a variable to send it back to the calling function.

- you can enclose the return value in parentheses for clarity if it’s not required.

extern int min(int n, int m)

{ int min;

if (n < m ) or if (n < m )

min=n; return (n);

else else

min=m; return (m);

return min;

Ex: Function () generation and calling

#include <stdio.h>

extern int imax (int x, int z);

void main (void)

{ printf ("The maximum of %d and %d is %d.\n",3,5,

imax(3));

printf ("The maximum of %d and %d is %d.\n",3,5,

imax(3,5));

}

int imax (n, m) or extern int imax(int n, int m)

int n,m;

{ int max;

if (n > m)

max = n;

else

max=m;

return max;

#include <stdio.h>

int power (int a, int b);

void main(void) {

int base, exponent, result;

printf("Raise what number to a power?");

scanf("%d", &base);

printf("what is the integer exponent?");

scanf("%d", &exponent);

result=power(base,exponent);

printf("%d to the power %d is %d.\n", base, exponent, result);

}

int power (int base, int exponent)

{ int I, result = 1;

for (I=0; I<exponent; I++)

result = result * base;

return (result);

storage class : defaults to extern

return type : defaults to int

parameter list : void, meaning no paramter is

passed to this function from the calling function

visibility : all source files that make up the program

function_1(void)

{

int num1 = 1, num2=2;

return(num1+num2);

storage class : extern

return type : float

parameter list : 2 integer paramters are passed

to this function from the calling function

visibility : all source files that make up the program

extern float function_2(int i, int j)

{

return((float)(i+j));

}

Ex) Another user define function

#include <stdio.h>

int total(int cur, int end);

void main (void)

{ int beg, end;

printf("Enter beginning ending: ");

scanf("%d %d", &beg, &end);

printf("Total: %d\n", total(beg, end));

}

int total(int cur, int end)

{ int count, tot=0;

for(count=cur; count<=end; ++count)

tot+=count;

return tot;

}

Output

Enter beginning ending: 3 10

Back to top

#define PI 3.141592 is called define directive

#define ERROR printf("\n ERROR. \n");

if (input > 20) or if (input > 20)

ERROR printf("\nERROR.\n");

Ex: Using macros in a program.

#include <stdio.h>

#define PR(n) printf ("%.2f\n",n)

void main (void)

{ /* PR(n): an argument n: identifier*/

/* PR (num1) : cause the variable num1 to be subsituted for n.*/

float num1 = 27.25;

float num2;

num2= 193.0;

PR(num1);

PR(num2);

}

/*PR (num1) <=> printf("%.2f\n",num1);*/

output

27.25

193.00

#define PR(n) printf ("%.2f\n",n);

Ex: Another example of macros

/*Calculate area of a sphere */

#include <stdio.h>

#define PI 3.14159

#define AREA (x) (4*PI*x*x) /*macro for area of sphere*/

void main(void)

{ float radius;

printf("Enter radius of sphere: ");

scanf("%f", &radius);

printf("Area if sphere is %.2f",AREA(radius));

#define SUM (x,y) x+y

:

ans = 10 * SUM ( 3,4);

ans = 10 * 7 = 70 wrong

ans = 10*3+4

- For safety’s sake, put parentheses around the entire text of any define directive that uses arguments and also around each of the argument.

Macros and Functions

Macros and function can actually perform many of the same tasks .

When to use macros

A macro generates more code but executes more quickly than a function .

Causes one source file to be included in another.

#define PI 3.141592

#define KONST 345

:

:

The following format causes the preprocessor to start searching in the standard header directory.

Ex:

home = 15915; /*unsigned decimal integer*/

printf("%d %u\n", home, &home);

Output:

15915 address(some address in memory)

#include <stdio.h>

int void interchange(int,int);

void main (void)

{ int x=5, y=10;

print("originally x = %d and y = %d. \n", x, y);

interchange (x, y);

print("Now x = %d and y = %d.\n", x, y);

}

void interchange(int u,int v) /* define function*/

{ int temp;

printf("Originally u = %d and v = %d. \n", u,v);

temp = u;

u = v;

v = temp;

printf("Now u = %d and v = %d. \n", u, v);

Originally x = 5 and y = 10

Originally u = 5 and v = 10

Now u = 10 and v = 5

To send the return value back to the calling program:

Note: with return you can send just one value back to the calling program

Pointers

are symbolic repressentation of addresses.

- &home is a pointer_to_home, actual address is a number (Hex number) the symbolic representation &home is a pointer constant.

To create a pointer variable

indirection operator, *: when followed by a variable, it gives the value stored at the pointed_to address.

home = 14914;

ptr = &home;

Val = ptr;

int *home; /*points to an integer variable*/

float *pi; /*points to a float variable*/

Declaring and using pointers

#include <stdio.h>

void interchange(); or void interchange(int *u,int *v);

void main(void)

{ int x = 5, y = 10;

printf("Originally x = %d and y = %d.\n ", x, y);

interchange(&x,&y);/*send addresses to function*/

printf("Now x = %d and y = %d.\n",x, y);

}

void interchange(u,v) or interchange(int *u,int *v)

int *u, *v;

{ int temp;

temp = *u;

*u = *v;

*v = temp;

Originally x = 5 and y = 10

#include <stdio.h>

void gets(int *px, int *py);

void main(void)

{ int x, y;

gets(&x, &y);

}

void gets(int *px, int *py)

{ *px = 3;

*py=5;

#include <stdio.h>

void main ( void )

{ int x = 4 , y = 7;

int *px , *py;

printf("x is %d, y is %d. \n", x, y);

px = &x;

py = &y; /*put address of numbers in pointers */

*px = *px + 10;

*py = *py +10;

printf("x is %d, and y is %d.\n",x, y);

}

x is 4, y is 7

x is 14, y is 17.

#include <stdio.h>

extern void more(void);

void main(void)

{ char ch;

printf("Enter any character you want.");

printf("A Q will end things.\n");

ch = (char) getchar();

printf("Aha! That was a %c!\n", ch);

if(ch != ‘Q‘)

more( );

}

extern void more(void)

{

main();

Enter any character you want A Q will end things.

A <cr>

Aha! That was a A!

Enter any character you want A Q will end things.

Aha! That was a <--prints newline

!

Enter any character you want A Q will end things.

Q <cr>

Recursion: To find factorial

n! = n x (n-1) x ( n-2) x (n-3)x......x 3 x 2 x 1

#include <stdio.h>

extern int factorial(int n);

void main(void)

{ int n, result;

print("Find the factorial of what?\n");

scanf("%d",&n);

result = factorial(n);

printf("the factorial of %d is %d\n", n, result);

}

extern int factorial(int n)

{

if(n ==1)

return(1);

else

return(n*factorial(n-1));

REVIEW

EXAMINATION #2

Back to top

Pointers and Arrays

The compiler translates array notation into pointer notation when compliling, since the internal architecture of the microprocessor understands pointers but does not understand arrays.

/*array C */

#include <stdio.h>

void main (void)

{ static int nums [5] = {92, 81, 70, 60, 58};

int dex;

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

printf("%d\n",nums [dex]);

92

81

70

60

print("%d\n", *(nums + dex);

nums + dex = 1400 + 3 * 2 = 1406

number of bytes per integer

*(nums + dex)

&nums[dex]

&nums[2] == (nums +2) == 1404

Ex: Use of poiter notations in the previous program.

#include <stdio.h>

void rets2(int *px, int *py)

void main(void)

{ int x, y;

rets2(&x, &y);

printf("First is %d, Second is %d.",x, y);

void rets2(int *px, int *py)

{

*px = 3 ;

*py = 5 ;

First is 3, Second is 5

#include <stdio.h>

#define SIZE 5

void addcon(int *ptr, int num, int con);

void main(void)

{ static int array[SIZE] = {3,5,7,9,11};

int konst = 10;

int j;

addcon(array, SIZE, konst);

for(j=0, j < SIZE, j++)

printf("%d", *(array+j));

}

void addcon(int *ptr, int num, int con)

{ int k;

for(k=0; k<num; k++)

*(ptr)=*(ptr++) + con;

{ static int arr[3] ={4,5,6};

int j;

for(j=0; j<3; j++)

printf("%d", arr[j];

{ static int arr[3] = {4,5,6};

int j, *ptr;

ptr=arr;

for(j=0; j<3; j++)

printf("%d", *ptr++); 4, 5, 6

char name[i][j];

...

Sample(name);

Sample(int *name[j])

Pointer notation vs. bracket notation

int a[5], *ptr;

ptr = a;

*(a+3)=10;

*(ptr+3)=10; They are all the same, but use different notations.

a[3]=10;

ptr = a;

ptr += a;

in this case, ptr itself is modified, since array name a is constant, not a variable, we can’t say a += 3.

1) Fetch the content of I.

2) Multiply it by the size of one object-pointed-to store the result in anonymous scratch variable

3) Then, increment I and put it back.

4) Fetch the content of ptr

5) Then add the results of the multiply to it.

6) Finally, fetch the contents of the memory whose address was just computed, and put it into x.

* 3 - fetches and one multiply

1) Fetch the contents of ptr.

2) Fetch the object at that address and put it into x.

3) Add to ptr the size of an object-pointed-to.

4) Store the result of the addition in ptr.

* 2 - fetches and no multiplication

#include <stdio.h>

#include <string.h>

#include <conio.h>

void main(void)

{ char ch, line[81], *ptr;

puts("Enter the sentence to be searched:");

gets(line);

printf("Enter Character to Search for:");

ch = getch();

ptr = strchr(line, ch);

printf("\n String starts at address %u \n",line);

printf("first occurance of char is address "

"%u.\n",ptr);

printf("this is position %d (starting from 0)",ptr-line);

}

Output:

Enter the sentence to be searched:

The quick brown fox jumped over the lazy dog. <cr>

Enter Character to Search for: <cr>

String starts at address 65424

first occurance of char is address 65442.

this is position 18 (starting from 0)

ptr = strchr(str,’x’);

strcmp("A","A")=>0 strcmp("A","B")=>-1

#include <stdio.h>

#include <string.h>

#define MAX 5

void main(void)

{ int dex;

int enter =0;

char name[40];

static char *list[MAX] = { "Katrina", "Nigel","Alistair", "Francesca",

"Gustar"};

printf("Enter your name:");

gets(name);

for (dex=0; dex < MAX; dex++)

if(strcmp(list[dex], name) == 0)

enter=1;

if(enter == 1)

printf("you may enter, Oh honored one.");

else

printf("Guards! Remove this person!");

}

Enter your name:Andy

Guards! Remove this person!

Enter your name:Katrina

An array of strings

An array of string is really an array of arrays, or a two-dimensional array.

#include <stdio.h>

#include <string.h>

#define MAX 5

#define LEN 40

void main(void){

int dex;

int enter = 0;

char name[40];

static char list[MAX][LEN] = {"Katrina", "David", "Steve", "Sue",

"Lee"};

printf("Enter your name: ");

gets(name);

for(dex = 0; dex < MAX; dex ++)

if (strcmp(&list[dex][0], name) == 0)

enter =1;

if(enter == 1)

printf("You may enter, it is in the list.");

else

printf("It is not in the list!");

Enter your name: James

It is not in the list!

Enter your name: Lee

You may enter, it is in the list.

The difference between arrays and pointers

Pointer version takes up less space in memory; it ends at 1038, while the array version ends at 1049

To obtain greater flexibility in the manipulation of the strings in the array.

Manipulating pointers to strings

#include <stdio.h>

#include <string.h>

#define MAXNUM 30

#define MAXLEN 81

void main(void)

{ static char name[MAXNUM][MAXLEN];

char *ptr[MAXNUM]; /*array of ptrs to strings*/

char *temp;

int count=0;

int in, out;

while (count < MAXNUM)

{ printf("NAME %d: ", count+1)

gets(name[count]);

if(strlen(name[count])== 0)

break; /*quit if no name*/

/*each ptr points to name*/

ptr[count++] = name[count];

}

for (out = 0; out < count-1; out++)

for(in = out +1; in < count; in ++)

if (strcmp(ptr[out],ptr[in])>0)

{ temp = ptr[in];

ptr[in] =ptr[out];

ptr[out]=temp;

}

printf("‘In sorted‘ list:\n");

for (out = 0; out < count; out ++)

printf("Name %d: %s \n", out +1, ptr[out]);

}

Input List

NAME 1: Baker

NAME 2: Bakers

NAME 3: John

NAME 4: Smith

NAME 5: Al

NAME 6: Pacino

NAME 7: Steve

NAME 8: <cr>

'Sorted' list:

Name 1: Al

Name 2: Baker

Name 3: Bakers

Name 4: John

Name 5: Pacino

Name 6: Smith

Name 7: Steve

#include <stdio.h>

int data[2]={100, 300};

int moredata[2]={100, 300}

void main(void)

{ int *p1, *p2, *p3;

p1= p2=data;

p3= moredata;

printf("%d %d %d\n",*p1++,*++p2, (*p3)++);

printf("%d %d %d \n", *p1, *p2, *p3);

100 300 100

Back to top

WEEK FIFTEEN

The pointer operators * and ++ have the some precedence but associate from right to left.

Pointers and two-dimensional arrays (double indirection)

int zippo[m][n]=*(*(zippo+m)+n)

zippo[0] == &zippo[0][0] == *zippo

zippo[1] == &zippo[1][0] == *(zippo+1)

zippo[2] == &zippo[2][0] == *(zippo+2)

*z[0] == z[0][0] == **z

*z[1] == z[1][0] == *(*(z+1))

*z[2] == z[2][0] == *(*(z+2))

The following 2 program show how arrays, pointers and addresses relate to each other.

#include <stdio.h>

void main (void)

{ int zippo[4][2];

printf("zippo = %u, zippo[0] = %u \n"

"&zippo[0][0]=%u, ", zippo, zippo[0], &zippo[0][0] );

printf("*zippo=%u\n", *zippo);

zippo = 3512, zippo[0] = 3512

#include <stdio.h>

void main (void)

{ int zippo[4][2];

printf("zippo = %u, zippo[0] = %u \n"

"&zippo[0][0]=%u, ", zippo, zippo[0], &zippo[0][0] );

printf("*zippo=%u\n", *zippo);

printf("zippo+1=%u, zippo[0]+1=%u\n", zippo+1, zippo[0]+1);

printf("&zippo[0][0]+1=%u, *zippo+1=%u\n",&zippo[0][0]+1, *zippo+1);

printf("*(zippo+1)=%u\n", *(zippo+1));

zippo = 3512, zippo[0] = 3512

&zippo[0][0] = 3512, *zippo = 3512

zippo+1=3516, zippo[0]+1=3514

&zippo[0][0]+1=3514, *zippo+1=3514

Function and multi-dimension array

There are 3 ways to pass multi-dimensional arrays to a function:

1) use a function written for one dimensional arrays on each subarray.

2) use the same function on the whole array, but treat the whole array as one dimensional instead of 2

dimensional.

3) use a function that explicitly deals with 2 dimensional arrays.

#include <stdio.h>

#define MODELS 2

#define COLORS 3

extern void print_inv(short inv[][COLORS]);

void main(void)

{ short inv[MODELS][COLORS]={{46,12,122},{62,20,88}};

print_inv(inv);

}

extern void print_inv(short inv[][COLORS])

{ int model, color;

printf(" RED GREEN PUCE\n");

for (model = 0; model < MODELS; ++model)

{ if (model == 0)

printf("STANDARD ");

else

printf("DELUXE ");

for (color = 0; color < COLORS; ++color)

printf("%6hi ", inv[model][color]);

printf("\n");

}

}

#include <stdio.h>

#define ROW 4

#define COL 5

void main(void)

{ static int table[ROW][COL] = { { 1, 2, 3, 4, 5}, { 6, 7, 8, 9, 10},

{ 11, 12, 13, 14, 15}, {16, 17, 18, 19, 20} };

int konst = 10;

int j, k;

for(j = 0; j < ROW; j++)

for(k=0; k < COL; k++)

table[j][k] = table[j][k]+konst;

for(j=0; j < ROW; j++)

{ for(k=0; k<COL; k++)

printf("%d ", table[j][k]);

printf("\n");

}

:

for(j=0; j < ROW; j++)

for(k=0; k<COL; k++)

Defining strings within a program

Whenever the compiler encounters something enclosed in double quotation marks, it recognizes the pharse as a string constant. The enclosed characters, plus a terminating ‘\0’ character automaticallly provided by the compiler, are stored in adjacent memory locations.

1) ‘X‘, ‘x‘, ‘E‘ => these are character

2) "X", "x", "E" => these are string

3) "Hello there." => these are string

Compiler treats them as

1) X , x , and E => w/o \0 as null char.

2) X\0 , x\0 , and E\0 => with \0 as null char.

Array and Pointer differences

We can examine the differences between initializing a character array to hold a string and initializing a pointer to point to a string. Keep in mind that by pointing to a string, the pointer is pointing to the first character of a string.

1) Declaring a constant pointer:

static char heart[] = "I love Tillie!";

2) Declaring a variable pointer:

Points to remember

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

putchar(*(heart+i)); putchar(*(head+i));

while(*(heart)!=‘\0‘) while(*(head)!=‘\0‘)

putchar(*(heart++));(err) putchar(*(head++));(OK)

#define LIM 5

static char *mytal[LIM] = {"Adding together",

"Multiply accurately", "Stacking data",

for which the first set of double quotation marks corresponds to brace-pair and thus is used to initialize the first character string pointer. The next set of double quotation marks initializes the second pointer, and so on. A comma seperates neighboring sets.

#define LIM 5

#define LINLIM 30

#define LIM 5

sets up a "ragged" array, with each row’s length determined by the string it is initalized to. The ragged array doesn’t waste any storage space.

Pointer to strings

Most C operations for strings actually work with pointers. For example: consider the useless, yet instructive, program in the following example.

#include <stdio.h>

void main (void)

{ char *mesg = "Don’t be a fool!";

char *copy;

copy = mesg;

printf("%s\n", copy);

printf("mesg=%s; value=%u; &mesg=%u\n",mesg,mesg,

&mesg);

printf("copy=%s; value=%u; &copy=%u\n",copy,copy,

&copy);

}

Output

Don't be a fool!

mesg=Don't be a fool!; value=404; &mesg=65498

copy=Don't be a fool!; value=404; &copy=65500

String output

#include <stdio.h>

#define DEF "I am a #define string."

void main (void)

{ static char str1[]="Array is initialized to me.";

char *str2 = "A pointer was initialized to me.";

puts("I’m an arguments to puts(). ");

puts(DEF);

puts(str1);

puts(str2);

puts(&str1[4]);

puts(str2+4);

I’m an argument to puts().

I am a #define string.

Array is initialized to me.

A pointer was initialized to me.

y is initialized to me.

inter was initialized to me.

Main function arguments

Command line arguments are additional items on the same line.

Traditionally, the formal parameters are called

void main(argc,argv) void main(int argc,char *argv[])

int argc; {

char *argv[]; :

{ }

:

}

Ex:

c:\tc>count 2 text 25 C_book <cr>

What the program gets from this command line:

argc = 5

argv[0] = "c:\tc\>count.exe"

argv[1] = "2"

argv[2] = "text"

argv[3] = "25"

#include <stdio.h>

void main(int argc, char *argv[])

{ int counter;

printf("The number of arguments you entered is: %d\n", argc);

for(counter=0; counter < argc; counter++)

printf("Argument number %d: is %s\n", counter, argv[counter]);

}

The number of arguments you entered is: 4

Argument number 0: is C:\TC\> mystuff.exe

Argument number 1: is one

Argument number 2: is two

Back to top

FILE input/output

C sees a file as a sequence of bytes, each of which can be read individually.

Text File

Information are stored as strings. MS-DOS text files represent the end of a line with the carriage

Binary file

Each byte of the file is accessible to a program. Binary view is more efficient way of storing

information.

ANSI C

Provides both a binary and a text view but these views can be implemented identically.

- Unix: both views are the same for unix implementations.

Levels of I/O:

low-level I/O - unbuffered, you can create your own buffer within a program.

Number storage in text formal

Binary mode and text mode

How numbers are stored?

How files are opened?

C originated on UNIX system and used UNIX file convention. MS-DOS, evolved separately from UNIX, has its own, somewhat different, conventions.

Differences

1) The handling of newlines and the representation of end-of -file.

Binary mode: no translation

2) the way end-of-file is detected.

Text mode

- A special character 1A hex (26 decimal), inserted after the last character in the file, to indicate EOF. (EOF == -1).

- If a file stores numbers in binary format, it’s important that binary mode be used in reading the file back, since one of the numbers might well be 1A.

Standard I/O: buffered

Advantages of standard I/O over low-level I/O

1) The buffer speed up the program considerably.

2) It has many specialized functions for handling various I/O problems.

3) It is part of the ANSI standard library, thus providing a highly portable solution to I/O programming

needs.

#include <stdio.h>

void main(void)

{ FILE *file_pointer; /*this is the file pointer*/

file_pointer = fopen("myfile.dta", "W");

/*creates a file called myfile.dta and assign its

address to the file ptr to the file pointer*/

fclose(file_pointer);

}

The getc ( ) and putc( ) functions

Example: the creation and opening of the same file ex(1), but this time the character C is put into the file

you now have a file called Myfile.DTA that contains the character C.

#include <stdio.h>

void main (void)

{

FILE *file_pointer;

char file_character;

file_pointer = fopen ("myfile.dta", "r");

file_character = getc(file_pointer);

/*get the first letter from the opened file*/

printf("The character is %c\n", file_character);

fclose(file_pointer);

#include <stdio.h>

#include <conio.h>

void main(void)

{ FILE *file_pointer;

char file_character;

file_pointer = fopen("myfile.dta", "w");

/*put a stream of characters into the file*/

while((file_character = getc(stdin)) != ‘\n‘)

putc(file_character, file_pointer);

fclose(file_pointer);

c:\>type myfile.dta

Reading a character stream

The concept of a character stream is a sequence of bytes of data being sent from one place to another (such as from computer memory to the disk).

#include <stdio.h>

void main(void)

{ FILE *file_pointer;

char file_character;

file_pointer = fopen("myfile.dta", "r");

while((file_character=getc(file_pointer))!=EOF)

printf("%c", file_character);

fclose(file_pointer);

#include <stdio.h>

#include <stdlib.h>

void main(int argc, char *argv[])

{ FILE *fptr;

int count = 0;

if ( argc !=2) /*check # of args*/

{ printf("format: c>prog filename");

exit(1); }

if ((fptr = fopen(argv[1],"r")) == NULL)

{ printf("can’t open file %s.",argv[1]);

exit(1); }

while (getc(fptr)!= EOF)

count++;

fclose(fptr);

printf("File %s contains %d characters.",argv[1], count);

C:\>prog myfile.dat<cr>

We have used a command-line argument to obtain the name of the file to be examined, rather than writing it into the fopen( ) statement.

#include <stdio.h>

void main(void)

{ FILE *fp;

char name[40];

int code;

float height;

fp = fopen("textfile.txt", "w");

do

{ printf("Type name, code number, and height:");

scanf("%s %d %f", name, &code, &height);

fprintf(fp, "%s %d %f\n", name, code, height);

}

while(strlen(name)>1);

fcolse(fp);

}

Input:

Type name, code number, and height: Bond 7 5.10<cr>

Type name, code number, and height: James 8 5.9<cr>

Type name, code number, and height: x 0 0<cr>

Output (from textfile.txt):

Bond 7 5.100000

James 8 5.900000

:

fp = fopen("textfile.txt", "r");

while(fscanf(fp,"%s %d %f",name,&code,&height)!= EOF)

print("%s %03d %.2f\n", name, code, height);

fclose(fp);

:

#include <stdio.h>

#include <stdlib.h>

#define MAX 20

void main(void)

{ FILE *fp;

char words[MAX]

if((fp=fopen("words", "a+")) == NULL)

{fprintf(stdout,"can’t open \"words\" file.\n");

exit(); }

puts("Enter words to add to the file, type the "

"enter");

puts("Key at the begining of a line to "

"terminate.");

while(gets(words)!=NULL && words[0]!=‘\0’)

fprintf(fp,"%s", words);

puts("File contents:")

rewind(fp);

while(fscanf(fp,"%s", words)== 1)

puts(words);

fclose(fp);

}

c>addaword

Key...

See the canoes <cr>

[enter]

File contents:

See

the

canoes

C>addaword

Key...

on the

sea

[enter]

File contents:

See

the

canoes

on

the

FILE I/O access

- sequential access: processing the file content in order

- random access: accessing the contents in any desired order.

The fprintf( ) and fscanf( ) functions

- They work just like printf( ) and scanf( ), except that they require an additional argument to point to

fprintf(stdout, "can’t open words file.\n");

The fgets( ) and fputs( ) functions

fgets(pointer_to_char,

integer that presents the upper limit to

the size of the input string,

the final arguments is the file pointer

that identifies the file to be read.)

Ex:

fgets(name, 80,fp)

- The first of the three fseek argument is a FILE pointer to the file being searched.

- The second argument is called the offset, which tells us how far to move from the starting point(must be long value)(+,-)

- The third argument is the mode, and it indentifies the starting point.

#include <stdio.h>

#define MAXLINE 20

void main(void)

{ char line[MAXLINE];

while(fgets(line,MAXLINE,stdin)!=NULL && line[0]!=‘\n’)

fputs(line, stdout);

}

Output:

It is spring. <cr>

It is spring.

The hills are green and The sea is sparkling <cr>

The hills are green and The sea is sparkling

<cr>

- fgets() reads first 19 character through n in green.

- fgets() reads the newline and places it in the first element of array.

- gets() discards the newline and you test it with ‘\0’.

- Like gets(), fgets returns the value NULL when it encounters EOF. This

features lets you check the end of file.

- Unlike puts(), fputs() does not append a new line when it prints.

Ex: A program to open a file for reading and writing.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void main (void)

{ FILE *fp;

char string[81];

/*create file for writing*/

if((fp=fopen("myfile.txt", "w"))==NULL)

{ printf("Cannot create data file\n");

exit(1);

};

while(strlen(gets(string)) > 0)/*get input from keybd, so long >0*/

{ fputs(string, fp); /*write into the file*/

fputs("\n", fp); /*append each string with new line*/

}

fclose(fp); /*close data file*/

fp=fopen("myfile.txt", "r"); /*open file for reading*/

while(fgets(string, 80, fp) != NULL) /*read up the end of file*/

printf("%s", string); /*print each line it reads*/

fseek(fp, 0, SEEK_SET); /*set file pointer to the beginning*/

fgets(string, 80, fp); /*read only the first line*/

printf("%s", string); /*and print it*/

fclose(fp); /*close data file*/

}

Output:

University of Houston <cr>

College of Technology <cr>

4800 Calhoun Rd. <cr>

Houston, Texas 77204 <cr>

See you all next semester! <cr>

<cr>

More Examples

4) Calhoun Andy

Structures

Structure

A structure consists of a number of data items-which need not be of the same type-grouped together.

#include <stdio.h>

struct easy

{ int num;

char ch;

};

void main(void)

{ /*declares ‘ez1‘ to be of type "struct easy"*/

struct easy ez1;

ez1.num = 2; /*reference elements of ‘ez1‘*/

ez1.ch = ‘z‘;

printf("ez1.num=%d, ez1=%c\n", ez1.num, ez1.ch);

The structure consists of three parts

1) How to set up a template for a structure type

2) How to declare a variable to fit that template

3) How to gain access to the indvidual components of a structure variable

struct easy

{ int num;

char ch;

A structure is a data type whose format is defined by the programmer.

which declares ez1 to be a structure of the easy type this statement does set aside space in memory.

struct easy{

int num;

char ch;

struct{

int num;

char ch;

3) Accessing structure elements

|

-->structure’s name

ez1.num = 2;

Initializing a structure.

many pre-ANSI implementation limit initialization to external or static structure variables. The important point is where the variable is defined.

Multiple structure variables of the same type

#include <stdio.h>

struct easy

{ int num;

char ch;

};

void main(void)

{ struct easy ez1;

struct easy ez2;

ez1.num = 2;

ez1.ch = ‘z‘;

ez2.num = 3;

ez2.ch = ‘y‘;

printf("ez1.num=%d, ez1.ch=%c\n",ez1.num,ez1.ch);

printf("ez2.num=%d, ez2.ch=%c\n",ez2.num,ez2.ch);

ez1.num=2, ez1.ch=z

ez2.num=3, ez2.ch=y

struct easy

{ int num;

char ch;

Entering Data into Structure

#include <stdio.h>

struct personnel

{ char name[30];

int agnum;

};

void main(void)

{ struct personnel agent1;

struct personnel agent2;

char numstr[81];

printf("\nAgent 1.\n Enter name: ");

gets(agent1.name);

printf("Enter agent number (3 digits): ");

gets(agnum);

agent1.agnum = atoi(numstr);

printf("\n Agent 2. \n Enter name: ");

gets(agent2.name);

print("Enter agent number (3 digit): ");

gets(numstr);

agent2.agnum = atoi(numstr);

printf("\n list of agents: \n");

printf(" Name:%s\n", agent1.name);

printf(" Agent number: %3d\n",agent1.agnum);

printf(" Name: %s\n", agent2.name);

printf(" Agent number: %3d\n", agent2.agnum);

}

Agent1

Enter name: Harrison Tureenbury

Enter agent number (3 digit):102

Agent2

Enter name: James Bond

Enter agent number (3 digit): 007

List of agents:

Name: Harrison Tureenbury

Agent number 102

Name: James Bond

struct book

{ char title[100];

char author[100];

float value;

};

: