C Language introduction

-=-=-=-=-=-=-=-=-=-=-=-=-

LANGUAGES :
-----------
A set of statements is called a Language.
There are four types of languages according to their time.

I Generation Languages :
------------------------
These languages are Machine languages. To write programs in these languages
the system technology must be required. The data is non-portable. That means a
program written in a system does not work in another systems.

II Generation Languages :
-------------------------
These are Assembly Languages. These are also system oriented that means
to write any program in a system that system's technology must be required and
data is non-portable. But they used MNEMONIC words in programs. That means
they used a single word instead of more words.

III Generation Languages :

--------------------------
In these languages programs are witten in general english language. There is
no need to know the system technology and the data can be transfered anywhere.

IV Generation languages :
-------------------------
These languages are defined in any one of the above languages. These are
also called as packages.

Here I & II Generation languages are called Low Level Languages

and III & IV generation languages are called High Level Languages.

For high level languages we have to use translaters to translate the source code
written in general english language into machine language.
These translaters are two types.
1) Interpreters, 2) Compilers.

1) Interpreters :
-----------------
These translaters translate the source code step by step into machine
language until any error. If there is any error it stops and shows some message.
After correction it can continue.
Ex : BASIC, DBase III+, ....

1
2) Compilers :
--------------
These translaters translate the entire source code into machine language
when it is error-free and creates an object file in machine language. If there is any
error it shows the list of error. After debugging it creates the object file.
Ex: COBOL, C, C++, ...

C
---
The language 'C' was designed by Dennis Ritchie at AT & T Bell Laboratories.
The standardised C was released in 1979.

The 'C' language is used to develop

i) Scientific applications,
ii) Business applications,
iii) Graphical applications (Ex: WINDOWS ),
iv) System programs,
v) Operating Systems (Ex: UNIX) , ...

Character Set :
---------------
alphabets constants, statements,
digits ==> variables, ==>
==> Programs
special symbols keywords instructions
---

Constants :
-----------
The unchangeable quantities are called Constants.
The constants are generally two types.
1) Character constants :
a) Characters Ex: 'a', '5', '+', ' ', ...
b) Strings Ex: "abc", "435", 'rama", ...

2) Numeric Constants :
a) integers Ex: 435, -657, 65535, -32768,...
b) Real numbers
i) Fractional form Ex: 435.67, 345.00054, ...
ii) Exponential form Ex: 0.02e3, 1.17e-38, ...

Variables :
------------
The quantities which can be changed during the execution of program are
called Variables. A variable can be considered as the name of the cell which can
hold the constants.
To use any variable it must be declared with its data type before the first
executable statement and they can be initialised.

2
Naming the variable is very important.
1) The variable name must be start with either alphabets or an underscore and
may contain alphabets, digits, hyphen or underscore.
2) The maximum length of a variable is 8 characters. But some compilers can
accept upto 32 characters.
3) There must not be any blank spaces or special symbols in a variable name.
4) A variable name must not be a keyword.

Ex:valid invlid
eno emp name
empname emp(name
emp-name 45abc
emp_name int
_abc char
ab45

Keywords :
----------
These are predefined words. There are 32 keywords in C language.
These keywords can not be used as user-defined variables.

Operators :
-----------
There are 42 operators in C language.

1) Arithmetic Operators :

+ - * / %
Ex:
100 + 40 ==> 140
100 - 40 ==> 60
100 * 40 ==> 4000
100 / 40 ==> 2
100 % 40 ==> 20
40 % 100 ==> 40

2) Assigning Operators : =

(variable) = (constant) / (variable) / (expression) ;

Ex: a = 5
b=a
c = a + b -2

3) Multiple operators :

+= -= *= /= %=

Ex:
a=a+3 ==> a += 3
3
 a = a -3 ==> a -= 3
a = a * 3 ==> a *= 3
a = a /3 ==> a /= 3
a = a % 3 ==> a %= 3

4) Unary Operators :
++ --

Ex :
a=a+1 ==> a += 1 ==> a ++ ==> ++ a
a=a-1 ==> a -= 1 ==> a -- ==> -- a

5) Relational Operators :

== > < >= <= !=

6) Logical Operators :

&& || !

Structure of a 'C' program :

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

preprocessor commands

global declarations
main()
{
local declarations ;
statements ;
}

function(arguments)
{
local delcarations ;
statements ;
}
-------------
The 'C' program has a free formated structure.
Every statement must be terminated with a semicolor ;
A program is a collection of functions. There may be a lot of functions but at least
one function must be there that is main(), where the execution starts.
C has case sensitivity. All the keywords are defined in lower case.
So better to write entire program in lower case.
Preprocessor commands :
------------------------
The commands which start with a hash(#) symbol are called Preprocessor
commands.
4
 Ex :
# include <stdio.h>
# include "conio.h"
# define PI 3.14159

Global declarations :
---------------------
To use any variable it must be declared with its data type before the first
executable statement. The variables which declared in a block are available in that
block only.
To use the variable in the entire program with same effect it must be declared
as global.

Data Types :
------------
Type Range occupied bytes format string
----------------------------------------------------------------------------
signed char -128 to 127 1 %c
unsigned char 0 to 255 1 %c

short signed int -32768 to 32767 2 %i %d %o %x

short unsigned int 0 to 65535 2 %u
long signed int -2^16 to 2^16 -1 4 %ld
long unsigned int 0 to 2^32 -1 4 %lu

float 3.14e-38 to 3.14e38 4 %f

double 1.17e-308 to 1.17e308 8 %lf
long double 1.17e-4932 to
1.17e4932 10 %Lf
Functions :
-----------

1) clrscr() :-
----------------
This function is used to clear the screen. This function's prototype has defined
in the header file CONIO.H
( CONIO ==> Console Input Output )
Syntax :
clrscr()

2) printf() :-
---------------
This function is used to display the text and the values of variables.
This function's prototype has defined in the header file STDIO.H
To display the variable's value the format string must be used.
( STDIO ==> Standard Input Output )
Syntax :
printf(" format string ", variables) ;
Ex :
printf(" Hello \t World ");
5
 printf(" %d %c", k, j);
printf("The marks are %d, %d, %d", m1, m2, m3 );

Note :
------
The function printf() returns an integer value that is the number of
arguments given to the statement.

Remarks :
-------
To write any remarks or comments to the statements they must be enclosed
with the symbols
/* */
Ex :

/*
sdfjkshadjfsdjkafkjsadjkfhkasdj
sdafhasdfhgasdhfgasdgfgasdfhasdfj
sdafjksadfjasdkhfjasdhkfjhksda
*/

Escape Sequences :
------------------

\0 ==> Null character

\t ==> Tab ( 8 spaces)
\l ==> Line feed
\r ==> Carriage Return
\n ==> New line character ( \n = \l + \r )
\a ==> Alert (beep sound)
\' ==> Single quotes
\" ==> Double quotes
\\ ==> back slash

TURBO C editor :
----------------
It is a compiler of C program and it can be also used as an general editor. To
enter into editor first change into the directory which contains the software and
enter the command TC at the command prompt.

C:\> CD TURBOC2
C:\TURBOC2> tc

Then it opens the editor which contains a menu bar at the top, a status bar at
the bottom and a main window to write the programming statements and a sub
window which shows the messages.
The menu bar contains some menu pads and they can be selected by pressing
ALT and the highlighted character in the required menu pad.

6
 Then it shows the submenu which contains some bars and they can be selected
using arrow keys.
The status bar shows online help and the keys information.

1) To write a new program select 'New' command from "File" menu.

2) To save the working program select 'Save' command from "File" menu
or press F2 and enter a name.
3) To compile the program select 'Compile to OBJ' command from
"compile" menu or press Alt + F9. Then it shows the list of
errors or warnings. If the program is error-free then the compiler
creates an object file (.OBJ) and an executable file (.EXE).
4) To execute the program select 'Run' command from "Run" menu or
press Ctrl + F9.
5) To seee the output of the execution select 'User Screen' command
from "Run" menu or press Alt + F5.
6) To close the editor select 'Quit' command from "File" menu or
press Alt + X.

scanf() :
----------
This function is used to accept the values for the variables while executing the
program from keyboard. This function's prototype has defined in the header file
STDIO.H

Syntax:
scanf("formatstring" , &(variables) );

Note :
To accept two or more values with a single scanf() they can be seperated by
space or tab or enter key.

Ex :
i) int a;
scanf("%d", &a);
ii) int m1, m2, m3;
scanf("%d%d%d", &m1, &m2, &m3);
iii) char ch;
scanf("%c", &ch);

getch() & getche() :

--------------------
This function is used to accept a single character for the variable while
executing the program. But this function does not display the entered character.
This function's prototype has defined in the header file CONIO.H
Note : To see the entered character the function getche() can be used.
Syntax:
(variable) = getch() ;
Ex :
char c;
7
 c = getch();

Note :
------
The arithmetic expressions are three types.

integer integer ==> integer

integer float ==> float
float float ==> float

Ex :
10 / 4 ==> 2
10 / 4.0 ==> 2.5
10.0 / 4 ==> 2.5
10.0 / 4.0 ==> 2.5

Conditional Statements :
------------------------

In C language the conditional statement returns zero when the condition is

false. Otherwise it returns a non-zero(1) value when the condition is true.

There are three types of conditional statements in 'C' .

1) if, 2) switch, 3) conditional operators

1) if ... else :
------------------
Syntax :

if (condition) if (condition)
{ {
(statements); (statements);
} or }
else
{
(statements) ;
}

2) switch... case :
----------------------
Syntax:

switch(variable)
{
8
 case (value) : (statements) ;
case (value) : (statements) ;
-----
------
---
default : (statements) ;
}

break:
------
This keyword stops the execution in the given block and comes out.
Generally it is used in switch..case statements and looping statements.
3) Ternary Operators ( ? : ; ) :
---------------------------------------
Syntax :
(condition) ? (statement1) : (statement2) ;

gotoxy() :
-----------
This function changes the cursor position on the screen to the required location
by giving the x and y co-ordinates. This function's prototype was defined in the
header file CONIO.H
Syntax:
gotoxy(x, y); or gotoxy(col, row) ;
Note :
Generally in MS-DOS mode the screen contains 25 rows from top to bottom and
80 columns from left to right.

textcolor() & textbackground() :

-----------------------------------
These functions changes the colors of screen. There are 16 colors numbered
from 0 to 15. The colors may be given with numbers or color names. These
functions prototypes was defined in the header file CONIO.H
Syntax:
textcolor(colorname); or textcolor(colornumber) ;
textbackground(colorname); or textbackground(colornumber);

Colors List :
-------------
BLACK, BLUE, ... WHITE

cprintf() :
-------------
This function displays the given text with the current console settings. This
function's prototype was defined in the header file CONIO.H
Syntax:
cprintf("formatstring") ;

9
 goto :
------
This keyword changes the execution control to the required statement by
defining the statement with label. This keyword is a branching statement.
Syntax:
goto (label) ;
----
(label) :
----

Note :
------
The world wide programmers decided to avoid this keyword to reduce the
complexity in big programs.

Looping Statements :
---------------------
Repeating a block of statements number of times is called Looping.
There are three types of looping statements in 'C' .
1) for, 2) while, 3) do..while.

Note :
The keyword 'goto' is a branching statement. It can also used to execute a
block of statements number of times.

1) do ... while :
--------------------
Syntax:

do
{

(statements) ;

} while (condition) ;

Note :
------
There is a drawback in do..while looping. Here the conditional statement
executes after executing the block of statements. If the given value is less than the
initial value of the loop generating variable it displays some mistakes. To avoid
this problem we can use 'while' statement.

2) while :
-----------
Syntax:

while (condition)
{

10
 (statements) ;

3)

Arrays :
---------
An array is a collection of similar data type elements. It stores the elements in
contiguous locations. To use any array it must be declared with its size and they
may be initialized. The indexing is start with 0. The arrays are two types.
1) Single Dimensional arrays, 2) Multi Dimensional Arrays.

1) Single Dimensional Arrays :

--------------------------------
Syntax :
(type) (variable) [size] ;
Ex:
int eno[5] = { 56, 67, 45, 89, 45};
char ena[] = { 'a', 'b', 'c', 'd' } ;
float bas[] = { 56.67, 900.45, 567 } ;

2) Multi Dimensional Arrays :

-------------------------------
Ex:
int a[5][3], b[4][5][6][7], .....
char na[3][20] = { "abcdefgh", "ramakrishna", "Bhanodaya" };

A multi dimensional array is a collection of another arrays. That means a double

dimensional array is a collection of single dimensional arrays.
Ex:
The array a[5][3] is a collection of 5 single dimensional arrays
with size 3.

STRINGS :
---------
A string is an array of characters. It ends with a null character.
( '\0' ==> Null character )
Ex :
char na1[6] = { 'a', 'b','c', 'd', 'e', '\0' } ;
char na2[6] = "abcde" ;
char names[][] = { "rama", "krishna", "abcd" } ;
char str1[20], str2[40] ;

11
 Note :
The format string for a string variable is %s .

Note :
scanf() function can accept the string values. But it does not allow spaces in
the string. To avoid this problem gets() can be used.
gets() :
---------
This function is used to accept the value for a string variable.
This function's prototype has defined in the header file STDIO.H.
Syntax :
gets(varaible) ;
Ex :
gets(str) ;

puts() :
--------
This function is used to display the string value of the variable.
This function's prototype has defined in the header file STDIO.H
Syntax :
puts(string) ;
Ex :
puts("The string is ");
puts(str) ;

STRING.H functions :
---------------------
To manipulate the strings the C authors designed some functions in the header
file STRING.H

1) strlen():
------------
This function returns an integer value that is the length of the string. length
means the number of characters.
Syntax:
int strlen(string) ;

2) strupr() :
---------------
This function changes the given string into uppercase characters.
Syntax :
strupr(string) ;

3) strlwr() :
--------------
This function changes the given string into lowercase characters.
Syntax :
strlwr(string) ;
12
 4) strcpy() :
--------------
This function copies the string to another string.
Syntax :
strcpy(target, source) ;

5) strcat() :
-------------
This function adds two strings.
Syntax :
strcat(destination, second) ;

6) strrev() :
---------------
This function change the given string into reverse order.
Syntax :
strrev(string) ;

7) strcmp() :
---------------
This function compares two strings and returns zero when both are
same.
Syntax :
int strcmp(first, second) ;

FUNCTIONS :
--------------
The function is a piece of code. These functions are used to reduce the
repetition of coding.

The functions are two types.

1) Derived functions,
2) User-defined functions.

The derived functions are provided by the C writers and they defined them in
header files. To use these functions the header file must be included at the top of
the program.

13
 We can create our own functions. To write any function there are three steps.
1) Functions declarations, 2) Functions calling, 3) Function definition.
or
1) Function definition, 2) Function calling.

In the function declaration and/or in the definition the name must be follow the
return data type, and it should be followed by parenthesis. In the parenthesis there
may be arguments with their data types. If the function does not return any
value it must be declared as void.

Syntax:

(datatype) (functionname) (argumentstype) ; /* Function declaration */

functionname(arguments) ; /* Function calling */

(datatype) (functionname) (argumentstype) /* Function definition */

{
(statements) ;
}

These functions are three types.

1) No arguments with no return value functions,

2) Arguments with no return value functions,
3) Arguments with return value functions.

PREPROCESSOR COMMANDS :
------------------------
The commands which start with hash (#) are called Preprocessor Commands.
Ex :
# define PI 3.14159
# include <stdio.h>
# include "conio.h"
# define A 1.7

define :
--------
This command is used to define our own constants.

include :
---------
This command is used to include the files which contains the definition of
functions.
There are two types to include the files.
1) # include < name >

14
 This type of command includes the file which is located in the specified
directory. These specifications are set by selecting the Directories command from
Options menu.

2) # include " name "

This type of command includes the file which is located in the current
directory and/or in the specified directory.

STORAGE CLAUSES :
-----------------

The declared variables are generally stored in memory devices. But by using the
storage clauses they can be stored either in memory devices or in CPU registers.
These storage clauses are 4 types. The variables initialization depends on this type.
1) auto, 2) register, 3) static, 4) extern

1) auto :
----------
This keyword is an option. It stores the variable in memory device. It assigns a
junk(garbage) value to the variable. The variable which declared in a block that is
available in that block only. The default type is auto.

2) register :
--------------
This keyword stores the variable in CPU registers. It assigns a junk(garbage)
value to the variable. In CPU registers it can't store more and big values like floats,
doubles,..etc. It can store only chars and integers. These variables are also local
that means the variables which declared in a block are available in that block only.
Generally these variables are used to generate the looping statements.

3) static :
------------
This keyword stores the variable in memory device. It initialises the variable as
0. The scope of variable is local that means the variables which declared in a block
are available in that block only. But it does not destroy the variable's value when
end that block. It takes the previous value when the controller entered into that
block again.

4) extern :
------------
This keyword stores the variable in memory device. It initialises the variable as
0. The scope of variable is global. This variable is declared before the main() . The
variable's value can be changed in the functions.

POINTERS :
15
 ----------
This topic is the most important in C.
The variables stored in the memory can be accessed with their addresses using
pointers.
To access with pointers we have to use two new operators.

& ==> Address of

* ==> Value at address of

Note: The variables are stored in memory between 64 kb and 128 kb.

Ex :

int a = 5;

a ==> 5
&a ==> 65500
*(&a) ==> 5

These address value can be stored in another variable. But that must be a pointer
variable of the same type to the variable.

sizeof :
--------
This keyword is used to find the size occupied by the variable in the memory.
Syntax :
int sizeof(type) ;
int sizeof(variable) ;

Note : Any Pointer variable occupies two bytes of memory. Because The pointer
variable contains the address of the variable. The address of any type of variable is
only a number.

Pointers in Functions :
------------------------
The functions can be send some arguments to the definition and may
take a return value. If the value of these variables changed in the
functions that does not effected to the function calling.

To change the value after calling the function the values can be send
by reference. That means the address of the variable can be send to change
the value.

Arrays with Pointers :

----------------------
An array is a collection of similar data type elements mentioning with a single
variable.
The address of first element is considered the address of the array.
The array elements can be accessed using the address of array and the index
value.
16
Note : By increasing the address it increases the size to address.

DYNAMIC MEMORY ALLOCATION :

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

malloc() :
----------
This function is used to allocate the memory while exeuting the program. This
functions returns a pointer that is the address of the location where it allocates the
required space. If this function fails to allocate the required space it returns NULL
value. This function's prototype was defined in the header file ALLOC.H and
STDLIB.H
Syntax:
(pointer) = (pointertype) malloc(size*number) ;

calloc() :
----------
This function works same as the function malloc(). But the main difference
between these two functions is the initial values. The malloc() function initilises the
allocated space with junk values. But the calloc() function initialises the allocated
space with zeros.
Syntax:
(pointer) = (pointertype) calloc(number, size) ;

realloc() :
----------
It re allocates the allocated memory with the required size and returns the
address. This may be differ to the previous address.
Syntax:
(pointer) realloc(block, size) ;

STRUCTURES :
-------------
A structure is a collection of variety of data type elements. This is created with
the keyword struct.

struct (name)
{
(elements declaration);
};

struct (name) (variable) ;

(variable).(element)

Ex :
1) struct employee
{
int eno;
17
 char ename[80];
float bas;
};
struct employee emp = { 5, "rama", 5600 } ;

2) struct employee
{
int eno;
char ename[80];
float bas;
} emp = { 5, "rama", 5600 } ;

3) struct
{
int eno;
char ename[80];
float bas;
} emp = { 5, "rama", 5600 } ;

Structures with Pointers :

--------------------------
The structure elements can be accessed using the address of the structure
variables. To access the elements with structure variable there must be a period
operator(.) between the variable and element. But to call the element with
structure pointer there must be -> operator between the structure pointer and the
element.

(structurevariable).(element)
(structurepointer)->(element)

FILE HANDLING IN C :
---------------------
Using C programs the data files and text files can be manipulated. To use
any file it must be loaded into memory. In C programs the file pointer where the file
stored can be found.

fopen():
--------
This function is used to open the required file in the required mode and returns
the file pointer where the file stored. If it is unable to open in the given mode it
returns a constant value NULL.
Syntax :
FILE * (filepointer) ;
(filepointer) = fopen("filename", "mode" );

modes :
----
"w" ==> To create the file and store the data
18
 "a" ==> To add the data to the file
"r" ==> To read the data from the file

Ex :
FILE *fp;
fp = fopen("data.txt", "w");

fclose() :
----------
The file, which opened in memory must be closed to avoid the data corruption.
To close the file the function fclose() must be used.
Syntax :
fclose(filepointer);
Ex :
fclose(fp) ;

fputc():
--------
This function is used to store the characters in the data file opened in the
filepointer.
Syntax :
fputc(char, filepointer) ;
Ex :
fputc(ch, fp) ;

fgetc() :
----------
This function is used to read a character to the variable from the file pointer.
Syntax :
char variable = fgetc(filepointer) ;
Ex :
ch = fgetc(fp) ;

fprintf() :
-----------
This function stores the data in the file.
Syntax :
fprintf(filepointer, "format string", variables);
Ex :
fprintf(fp, "%d %s %f", eno, ena, bas);

fscanf() :
----------
This function reads the data from the file.
Syntax :
fscanf(filepointer, "format string", variables);
19
 Ex :
fscanf(fp, "%d %s %f", &eno, ena, &bas);

fwrite() :
----------
This function is used to store the structures in the file in binary mode.
Syntax:
fwrite( (pointer to structure), (size of structure), (numberofstructures),
(filepointer) );
Ex:
fwrite( &emp, sizeof(emp), 1, fp);

fread() :
---------
This function is used to read the structures from the file in binary level.
Syntax:
fread( (pointer to structure), (size of structure), (numberofstructures),
(filepointer) );
Ex:
fread(&emp, sizeof(emp), 1, fp);

COMMAND LINE ARGUMENTS :

------------------------
The arguments can be passed to any function when they are calling.
The main() is also a function and some arguments can be passed to it from the
MS-DOS prompt.
Here we have to use the words argv, args[] .
Here argv is the an integer value and it is the number of arguments passed and
*args[] is an array of strings contain the arguments

Syntax:
main(int argv, char *args[])

GRAPHICS :
-----------
Generally the screen is in textmode. It can be changed by the display
adopters. There are a number of adopters like VGA, CGA, EGA, ...

The normal text mode has 25 rows and 80 columns. It can be changed using the
MODE command in MS-DOS. Using C programs we can design some graphics by
changing the screen from text mode to graphics mode.

initgraph() :
-------------
This function changes the screen from text mode to graphics mode. But here
we have to mention the display driver and mode. To use this command the file
20
EGAVGA.BGI must be in the current directory. This function's prototype has defined
in the header file GRAPHICS.H
Syntax:
initgraph( (address of driver), (address of mode), (path to file) );
Ex :
int gdr = DETECT, gmd;
initgraph(&gdr, &gmd, "C:\TC" );

detectgraph() :
---------------
This function detects the using graphic driver and modes. It assign the values
to the variables.
Syntax :
detectgraph( (address of graphic driver), (address of graphic mode) );
Ex :
int gdr, gmd;
detectgraph(&gdr, &gmd);

closegraph() :
---------------
This function closes the graphics mode and changes to text mode.
Syntax:
closegraph();

setcolor() :
------------
This function changes the displaying color of screen. In VGAHI we can use 16
colors. The color can be mentioned as integer.
Syntax:
setcolor(integer) ;
Ex :
setcolor(RED) ;
setcolor(4) ;

setbkcolor() :
--------------
This function changes the background color of screen .
Syntax :
setbkcolor(integer) ;
Ex:
setbkcolor(YELLOW) ;
setbkcolor(15);

putpixel() :
--------------
This function highlights the pixel(picture element) at the given co-ordinates to
the given color .
Syntax :
putpixel(x-coordinate, y-coordinate, color) ;
21
 Ex :
putpixel(320, 240, 5) ;

line() :
---------
This function displays a line between the given coordinates.
Syntax :
line(x1, y1, x2, y2 );
Ex :
line(200,300, 240, 370 );

lineto() :
-----------
This function displays a line to the given coordinates from the current
coordinates.
Syntax :
lineto(x2, y2) ;
Ex :
lineto(400, 600) ;

circle() :
-----------
This function displays a circle with the given center coordinates and the radius.
Syntax :
circle(x, y, radius) ;
Ex :
circle(320, 240, 100) ;

ellipse() :
-------------
Syntax :
ellipse(x, y, st-angle, end-angle,x-radius, y-radius );
Ex :
ellipse( 320, 240, 0, 360, 200, 100 );

arc() :
-------
Syntax :
arc(x, y, st-angle, end-angle, radius );
Ex :
arc(320, 240, 45, 135, 200 ) ;

rectangle() :
--------------
Syntax :
rectangle( x1, y1, x2, y2 );
Ex :
rectangle( 200, 150, 440, 320 );

random() :
22
 -----------
This function returns the value which is between 0 and 1 less than the given
number. This function's prototype has defined in the header file STDLIB.H
Syntax :
random(n);
This function returns any number from 0 to n-1 .

settextstyle() :
-----------------
This function sets the displaying text style .
Syntax :
settextstyle( font, direction, size );

fonts :
direction : HORIZ_DIR, VERT_DIR
size :

Ex : settextstyle( 3, 0, 5 );

outtextxy() :
--------------
This functions displays the given text at the given coordinates with the setted
style.
Syntax :
outtextxy(x, y, text) ;
Ex :
outtextxy( 200, 300, "abcdefgh ");

23