LEARN "C" PROGRAM

Definition of variable in c :

2011-08-07T02:51:00.000-07:00

Definition of variable in c:

A variable is named location of data. In other word we can variable is container of data.

    In real world you have used various type containers for specific purpose. For example you have used suitcase to store clothes, match box to store match sticks etc. In the same way variables of different data type is used to store different types of data. For example integer variables are used to store integers char variables is used to store characters etc. On the basis of how many data a variable will store, we can categorize the all c variable in three groups.

(a)Variables which can store only one data at time. Example: integer variables, char variables, pointer variables etc.

(b)Variables which can store more than one data of similar type at a time. Example: array variables

(c) Variables, which can store more than one value of dissimilar type at a time. Example: structure or union variables.

Properties of variable in c:

    Every variable in c have three most fundamental attributes. They are:

1. Name

2. Value

3. Address

Name of a variable:

Every variable in c has its own name. A variable without any name is name is not possible in c. Most important properties of variables name are its unique names. Not two variables in c can have same name with same visibility. For example:

#include<stdio.h>
int main(){
    auto int a=5;   //Visibility is within main block
    static int a=10; //Visibility is within main block

/* Two variables of same name */
    printf("%d",a);
    return 0;
}

Output: compilation error

But it is possible that two variable with same name but different visibility. In this case variable name can access only that variable which is more local. In c there is not any way to access global variable if any local variable is present of same name. For example:

(a)

#include<stdio.h>
int a=50; //Visibility is whole the program

int main(){
    int a=10; //Visibility within main block
    printf("%d",a);
    return 0;
}

Output: 10

(b)

#include<stdio.h>

int main(){
    int a=10; //Visibility within main block.
    {
        a+=5; //Accessing outer local variable a.
        int a=20; //Visibility within inner block.
        a+=10; //Accessing inner local variable a.
        printf(“%d”,a);//Accessing inner local variable a.
    }

    printf(“%d”,a); //Accessing outer local variable a.
    return 0;
}

Output: 30 15

Note: In c any name is called identifier. This name can be variable name, function name, enum constant name, micro constant name, goto label name, any other data type name like structure, union, enum names or typedef name.

Identifier naming rule in c

1.Value of variable in c language

2.Address of a variable in c

3.Declaration of a variable in c

4.Identifier naming rule in c

Identifier naming rule in c

2011-08-07T02:50:00.001-07:00

Identifier naming rule in c:

Note: In c any name is called identifier. This name can be variable name, function name, enum constant name, micro constant name, goto label name, any other data type name like structure, union, enum names or typedef name.

Rule 1: Name of identifier includes alphabets, digit and underscore.

Valid name: world, addition23, sum_of_number etc.

Invalid name: factorial#, avg value, display*number etc.

Rule 2: First character of any identifier must be either alphabets or underscore.

Valid name: _calulate, _5,a_, __ etc.

Invalid name: 5_, 10_function, 123 etc.

Rule 3: Name of identifier cannot be any keyword of c program.

Invalid name: interrupt, float, asm, enum etc.

Example:

#include<stdio.h>

int main(){

int huge=5;

printf("%d"”,huge);

return 0;

}

Output: Compilation error

Rule 4: Name of function cannot be global identifier.

Valid name: __TOTAL__, __NAME__ , __TINY__etc.

Invalid name: __TIME__ ,__DATE__ , __FILE__ ,__LINE__ ,__STDC__, __TINY__, __SMALL__, __COMPACT__, __LARGE__, __HUHE__, __CDECL__, __PASCAL__, __MSDOS__, __TURBOC__

For example:

(a)

#include<stdio.h>

int main(){

double __TIME__=5.5;

printf("%f",__TIME__);

return 0;

}

Output: Compilation error

(b)

#include<stdio.h>

int main(){

double __CPP__=5.5;

printf("%f",__CPP__);

return 0;

}

Output: 5.500000

Note: It is good practice to not write the variable name in the above format.

Rule 5: Name of identifier cannot be register Pseudo variables

Register Pseudo variables are:

Example:

#include<stdio.h>

int main(){

long int _AH=5;

printf("%ld",_AH);

return 0;

}

Output: Compilation error

Rule 6: Name of identifier cannot be exactly same as of name of function within the scope of the function.

Example:

(q) What will be output of following program?

#include<stdio.h>

float lata();

int main(){

float lata;

lata=lata();

printf("%f",lata);

return 0;

}

float lata(){

return 4.5f;

}

Output: Compiler error

Rule 7: Name of identifier is case sensitive i.e. num and Num are two different variables.

Rule 8: Only first 32 characters are significant of identifier name.

Example:

abcdefghijklmnopqrstuvwxyz123456aaa,

abcdefghijklmnopqrstuvwxyz123456bbb,

abcdefghijklmnopqrstuvwxyz123456cad

All three identifier name are same because only first 32 characters has meaning. Rest has not any importance.

Rule 9: Identifier name cannot be exactly same as constant name which have been declared in header file of c and you have included that header files. For example:

(a)

#include<stdio.h>

int main(){

int M_PI=25;

printf("%d",M_PI);

return 0;

}

Output: 25

(b)

#include<math.h>

#include<stdio.h>

int main(){

int M_PI=25;

printf("%d",M_PI);

return 0;

}

Output: Compilation error

Explanation: M_PI is constant name which has been defined in header file math.h hence it cannot be variable in c.

Variable name cannot be exactly same as function name which have been declared any header file of c and we have included that header file in our program and used that function also in the program. For example:

(a)

#include<stdio.h>

int main(){

int sqrt=25;

printf("%d",sqrt);

return 0;

}

Output: 25

(b)

#include<math.h>

#include<stdio.h>

int main(){

int sqrt=25;

printf("%d",sqrt);

return 0;

}

Output: 25

(c)

#include<math.h>

#include<stdio.h>

int main(){

int sqrt=25;//Invalid variable name

printf("%f",sqrt(sqrt));

return 0;

}

Output: Compilation error

Note: Header file stdio.h or conio.h by default it has included every c program .If you have not included that header explicitly then c complier will include that file. To make any program as c program save it as with .c extension.

(d)

int main(){

int scanf=45;

printf("%d",scanf);

return 0;

}

Output: 45

(e)

int main(){

int scanf=45,b;

scanf("%d",&b);

printf("%d %d",scanf,b);

return 0;

}

Output: Compilation error

Identifier name in c can be exactly same as data type which has been declared in any header of c. For example

(a)

#include<stdio.h>

int main(){

FILE *ptr;

int FILE =11;

printf("%d",FILE);

return 0;

}

Output: 11

(b)

#include<stdio.h>

#include<time.h>

int main(){

clock_t clock_t=80

printf("%d",clock_t);

return 0;

}

Output: 80

Address of a variable in c

2011-08-07T02:47:00.000-07:00

Address of a variable in c :

Location in a memory where a variable stores its data or value is known as address of variable. To know address of any variable c has provided a special unary operator & which is known as dereferencing operator or address operator. It operator is only used with variables not with the constant. For example:

#include<stdio.h>

int main(){

int a=5;

printf("Address of variable a is: %d",&a);

return 0;

}

We cannot write: &&a, because:

&&a=& (&a) =& (address of variable a) =& (a constant number)

And we cannot use address operator with constant.

Important points about address of variables in c:

(1)Address of any variable in c is an unsigned integer. It cannot be a negative number. So in printf statement we should use %u instead of %d, to print the address of any variable.

%d: It is used to print signed decimal number.

%u: It is used to print unsigned decimal number.

Since, if the address of any variable will beyond the range of signed short int it will print a cyclic value.

(2)Address of any variable must be within the range 0000 to FFFF in hexadecimal number format or 0 to 65535 i.e. range of unsigned short int in c. To print the address of any variable in hexadecimal number format by printf function we should use %x or %X.

%x: To print a number in hexadecimal format using 0 to 9 and a, b, c, d, e, f.

%X: To print a number in hexadecimal format using 0 to 9 and A, B, C, D, E, F.

(3)A programmer cannot know at which address a variable will store the data. It is decided by compiler or operating system.

(4)Any two variables in c cannot have same physical address.

(5)Address of any variable reserve two bytes of memory spaces.

(6) Address of any variable in c is not integer type so to assign an address to a integral variable we have to type cast the address. For example:

#include<stdio.h>

int main(){

int a=100;

unsigned int b=(unsigned)&b;

printf("%u",b);

return 0;

}

Address arithmetic in c:

(1) We can subtract address of any two variables. For example:

#include<stdio.h>

int main(){

int a;

int b;

printf("%d",&b-&a);

return 0;

}

(2)We cannot add, multiply, divide two addresses.

(3) we can add or subtract a integer number with address.

(3)Other operators which can be used with addresses are:

(a)Negation operator:!

(b)Size operator: sizeof

(c)Type casting operator: (Type)

(e) Dereferencing operator: *

(f)Logical operator: &&, ||

Example:

#include<stdio.h>

int main(){

int a=12;

printf("%d",!&a);

printf("%d",sizeof(&a));

printf("%d",(int)&a);

printf("%d",*&a);

printf("%d %d %d %d",&a&&&b,&a&&b,&a||&b,&a||b);

return 0;

}

Declaration of a variable in c

2011-08-07T02:46:00.004-07:00

Declaration of a variable in c :

Declaration of variables means to acknowledge the compiler only about variable name and its data type with its modifiers but compiler doesn’t reserve any memory for the variables.

In c we can declared any variable with help of extern keyword while it has not initialized. Example of declaration:

(1) extern int a;

(2)extern struct student{

char * name;

int roll;

double marks;

};

Important points about declaration variables in c:

(1) Since declaration variable doesn’t get any memory space so we cannot assign any value to variable. For example:

#include<stdio.h>

extern int a;

int main(){

a=100;

printf("%d",a);

return 0;

}

Output: Compilation error

(2) We cannot use any operator with a variable which has only declared.

(3)We can declare any variable either globally or locally.

(4)A same variable can be declared many times.

Definition of variables in c:

A c statement in which a variable gets a memory is known as definition of variable. All auto, register, static and initialized extern variable are example of definition of variables. For example:

(a)

int a; //Definition of variable a

static int a; //Definition of variable a

register int a; //Definition of variable a

extern int a=5; //Definition of variable a

Note: In the above c statement all variables has been declared and defined at the same time.

(b)

#include<stdio.h>

extern int a; //Declaration of variable a

extern int a; //Again declaration of variable a

int a=5; //Definition of variable a

int main(){

ptintf("%d",a);

return 0;

}

Output: 5

Important points about definition of variable:

(1)If any variable has not declared then it declaration occurs at the time of definition.

(2)We can use any operator after the definition of variable.

(3)Definition of variables can be globally or locally.

(4)A register variable gets CPU instead of memory in definition.

(5)A static or extern variable gets memory at the compile time while auto and register variables get memory or CPU at the run time.

Value of variable in c language

2011-08-07T02:46:00.002-07:00

Value of variable in c language :

Data which any variable keeps is known as value of variable. For example:

int a=5;

Here value of variable a is five. Name of variable always returns value of the variable.

How to assign any value to a variable:

C supports eleven type of assignment operator to assign any value to operator. Those are:

(a) = (b) += (c) -= (d) v*= (e) /= (f) %=

(g) <<= (h) >>= (i) |= (j) &= (k) ^=

In this chapter will discuss only first operator i.e. =

Assignment statement in c:

LValue: Lvalue stands for left value. In any assignment statement LValue must be a container i.e. which have ability to hold the data. In c has only one type only container and which is variable. Hence LValue must be any variable in c it cannot be a constant, function or any other data type of c. For example

#define <stdio.h>

#define max 125

struct abc{

char *name;

int roll;

};

enum {RED,BLUE};

int main(){

int a;

const b;

a=5;

//10=5; LValue cannot be a integer constant

//max=20; //Lvalue cannot be a micro constant

//b=11; Lvalue cannot be a constant variable

//float=3.3f; Lvalue cannot be a data type

//abc={“sachin”,5}; Lvalue cannot be a data type

//BLUE =2; Lvalue cannot be a enum constant

return 0;

}

RValue: In any assignment statement RValue must be anything which can return and constant value or it is itself a constant. RValue can be any c constants, variables, function which is returning a value etc. For example:

#include<stdio.h>

#define max 5

void display();

float sum();

enum {BLACK, WHITE};

int main(){

int x=2; //RValue can be a constant.

float y=9.0;

const int z=x; //RValue can be a constant variable

x=max; //RValue can be a variable.

x=BLACK; //RValue can be a enum constant.

y=sum();//RValue can be a function.

y=display(); //RValue can be a function which is

return 0;

}

Memory mapping in c

2011-08-06T11:31:00.000-07:00

Basic knowledge before staring c programming language :

1. List the five c compilers?

2. Describe turbo c compiler?

3. What is hexadecimal number system?

4. What will be address range which can be represented in 20 bit?

5. What is difference between TSR and TSO program?

7. What is difference between .com program and .exe 8rogram?

Memory Organization: DOS as example:

1. What is memory cell?

2. What is residence memory?

3. What is physical address?

4. What is segmentation?

5. What is offset address?

6. What is data segment?

Data segment in c

2011-08-06T11:24:00.000-07:00

Data segment in c :

All the segments are used for specific purpose. Like segment number 15 is used for ROM, segment number 14 is used for BIOS etc.

We will discuss about how to access text video memory, graphics video memory in the pointer and union chapters of 255 bits color graphics programming.

Segment number eight has special name which is known as data segment. This segment has been divided into four parts. This is very important for c programming

1. Stack area

All automatic variables and constants are stored into stack area. Automatic variables and constants in c:

1. All the local variables of default storage class.

2. Variables of storage calls auto.

3. Integer constants, character constants, string constants, float constants etc in any expression.

4. Function parameters and function return value.

Variables in the stack area are always deleted when program control reaches it out of scope. Due to this stack area is also called temporary memory area. For example:

What will be output of following c code?

#include<stdio.h>

int main(){

int i;

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

int a=5;

printf("%d",a);

}

return 0;

}

Output: 5 5 5

Explanation: Since variable a is automatic variable, it will store in the stack area. Scope of variable a is within for loop. So after each iteration variable a will be deleted from stack and in each iteration variable a will initialize.

This two concepts are only for Turbo C 3.0

It follows LIFO data structure. That in the stack area of memory data is stored in last in first out. For example:

What will be output of flowing c code. (Turbo c 3.0)?

#include<stdio.h>

int main(){

int a =5, b = 6, c = 7,d =8;

printf("%d %d %d");

return 0;

}

Output: 8 7 6

Explanation:

Default storage class of variables a, b, c and d is auto .Since it automatic variable it will be sorted in the stack area of memory. It will store in the stack as

Stack always follows LIFO data structure. In the printf function, name of variables is not written explicitly. So default output will content of stack which will be in the LIFO order i.e. 8 7 6.

It has two part one for initialize variable another for non-initialize variable. All initialize variables are more nearer than not initialized variable and vice versa. For example:

What will be output of following program (Turbo c 3.0)?

#include<stdio.h>

int main(){

int a =5, b, c =7;

printf("%d %d %d");

return 0;

}

Output: 7 5 garbage value

Explanation:

Automatic variable a and c has initialized while b has not initialized. Initialize variables are more nearer than uninitialized variable .They will be stored in the stack. So due to LIFO first output will be 7 then 6 (since a is more nearer than b with respect to c) then any garbage value will be output which is present in the stack.

Note: Default storage class of any local variable is auto.

2. Data area:

All static and extern variable are stored in the data area. It is permanent memory space and variable will store in the memory unless and until program end. For example:

What will be output of following c code?

#include<stdio.h>

int main(){

int i;

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

static int a=5;

printf("%d",a);

}

return 0;

}

Output: 5 6 7

3. Heap area:

This memory area is use to allocate memory dynamically. In c we can allocate the memory space dynamically by using function malloc and calloc. It always allocates memory in the heap area. Its size is variable and depends upon free space in the memory.

4. Code area:

Function pointer can only access code area. Size of this area is always fixed and it is read only memory area.

Offset address meaning

2011-08-06T11:19:00.000-07:00

Offset address meaning :

Each segment has divided into two parts.

1. Segment no (4 bit)

2. Offset address (16 bit)

So, in the other words we can say memory address of any variable in c has two parts segment number and offset address.

In turbo c 3.0 a particular segment number offset address varies from 0x0000 to 0xFFFF

Suppose physical address of any variable in c is 0x500F1.

Then its segment number is 5 and offset address is 00F1.

Write a program to find the offset address of any variable?

#include<stdio.h>

int main(){

int x;

printf("%u ",&x); //To print offset address

printf("%p ",x); //To print segment address

printf("%p ",&x); //To print offset address

printf("%fp ",&x); //To print segment address : offset address

return 0;

}

Segmentation in operating system

2011-08-06T11:17:00.000-07:00

Segmentation in operating system :

Residential memory of RAM of size 1MB has divided into 16
equal parts. These parts is called segment. Each segment
has size is 64 KB.

16 * 64 KB = 1 MB

This process of division is known as segmentation.

Note: In turbo c 3.0 physical addresses of any variables

are stored in the 20 bits. But we have not any pointers

(We will discuss later what is pointer?)of size 20 bits.

So pointers cannot access whole residence memory

address.To solve this problem we there are three types

pointers in c language. They are

1. Near pointer

2. Far pointer

3. Huge pointer

physical address of computer

2011-08-06T11:15:00.000-07:00

physical address of computer :

All the c variables are stored in the residence memory.
In turbo C 3.0, 20 bits address of the memory cell is
known as physical address or real address. In 20 bits,
we can represent address from 0x00000 to 0xFFFFF. That
is all c variables must have memory address within this
range.

A C programmer cannot not decides what will be the memory

address of any variables. It is decided by compiler. For Example:

What will be output of following c code?

#include<stdio.h>

int main(){

int a;

printf("%x",&x);

return 0;

}

Output: We cannot predict.

But we can say in 16 bits compilers address must be

within 0x0000 to 0xFFFF and in 32 bits compilers memory

address must be within 0x00000000 to 0xFFFFFFFF.

Note: Suppose your c compiler is based on the

microprocessor which total address buses are 32 then its

total size of addressable memory will be:

= 2 ^ 32 bytes

= 4 GB

What is residence memory in c programming language?

2011-08-06T11:12:00.000-07:00

What is residence memory in c programming language?

RAM has divided into two parts:

(1) Extended memory (useless)

(2) Residence memory

In Turbo C 3.0 compiler size of residence memory is 1MB.

Residence memory:

When any program is executed it is stored in the
residence memory. For turbo c 3.0, it has 1MB residence
memory i.e. when we open turbo c 3.0 it stores 1MB in the
RAM.

Memory cell in computer

2011-08-06T11:08:00.000-07:00

Memory cell in computer :

Entire RAM has divided in numbers of equal parts, which are

known as memory cells. Following diagram represents the 256

MB RAM.

Each cell can store one-byte data. Data are stored in the
binary number system. That is a character data reserves one
memory cell while floating data reserves four memory cells.

Each memory cell has unique address. Address is always in
whole number and must be in increasing order. We will discuss
how a characters, integers etc. data are in stored in the
data type chapter. Just for now assume

int a = 4;

Here variables a stores in the memory in the flowing way:

If you know memory address of first cell is 0x5000 then
what would be the memory address of next memory cell?

It will 5001 since integer data always stores at
continuous memory location and as we know memory address
always in increasing order.

Difference between .com program and .exe program in c programming language

2011-08-06T11:06:00.000-07:00

Difference between .com program and .exe program in c programming language:

Both .com and .exe program are executable program but .com program execute faster than .exe program. All drivers are .com program.

Difference between TSR and TSO program

2011-08-06T11:04:00.000-07:00

Difference between TSR and TSO program :

TSO means terminate but stay outside. It is that program, which release the main memory after the execution of the program. Example ms paint, notepad, turbo c compilers etc.

TSR means terminate but stay residence .It is those program, which after the execution of the program does not release the RAM (main memory).e.g. antivirus.

What will be address range which can be represented in 20 bit?

2011-08-06T11:02:00.000-07:00

What will be address range which can be represented in 20 bit?

	*Binary*	*Hexadecimal*
*Min possible*	0000 0000 0000 0000 0000	00000
*Max possible*	1111 1111 1111 1111 1111	FFFFF

In c any hexadecimal number start with 0x 0r 0X So, address range will be 0x0000 to 0xFFFF. So in turbo C 3.0 memory address of all variables must be within 0x0000 to oxFFFF.

It is 1MB memory range.

Note.

2^10 = 1KB

2^20 = 1MB

2^30 = 1GB

Where 10, 20, 30 are number of bit.

Hexadecimal representation in c

2011-08-06T11:00:00.000-07:00

Hexadecimal representation in c :

In hexadecimal number system we use 16 different digits so its base is 16. List of all hexadecimal digits:

Hexadecimal digit	Decimal equivalent	Binary equivalent
0	0	0000
1	1	0001
2	2	0010
3	3	0011
4	4	0100
5	5	0101
6	6	0110
7	7	0111
8	8	1000
9	9	1001
A	10	1010
B	11	1011
C	12	1100
D	13	1101
E	14	1110
F	15	1111

To convert the binary number into hexadecimal number:

Make the group of four binary digits from right to left and replace the four binary digits with the equivalent hexadecimal digit using above table.

For example:

Binary number = 11000111110101

Group of four digits from right side:

to make group of four digit of left most digit 11 , add two zero at the left side i.e. 0011

Now put the equivalent hexadecimal digit using above table

So, equivalent hexadecimal number will be 31F5

Turbo c compiler

2011-08-06T10:57:00.000-07:00

Turbo c compiler :

Turbo c compiler is one of the most popular c compilers. It is based on DOS operating system. It uses 8086 microprocessor which is 16 bit microprocessor. It has 20 address buses and 16 data bus. Its word length is two byte.

Memory mapping in c

2011-08-06T10:51:00.000-07:00

List the five c compilers?

There are various c compilers are variables. Some of these are:

S.N.	Name	Micropreocessor	O.S.
1	Turbo c 3.0	8086	M.S. DOS
2	Ansic c	80386	LINUX/UNIX
3	Borland c 4.0	80386	WINDOW
4	Microsoft c	8086	M.S. DOS
5	Visual c++	80386	WINDOW

Note: 8086 is 16 bit microprocessor while 80386 is 32 bit microprocessor.

Note: Different versions of compilers are based on the different microprocessors and support many OS. It is always changing. As a programmer you should know the microprocessor name, its world length etc. which your compiler is based on. Since c language is platform dependent. In preprocessor section you will know how to make a program as much as platform independent.

Lesson 18

2011-08-06T01:08:00.000-07:00

Binary Trees in C:

The binary tree is a fundamental data structure used in computer science. The binary tree is a useful data structure for rapidly storing sorted data and rapidly retrieving stored data. A binary tree is composed of parent nodes, or leaves, each of which stores data and also links to up to two other child nodes (leaves) which can be visualized spatially as below the first node with one placed to the left and with one placed to the right. It is the relationship between the leaves linked to and the linking leaf, also known as the parent node, which makes the binary tree such an efficient data structure. It is the leaf on the left which has a lesser key value (i.e., the value used to search for a leaf in the tree), and it is the leaf on the right which has an equal or greater key value. As a result, the leaves on the farthest left of the tree have the lowest values, whereas the leaves on the right of the tree have the greatest values. More importantly, as each leaf connects to two other leaves, it is the beginning of a new, smaller, binary tree. Due to this nature, it is possible to easily access and insert data in a binary tree using search and insert functions recursively called on successive leaves.

The typical graphical representation of a binary tree is essentially that of an upside down tree. It begins with a root node, which contains the original key value. The root node has two child nodes; each child node might have its own child nodes. Ideally, the tree would be structured so that it is a perfectly balanced tree, with each node having the same number of child nodes to its left and to its right. A perfectly balanced tree allows for the fastest average insertion of data or retrieval of data. The worst case scenario is a tree in which each node only has one child node, so it becomes as if it were a linked list in terms of speed. The typical representation of a binary tree looks like the following:

/ \

6 14

/ \ / \

5 8 11 18

The node storing the 10, represented here merely as 10, is the root node, linking to the left and right child nodes, with the left node storing a lower value than the parent node, and the node on the right storing a greater value than the parent node. Notice that if one removed the root node and the right child nodes, that the node storing the value 6 would be the equivalent a new, smaller, binary tree.
The structure of a binary tree makes the insertion and search functions simple to implement using recursion. In fact, the two insertion and search functions are also both very similar. To insert data into a binary tree involves a function searching for an unused node in the proper position in the tree in which to insert the key value. The insert function is generally a recursive function that continues moving down the levels of a binary tree until there is an unused leaf in a position which follows the rules of placing nodes. The rules are that a lower value should be to the left of the node, and a greater or equal value should be to the right. Following the rules, an insert function should check each node to see if it is empty, if so, it would insert the data to be stored along with the key value (in most implementations, an empty node will simply be a NULL pointer from a parent node, so the function would also have to create the node). If the node is filled already, the insert function should check to see if the key value to be inserted is less than the key value of the current node, and if so, the insert function should be recursively called on the left child node, or if the key value to be inserted is greater than or equal to the key value of the current node the insert function should be recursively called on the right child node. The search function works along a similar fashion. It should check to see if the key value of the current node is the value to be searched. If not, it should check to see if the value to be searched for is less than the value of the node, in which case it should be recursively called on the left child node, or if it is greater than the value of the node, it should be recursively called on the right child node. Of course, it is also necessary to check to ensure that the left or right child node actually exists before calling the function on the node.
Because binary trees have log (base 2) n layers, the average search time for a binary tree is log (base 2) n. To fill an entire binary tree, sorted, takes roughly log (base 2) n * n. Let's take a look at the necessary code for a simple implementation of a binary tree. First, it is necessary to have a struct, or class, defined as a node.

struct node
{
  int key_value;
  struct node *left;
  struct node *right;
};

The struct has the ability to store the key_value and contains the two child nodes which define the node as part of a tree. In fact, the node itself is very similar to the node in a linked list. A basic knowledge of the code for a linked list will be very helpful in understanding the techniques of binary trees. Essentially, pointers are necessary to allow the arbitrary creation of new nodes in the tree.

There are several important operations on binary trees, including inserting elements, searching for elements, removing elements, and deleting the tree. We'll look at three of those four operations in this tutorial, leaving removing elements for later.

We'll also need to keep track of the root node of the binary tree, which will give us access to the rest of the data:

struct node *root = 0;

It is necessary to initialize root to 0 for the other functions to be able to recognize that the tree does not yet exist. The destroy_tree shown below which will actually free all of the nodes of in the tree stored under the node leaf: tree.

void destroy_tree(struct node *leaf)
{
  if( leaf != 0 )
  {
      destroy_tree(leaf->left);
      destroy_tree(leaf->right);
      free( leaf );
  }
}

The function destroy_tree goes to the bottom of each part of the tree, that is, searching while there is a non-null node, deletes that leaf, and then it works its way back up. The function deletes the leftmost node, then the right child node from the leftmost node's parent node, then it deletes the parent node, then works its way back to deleting the other child node of the parent of the node it just deleted, and it continues this deletion working its way up to the node of the tree upon which delete_tree was originally called. In the example tree above, the order of deletion of nodes would be 5 8 6 11 18 14 10. Note that it is necessary to delete all the child nodes to avoid wasting memory.

The following insert function will create a new tree if necessary; it relies on pointers to pointers in order to handle the case of a non-existent tree (the root pointing to NULL). In particular, by taking a pointer to a pointer, it is possible to allocate memory if the root pointer is NULL.

insert(int key, struct node **leaf)
{
    if( *leaf == 0 )
    {
        *leaf = (struct node*) malloc( sizeof( struct node ) );
        (*leaf)->key_value = key;
        /* initialize the children to null */
        (*leaf)->left = 0;    
        (*leaf)->right = 0;  
    }
    else if(key < (*leaf)->key_value)
    {
        insert( key, &(*leaf)->left );
    }
    else if(key > (*leaf)->key_value)
    {
        insert( key, &(*leaf)->right );
    }
}

The insert function searches, moving down the tree of children nodes, following the prescribed rules, left for a lower value to be inserted and right for a greater value, until it reaches a NULL node--an empty node--which it allocates memory for and initializes with the key value while setting the new node's child node pointers to NULL. After creating the new node, the insert function will no longer call itself. Note, also, that if the element is already in the tree, it will not be added twice.

struct node *search(int key, struct node *leaf)
{
  if( leaf != 0 )
  {
      if(key==leaf->key_value)
      {
          return leaf;
      }
      else if(key<leaf->key_value)
      {
          return search(key, leaf->left);
      }
      else
      {
          return search(key, leaf->right);
      }
  }
  else return 0;
}

The search function shown above recursively moves down the tree until it either reaches a node with a key value equal to the value for which the function is searching or until the function reaches an uninitialized node, meaning that the value being searched for is not stored in the binary tree. It returns a pointer to the node to the previous instance of the function which called it.

Lesson 17

2011-08-06T01:01:00.000-07:00

Functions with Variable Argument Lists in C using va_list:

Perhaps you would like to have a function that will accept any number of values and then return the average. You don't know how many arguments will be passed in to the function. One way you could make the function would be to accept a pointer to an array. Another way would be to write a function that can take any number of arguments. So you could write avg(4, 12.2, 23.3, 33.3, 12.1); or you could write avg(2, 2.3, 34.4); The advantage of this approach is that it's much easier to change the code if you want to change the number of arguments. Indeed, some library functions can accept a variable list of arguments (such as printf--I bet you've been wondering how that works!). Whenever a function is
declared to have an indeterminate number of arguments, in place of the last argument you should place an ellipsis (which looks like '...'), so, int a_function ( int x, ... ); would tell the compiler the function should accept however many arguments that the programmer uses, as long as it is equal to at least one, the one being the first, x. We'll need to use some macros (which work much like functions, and you can treat them as such) from the stdarg.h header file to extract the values stored in the variable argument list--va_start, which initializes the list, va_arg, which returns the next argument in the list, and va_end, which cleans up the variable argument list. To use these functions, we need a variable capable of storing a variable-length argument list--this variable will be of type va_list. va_list is like any other type. For example, the following code declares a list that can be used to store a variable number of arguments.
va_list a_list;
va_start is a macro which accepts two arguments, a va_list and the name of the variable that directly precedes the ellipsis ("..."). So in the function a_function, to initialize a_list with va_start, you would write va_start ( a_list, x );
int a_function ( int x, ... ) { va_list a_list; va_start( a_list, x ); }
va_arg takes a va_list and a variable type, and returns the next argument in the list in the form of whatever variable type it is told. It then moves down the list to the next argument. For example, va_arg ( a_list, double ) will return the next argument, assuming it exists, in the form of a double. The next time it is called, it will return the argument following the last returned number, if one exists. Note that you need to know the type of each argument--that's part of why printf requires a format string! Once you're done, use va_end to clean up the list: va_end( a_list );

To show how each of the parts works, take an example function:
#include <stdarg.h> #include <stdio.h> double average ( int num, ... ) { va_list arguments; double sum = 0; /* Initializing arguments to store all values after num */ va_start ( arguments, num ); /* Sum all the inputs; we still rely on the function caller to tell us how * many there are */ for ( int x = 0; x < num; x++ ) { sum += va_arg ( arguments, double ); } va_end ( arguments ); // Cleans up the list return sum / num; } int main() { printf( "%f\n", average ( 3, 12.2, 22.3, 4.5 ) ); printf( "%f\n", average ( 5, 3.3, 2.2, 1.1, 5.5, 3.3 ) ); }
It isn't necessarily a good idea to use a variable argument list at all times; the potential exists for assuming a value is of one type, while it is in fact another, such as a null pointer being assumed to be an integer. Consequently, variable argument lists should be used sparingly.

Lesson 16: Recursion in C

2011-08-06T00:58:00.000-07:00

Recursion is a programming technique that allows the programmer to express operations in terms of themselves. In C++, this takes the form of a function that calls itself. A useful way to think of recursive functions is to imagine them as a process being performed where one of the instructions is to "repeat the process". This makes it sound very similar to a loop because it repeats the same code, and in some ways it is similar to looping. On the other hand, recursion makes it easier to express ideas in which the result of the recursive call is necessary to complete the task. Of course, it must be possible for the "process" to sometimes be completed without the recursive call. One simple example is the idea of building a wall that is ten feet high; if I want to build a ten foot high wall, then I will first build a 9 foot high wall, and then add an extra foot of bricks. Conceptually, this is like saying the "build wall" function takes a height and if that height is greater than one, first calls itself to build a lower wall, and then adds one a foot of bricks.

A simple example of recursion would be:

 
void recurse()
{
    recurse(); /* Function calls itself */
}

int main()
{
    recurse(); /* Sets off the recursion */
    return 0;
}

This program will not continue forever, however. The computer keeps function calls on a stack and once too many are called without ending, the program will crash. Why not write a program to see how many times the function is called before the program terminates?

 
#include <stdio.h>

void recurse ( int count ) /* Each call gets its own copy of count */
{
    printf( "%d\n", count );
    /* It is not necessary to increment count since each function's
       variables are separate (so each count will be initialized one greater)
     */
    recurse ( count + 1 );
}

int main()
{
  recurse ( 1 ); /* First function call, so it starts at one */
  return 0;
}

This simple program will show the number of times the recurse function has been called by initializing each individual function call's count variable one greater than it was previous by passing in count + 1. Keep in mind that it is not a function call restarting itself; it is hundreds of function calls that are each unfinished.

The best way to think of recursion is that each function call is a "process" being carried out by the computer. If we think of a program as being carried out by a group of people who can pass around information about the state of a task and instructions on performing the task, each recursive function call is a bit like each person asking the next person to follow the same set of instructions on some part of the task while the first person waits for the result.

At some point, we're going to run out of people to carry out the instructions, just as our previous recursive functions ran out of space on the stack. There needs to be a way to avoid this! To halt a series of recursive calls, a recursive function will have a condition that controls when the function will finally stop calling itself. The condition where the function will not call itself is termed the base case of the function. Basically, it will usually be an if-statement that checks some variable for a condition (such as a number being less than zero, or greater than some other number) and if that condition is true, it will not allow the function to call itself again. (Or, it could check if a certain condition is true and only then allow the function to call itself).

A quick example:

 
void count_to_ten ( int count )
{
    /* we only keep counting if we have a value less than ten
       if ( count < 10 )   
       {
           count_to_ten( count + 1 );
       }
}
int main()
{
  count_to_ten ( 0 ); 
}

This program ends when we've counted to ten, or more precisely, when count is no longer less than ten. This is a good base case because it means that if we have an input greater than ten, we'll stop immediately. If we'd chosen to stop when count equaled ten, then if the function were called with the input 11, it would run out of memory before stopping.

Notice that so far, we haven't done anything with the result of a recursive function call. Each call takes place and performs some action that is then ignored by the caller. It is possible to get a value back from the caller, however. It's also possible to take advantage of the side effects of the previous call. In either case, once a function has called itself, it will be ready to go to the next line after the call. It can still perform operations. One function you could write could print out the numbers 123456789987654321. How can you use recursion to write a function to do this? Simply have it keep incrementing a variable passed in, and then output the variable twice: once before the function recurses, and once after.

 
void printnum ( int begin )
{
    printf( "%d", begin );
    if ( begin < 9 )         /* The base case is when begin is no longer */
    {                           /* less than 9 */
        printnum ( begin + 1 ); 
    }
    /* display begin again after we've already printed everything from 1 to 9
     * and from 9 to begin + 1 */
    printf( "%d", begin );
}

This function works because it will go through and print the numbers begin to 9, and then as each printnum function terminates it will continue printing the value of begin in each function from 9 to begin.

This is, however, just touching on the usefulness of recursion. Here's a little challenge: use recursion to write a program that returns the factorial of any number greater than 0. (Factorial is number*number-1*number-2...*1).

Hint: Your function should recursively find the factorial of the smaller numbers first, i.e., it takes a number, finds the factorial of the previous number, and multiplies the number times that factorial...have fun. :-)

Lesson 15: Singly linked lists in C

2011-08-06T00:55:00.000-07:00

Linked lists are a way to store data with structures so that the programmer can automatically create a new place to store data whenever necessary. Specifically, the programmer writes a struct definition that contains variables holding information about something and that has a pointer to a struct of its same type (it has to be a pointer--otherwise, every time an element was created, it would create a new element, infinitely). Each of these individual structs or classes in the list is commonly known as a node or element of the list.

One way to visualize a linked list is as though it were a train. The programmer always stores the first node of the list in a pointer he won't lose access to. This would be the engine of the train. The pointer itself is the connector between cars of the train. Every time the train adds a car, it uses the connectors to add a new car. This is like a programmer using malloc to create a pointer to a new struct.

In memory a linked list is often described as looking like this:

 
----------        ----------
- Data   -        - Data   -    
----------        ----------   
- Pointer- - - -> - Pointer-  
----------        ----------

The representation isn't completely accurate in all of its details, but it will suffice for our purposes. Each of the big blocks is a struct that has a pointer to another one. Remember that the pointer only stores the memory location of something--it is not that thing itself--so the arrow points to the next struct. At the end of the list, there is nothing for the pointer to point to, so it does not point to anything; it should be a null pointer or a dummy node to prevent the node from accidentally pointing to a random location in memory (which is very bad).

So far we know what the node struct should look like:

 
#include <stdlib.h>

struct node {
  int x;
  struct node *next;
};

int main()
{
    /* This will be the unchanging first node */
    struct node *root;      

    /* Now root points to a node struct */
    root = malloc( sizeof(struct node) ); 

    /* The node root points to has its next pointer equal to a null pointer 
       set */
    root->next = 0;  
    /* By using the -> operator, you can modify what the node,
       a pointer, (root in this case) points to. */
    root->x = 5;     
}

This so far is not very useful for doing anything. It is necessary to understand how to traverse (go through) the linked list before it really becomes useful. This will allow us to store some data in the list and later find it without knowing exactly where it is located.

Think back to the train. Let's imagine a conductor who can only enter the train through the first car and can walk through the train down the line as long as the connector connects to another car. This is how the program will traverse the linked list. The conductor will be a pointer to node, and it will first point to root, and then, if the root's pointer to the next node is pointing to something, the "conductor" (not a technical term) will be set to point to the next node. In this fashion, the list can be traversed. Now, as long as there is a pointer to something, the traversal will continue. Once it reaches a null pointer (or dummy node), meaning there are no more nodes (train cars) then it will be at the end of the list, and a new node can subsequently be added if so desired.

Here's what that looks like:

 
#include <stdio.h>
#include <stdlib.h>

struct node {
  int x;
  struct node *next;
};

int main()
{
    /* This won't change, or we would lose the list in memory */
    struct node *root;       
    /* This will point to each node as it traverses the list */
    struct node *conductor;  

    root = malloc( sizeof(struct node) );  
    root->next = 0;   
    root->x = 12;
    conductor = root; 
    if ( conductor != 0 ) {
        while ( conductor->next != 0)
        {
            conductor = conductor->next;
        }
    }
    /* Creates a node at the end of the list */
    conductor->next = malloc( sizeof(struct node) );  

    conductor = conductor->next; 

    if ( conductor == 0 )
    {
        printf( "Out of memory" );
        return 0;
    }
    /* initialize the new memory */
    conductor->next = 0;         
    conductor->x = 42;

    return 0;
}

That is the basic code for traversing a list. The if statement ensures that the memory was properly allocated before traversing the list. If the condition in the if statement evaluates to true, then it is okay to try and access the node pointed to by conductor. The while loop will continue as long as there is another pointer in the next. The conductor simply moves along. It changes what it points to by getting the address of conductor->next.

Finally, the code at the end can be used to add a new node to the end. Once the while loop as finished, the conductor will point to the last node in the array. (Remember the conductor of the train will move on until there is nothing to move on to? It works the same way in the while loop.) Therefore, conductor->next is set to null, so it is okay to allocate a new area of memory for it to point to (if it weren't NULL, then storing something else in the pointer would cause us to lose the memory that it pointed to). When we allocate the memory, we do a quick check to ensure that we're not out of memory, and then the conductor traverses one more element (like a train conductor moving on to the newly added car) and makes sure that it has its pointer to next set to 0 so that the list has an end. The 0 functions like a period; it means there is no more beyond. Finally, the new node has its x value set. (It can be set through user input. I simply wrote in the '=42' as an example.)

To print a linked list, the traversal function is almost the same. In our first example, it is necessary to ensure that the last element is printed after the while loop terminates. (See if you can think of a better way before reading the second code example.)

For example:

 
conductor = root;
if ( conductor != 0 ) { /* Makes sure there is a place to start */
    while ( conductor->next != 0 ) {
        printf( "%d\n", conductor->x );
        conductor = conductor->next;
    }
    printf( "%d\n", conductor->x );
}

The final output is necessary because the while loop will not run once it reaches the last node, but it will still be necessary to output the contents of the next node. Consequently, the last output deals with this. We can avoid this redundancy by allowing the conductor to walk off of the back of the train. Bad for the conductor (if it were a real person), but the code is simpler as it also allows us to remove the initial check for null (if root is null, then conductor will be immediately set to null and the loop will never begin):

 
conductor = root;
while ( conductor != NULL ) {
    printf( "%d\n", conductor->x );
    conductor = conductor->next;
}

Lesson 14

2011-08-06T00:52:00.000-07:00

Accepting command line arguments in C using argc and argv:

In C it is possible to accept command line arguments. Command-line arguments are given after the name of a program in command-line operating systems like DOS or Linux, and are passed in to the program from the operating system. To use command line arguments in your program, you must first understand the full declaration of the main function, which previously has accepted no arguments. In fact, main can actually accept two arguments: one argument is number of command line arguments, and the other argument is a full list of all of the command line arguments.

The full declaration of main looks like this:

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

The integer, argc is the argument count. It is the number of arguments passed into the program from the command line, including the name of the program.

The array of character pointers is the listing of all the arguments. argv[0] is the name of the program, or an empty string if the name is not available. After that, every element number less than argc is a command line argument. You can use each argv element just like a string, or use argv as a two dimensional array. argv[argc] is a null pointer.

How could this be used? Almost any program that wants its parameters to be set when it is executed would use this. One common use is to write a function that takes the name of a file and outputs the entire text of it onto the screen.

 
#include <stdio.h>

int main ( int argc, char *argv[] )
{
    if ( argc != 2 ) /* argc should be 2 for correct execution */
    {
        /* We print argv[0] assuming it is the program name */
        printf( "usage: %s filename", argv[0] );
    }
    else 
    {
        // We assume argv[1] is a filename to open
        FILE *file = fopen( argv[1], "r" );

        /* fopen returns 0, the NULL pointer, on failure */
        if ( file == 0 )
        {
            printf( "Could not open file\n" );
        }
        else 
        {
            int x;
            /* read one character at a time from file, stopping at EOF, which
               indicates the end of the file.  Note that the idiom of "assign
               to a variable, check the value" used below works because
               the assignment statement evaluates to the value assigned. */
            while  ( ( x = fgetc( file ) ) != EOF )
            {
                printf( "%c", x );
            }
            fclose( file );
        }
    }
}

This program is fairly short, but it incorporates the full version of main and even performs a useful function. It first checks to ensure the user added the second argument, theoretically a file name. The program then checks to see if the file is valid by trying to open it. This is a standard operation, and if it results in the file being opened, then the return value of fopen will be a valid FILE*; otherwise, it will be 0, the NULL pointer. After that, we just execute a loop to print out one character at a time from the file. The code is self-explanatory, but is littered with comments; you should have no trouble understanding its operation this far into the tutorial. :-)

Lesson 11

2011-08-06T00:49:00.000-07:00

Typecasting:

Typecasting is a way to make a variable of one type, such as an int, act like another type, such as a char, for one single operation. To typecast something, simply put the type of variable you want the actual variable to act as inside parentheses in front of the actual variable. (char)a will make 'a' function as a char.

For example:

 
#include <stdio.h> 

int main()       
{
  /* The (char) is a typecast, telling the computer to interpret the 65 as a
     character, not as a number.  It is going to give the character output of 
     the equivalent of the number 65 (It should be the letter A for ASCII).
     Note that the %c below is the format code for printing a single character
   */
  printf( "%c\n", (char)65 );
  getchar();
}

One use for typecasting for is when you want to use the ASCII characters. For example, what if you want to create your own chart of all 256 ASCII characters. To do this, you will need to use to typecast to allow you to print out the integer as its character equivalent.

 
#include <stdio.h>

int main()
{
    for ( int x = 0; x < 256; x++ ) {
        /* Note the use of the int version of x to output a number and the use
         * of (char) to typecast the x into a character which outputs the
         * ASCII character that corresponds to the current number
         */
        printf( "%d = %c\n", x, (char)x );
    }
    getchar();

}

If you were paying careful attention, you might have noticed something kind of strange: when we passed the value of x to printf as a char, we'd already told the compiler that we intended the value to be treated as a character when we wrote the format string as %c. Since the char type is just a small integer, adding this typecast actually doesn't add any value!

So when would a typecast come in handy? One use of typecasts is to force the correct type of mathematical operation to take place. It turns out that in C (and other programming languages), the result of the division of integers is itself treated as an integer: for instance, 3/5 becomes 0! Why? Well, 3/5 is less than 1, and integer division ignores the remainder.

On the other hand, it turns out that division between floating point numbers, or even between one floating point number and an integer, is sufficient to keep the result as a floating point number. So if we were performing some kind of fancy division where we didn't want truncated values, we'd have to cast one of the variables to a floating point type. For instance, (float)3/5 comes out to .6, as you would expect!

When might this come up? It's often reasonable to store two values in integers. For instance, if you were tracking heart patients, you might have a function to compute their age in years and the number of heart times they'd come in for heart pain. One operation you might conceivably want to perform is to compute the number of times per year of life someone has come in to see their physician about heart pain. What would this look like?

 
/* magical function returns the age in years */
int age = getAge();  
/* magical function returns the number of visits */
int pain_visits = getVisits(); 

float visits_per_year = pain_visits / age;

The problem is that when this program is run, visits_per_year will be zero unless the patient had an awful lot of visits to the doc. The way to get around this problem is to cast one of the values being divided so it gets treated as a floating point number, which will cause the compiler to treat the expression as if it were to result in a floating point number:

 
float visits_per_year = pain_visits / (float)age;
/* or */
float visits_per_year = (float)pain_visits / age;

This would cause the correct values to be stored in visits_per_year. Can you think of another solution to this problem (in this case)?

Lesson 10

2011-08-06T00:45:00.000-07:00

C File I/O and Binary File I/O:

When accessing files through C, the first necessity is to have a way to access the files. For C File I/O you need to use a FILE pointer, which will let the program keep track of the file being accessed. (You can think of it as the memory address of the file or the location of the file).

For example:

FILE *fp;

To open a file you need to use the fopen function, which returns a FILE pointer. Once you've opened a file, you can use the FILE pointer to let the compiler perform input and output functions on the file.

FILE *fopen(const char *filename, const char *mode);

In the filename, if you use a string literal as the argument, you need to remember to use double backslashes rather than a single backslash as you otherwise risk an escape character such as \t. Using double backslashes \\ escapes the \ key, so the string works as it is expected. Your users, of course, do not need to do this! It's just the way quoted strings are handled in C and C++.

The modes are as follows:

r  - open for reading
w  - open for writing (file need not exist)
a  - open for appending (file need not exist)
r+ - open for reading and writing, start at beginning
w+ - open for reading and writing (overwrite file)
a+ - open for reading and writing (append if file exists)

Note that it's possible for fopen to fail even if your program is perfectly correct: you might try to open a file specified by the user, and that file might not exist (or it might be write-protected). In those cases, fopen will return 0, the NULL pointer.

Here's a simple example of using fopen:

FILE *fp;
fp=fopen("c:\\test.txt", "r");

This code will open test.txt for reading in text mode. To open a file in a binary mode you must add a b to the end of the mode string; for example, "rb" (for the reading and writing modes, you can add the b either after the plus sign - "r+b" - or before - "rb+")

To close a function you can use the function

int fclose(FILE *a_file);

fclose returns zero if the file is closed successfully.

An example of fclose is:

fclose(fp);

To work with text input and output, you use fprintf and fscanf, both of which are similar to their friends printf and scanf except that you must pass the FILE pointer as first argument. For example:

FILE *fp;
fp=fopen("c:\\test.txt", "w");
fprintf(fp, "Testing...\n");

It is also possible to read (or write) a single character at a time--this can be useful if you wish to perform character-by-character input (for instance, if you need to keep track of every piece of punctuation in a file it would make more sense to read in a single character than to read in a string at a time.) The fgetc function, which takes a file pointer, and returns an int, will let you read a single character from a file:

int fgetc (FILE *fp);

Notice that fgetc returns an int. What this actually means is that when it reads a normal character in the file, it will return a value suitable for storing in an unsigned char (basically, a number in the range 0 to 255). On the other hand, when you're at the very end of the file, you can't get a character value--in this case, fgetc will return "EOF", which is a constant that indicates that you've reached the end of the file. To see a full example using fgetc in practice, take a look at the example here.

The fputc function allows you to write a character at a time--you might find this useful if you wanted to copy a file character by character. It looks like this:

int fputc( int c, FILE *fp );

Note that the first argument should be in the range of an unsigned char so that it is a valid character. The second argument is the file to write to. On success, fputc will return the value c, and on failure, it will return EOF.

Binary I/O:

For binary File I/O you use fread and fwrite.

The declarations for each are similar:

size_t fread(void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);
              
size_t fwrite(const void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);

Both of these functions deal with blocks of memories - usually arrays. Because they accept pointers, you can also use these functions with other data structures; you can even write structs to a file or a read struct into memory.

Let's look at one function to see how the notation works.

fread takes four arguments. Don't by confused by the declaration of a void *ptr; void means that it is a pointer that can be used for any type variable. The first argument is the name of the array or the address of the structure you want to write to the file. The second argument is the size of each element of the array; it is in bytes. For example, if you have an array of characters, you would want to read it in one byte chunks, so size_of_elements is one. You can use the sizeof operator to get the size of the various datatypes; for example, if you have a variable int x; you can get the size of x with sizeof(x);. This usage works even for structs or arrays. E.g., if you have a variable of a struct type with the name a_struct, you can use sizeof(a_struct) to find out how much memory it is taking up.

e.g.,

sizeof(int);

The third argument is simply how many elements you want to read or write; for example, if you pass a 100 element array, you want to read no more than 100 elements, so you pass in 100.

The final argument is simply the file pointer we've been using. When fread is used, after being passed an array, fread will read from the file until it has filled the array, and it will return the number of elements actually read. If the file, for example, is only 30 bytes, but you try to read 100 bytes, it will return that it read 30 bytes. To check to ensure the end of file was reached, use the feof function, which accepts a FILE pointer and returns true if the end of the file has been reached.

fwrite is similar in usage, except instead of reading into the memory you write from memory into a file.

For example,

FILE *fp;
fp=fopen("c:\\test.bin", "wb");
char x[10]="ABCDEFGHIJ";
fwrite(x, sizeof(x[0]), sizeof(x)/sizeof(x[0]), fp);