Programming in C
UNIT -1
Programming
To solve a computing problem, its
solution must be specified in terms of sequence of computational steps such
that they are effectively solved by a human agent or by a digital computer.
Programming Language
1)
The
specification of the sequence of computational steps in a particular
programming language is termed as a program
2)
The
task of developing programs is called programming
3)
The
person engaged in programming activity is called programmer
Techniques of Problem Solving
Problem solving an art in that it
requires enormous intuitive power & a science for it takes a pragmatic
approach.
Here a rough outline of a general
problem solving approach.
1)
Write
out the problem statement include information on what you are to solve &
consider why you need to solve the problem
2)
Make
sure you are solving the real problem as opposed to the perceived problem. To
check to see that you define & solve the real problem
3)
Draw
& label a sketch. Define & name all variables and /or symbols. Show numerical
values of variables, if known.
4)
Identify
& Name
a.
relevant
principles, theories & equations
b.
system
& subsystems
c.
dependent
& independent variables
d.
known
& unknowns
e.
inputs
& outputs
f.
necessary
information
5)
List
assumptions and approximations involved in solving the problem. Question the
assumptions and then state which ones are the most reasonable for your
purposes.
6)
Check
to see if the problem is either under-specified, figure out how to find the
missing information. If over-specified, identify the extra information that is
not needed.
7)
Relate
problem to similar problem or experience
8)
Use
an algorithm
9)
Evaluate
and examine and evaluate the answer to see it makes sense.
Introduction to C Programming
C is a
general-purpose computer programming language
developed in 1972 by Dennis Ritchie at the Bell Telephone
Laboratories for use with the Unix
operating system. C is a structured
programming language, which means that it allows you to develop programs using
well-defined control structures (you will learn about control
structures in the articles to come), and provides modularity
(breaking the task into multiple sub tasks that are simple enough to understand
and to reuse). C is often called a middle-level
language because it combines
the best elements of low-level or machine language with high-level
languages.
Where is
C useful?
C’s ability to communicate directly with hardware makes it a
powerful choice for system programmers. In fact, popular operating systems such
as Unix and Linux are written entirely in C. Additionally, even compilers and
interpreters for other languages such as FORTRAN, Pascal, and BASIC are written
in C. However, C’s scope is not just limited to developing system programs. It
is also used to develop any kind of application, including complex business
ones. The following is a partial list of areas where C language is
used:
Ø
Embedded Systems
Ø
Systems Programming
Ø
Artificial Intelligence
Ø
Industrial Automation
Ø
Computer Graphics
Ø
Space Research
Why
you should learn C?
You should
learn C because:
·
C
is simple.
·
There
are only 32 keywords so C is very easy to master. Keywords are words
that have special meaning in C language.
·
C
programs run faster than programs written in most other languages.
·
C
enables easy communication with computer hardware making it easy to write
system programs such as compilers and interpreters.
WHY WE NEED DATA AND
A PROGRAM
Any
computer program has two entities to consider, the data, and the program. They
are highly dependent on one another and careful planning of both will lead to a
well planned and well written program. Unfortunately, it is not possible to
study either completely without a good working knowledge of the other. For that
reason, this tutorial will jump back and forth between teaching methods of
program writing and methods of data definition. Simply follow along and you
will have a good understanding of both. Keep in mind that, even though it seems
expedient to sometimes jump right into coding the program, time spent planning
the data structures will be well spent and the quality of the final program will
reflect the original planning
How to run a simple c program
1. Copy Turbo c/c++ in computer
2. Open c:\tc\bin\tc.exe
3. A window appears
4. Select File->new to open a new file
5. Type the following program on editor
#include
<stdio.h>
void
main()
{
printf(“hello”);
}
6.
compile the program by pressing ALT+F9
7.
Run the program by pressing CTRL +F9
Note:
1.
C is case sensitive
2.
Always terminate statements with semicolon.
3.
A program starts with main()
Explanation of
program
#include
is known as compiler directive. A compiler directive is a command to compiler
to translate the program in a certain way. These statements are not converted
into machine language but only perform some other task.
main()
is a function which the starting point for complier to start compilation. So a
function must contain a main() function.
DETECTION AND CORRECTION OF ERRORS
Syntactic errors and execution errors
usually result in the generation of error messages when compiling or executing
a program. Error of this type is usually quite easy to find and correct. There
are some logical errors that can be very difficult to detect. Since the output
resulting from a logically incorrect program may appear to be error free.
Logical errors are often hard to find, so in order to find and correct errors
of this type is known as logical debugging. To detect errors test a new program
with data that will give a known answer. If the correct results are not
obtained then the program obviously contains errors even if the correct results
are obtained.
Computer Applications: However you
cannot be sure that the program is error free, since some errors cause
incorrect result only under certain circumstances. Therefore a new program
should receive thorough testing before it is considered to be debugged. Once it
has been established that a program contains a logical error, some ingenuity
may be required to find the error. Error detection should always begin with a
thorough review of each logical group of statements within the program. If the
error cannot be found, it sometimes helps to set the program aside for a while.
If an error cannot be located simply by inspection, the program should be
modified to print out certain intermediate results and then be rerun. This
technique is referred to as tracing. The source of error will often become
evident once these intermediate calculations have been carefully examined. The
greater the amount of intermediate output, the more likely the chances of
pointing the source of errors. Sometimes an error simply cannot be located.
Some C compilers include a debugger, which is a special program that
facilitates the detection of errors in C programs. In particular a debugger
allows the execution of a source program to be suspended at designated places,
called break points, revealing the values assigned to the program variables and
array elements at the time execution stops. Some debuggers also allow a program
to execute continuously until some specified error condition has occurred. By
examining the values assigned to the variables at the break points, it is
easier to determine when and where an error originates.
Linear Programming
Linear
program is a method for straightforward programming in a sequential manner.
This type of programming does not involve any decision making. General model of
these linear programs is:
1.
Read
a data value
2.
Computer
an intermediate result
3.
Use the intermediate result to computer the
desired answer
4.
Print
the answer
5.
Stop
Structured
Programming
Structured programming (sometimes
known as modular programming) is a subset of procedural programming that
enforces a logical structure on the program being written to make it more
efficient and easier to understand and modify. Certain languages such as Ada,
Pascal,
and dBASE are designed with features that encourage or enforce a logical
program structure.
Structured
programming frequently employs a top-down design model, in which developers map
out the overall program structure into separate subsections. A defined function
or set of similar functions is coded in a separate module or sub module, which
means that code can be loaded into memory
more efficiently and that modules can be reused in other programs. After a
module has been tested individually, it is then integrated with other modules
into the overall program structure.
Advantages of Structured Programming
1.
Easy
to write:
Modular design increases the programmer's productivity by allowing them to look
at the big picture first and focus on details later. Several Programmers can work
on a single, large program, each working on a different module. Studies show
structured programs take less time to write than standard programs. Procedures
written for one program can be reused in other programs requiring the same
task. A procedure that can be used in many programs is said to be reusable.
2. Easy to debug:
Since each procedure is specialized to perform just one task, a procedure can
be checked individually. Older unstructured programs consist of a sequence of
instructions that are not grouped for specific tasks. The logic of such
programs is cluttered with details and therefore difficult to follow.
3. Easy to Understand:
The relationship between the procedures shows the modular design of the
program. Meaningful procedure names and clear documentation identify the task
performed by each module. Meaningful variable names help the programmer
identify the purpose of each variable.
4. Easy to Change:
Since a correctly written structured program is self-documenting, it can be
easily understood by another programmer.
Structured Programming Constructs
It uses only three constructs -
- Sequence (statements, blocks)
- Selection (if, switch)
- Iteration (loops like while and
for)
Sequence
- Any valid expression terminated
by a semicolon is a statement.
- Statements may be grouped
together by surrounding them with a pair of curly braces.
- Such a group is syntactically
equivalent to one statement and can be inserted where ever
- One statement is legal.
Selection
The
selection constructs allow us to follow different paths in different
situations. We may also think of them as enabling us to express decisions.
The
main selection construct is:
if (expression)
statement1
else
statement2
statement1 is executed if and only if expression
evaluates to some non-zero number. If expression evaluates to 0, statement1
is not executed. In that case, statement2 is executed.
If and else
are independent constructs, in that if can occur without else (but not the
reverse).Any else is paired with the most recent else-less if, unless curly
braces enforce a different scheme. Note that only curly braces, not
parentheses, must be used to enforce the pairing. Parentheses
Iteration
Looping is
a way by which we can execute any some set of statements more than one times
continuously .In C there are mainly two types of loops are used :
- Entry controlled loops
- Exit controlled loops
Entry
controlled loops:
·
while
Loop
·
For
Loop
Exit
controlled loop:
·
do
while Loop
The control
structures are easy to use because of the following reasons:
1) They are easy to recognize
2) They are simple to deal with as they
have just one entry and one exit point
3) They are free of the complications of
any particular programming language
Modular Design of Programs
One
of the key concepts in the application of programming is the design of a
program as a set of units referred to as blocks or modules. A style
that breaks large computer programs into smaller elements called modules.
Each module performs a single task; often a task that needs to be performed
multiple times during the running of a program. Each module also stands alone
with defined input and output. Since modules are able to be reused they can be
designed to be used for multiple programs. By debugging each module and only
including it when it performs its defined task, larger programs are easier to
debug because large sections of the code have already been evaluated for
errors. That usually means errors will be in the logic that calls the various
modules.
Languages like Modula-2 were designed for use with modular programming.
Modular programming has generally evolved into object-oriented programming.
Programs can be logically separated
into the following functional modules:
1)
Initialization
2)
Input
3)
Input
Data Validation
4)
Processing
5)
Output
6)
Error
Handling
7)
Closing
procedure
Basic attributes of modular
programming:
1)
Input
2)
Output
3)
Function
4)
Mechanism
5)
Internal
data
Control Relationship between modules:
The
structure charts show the interrelationships of modules by arranging them at
different levels and connecting modules in those levels by arrows. An arrow
between two modules means the program control is passed from one module to the
other at execution time. The first module is said to call or invoke the lower
level modules. There are three rules for controlling the relationship between
modules.
1)
There
is only one module at the top of the structure. This is called the root or boss
module.
2) The root passes control down the
structure chart to the lower level modules. However, control is always returned
to the invoking module and a finished module should always terminate at the
root.
3) There can be more than one control
relationship between two modules on the structure chart, thus, if module A
invokes module B, then B cannot invoke module A.
Communication between modules:
1)
Data: Shown by an arrow with empty circle at its tail.
2)
Control : Shown by a filled-in circle at the
end of the tail of arrow
Module
Design Requirements
A
hierarchical or module structure should prevent many advantages in management,
developing, testing and maintenance. However, such advantages will occur only
if modules fulfill the following requirements.
a)
Coupling: In computer science,
coupling is considered to be the degree to which each program module relies on
other modules, and is also the term used to describe connecting two or more
systems. Coupling is broken down into loose coupling, tight coupling, and
decoupled. Coupling is also used to describe software as well as systems. Also
called dependency
Types
of Programming Language
Low Level Language
First-generation language is the lowest level computer language. Information is conveyed to the computer by the programmer
as binary instructions. Binary instructions
are the equivalent of the on/off signals used by computers to carry out
operations. The language consists of zeros and ones. In the 1940s and 1950s,
computers were programmed by scientists sitting before control panels equipped
with toggle switches so that they could input instructions as strings of zeros
and ones.
Advantages:
Ø
Fast
and efficient
Ø
Machine
oriented
Ø
No
translation required
Disadvantages
Ø
Not
portable
Ø
Not
programmer friendly
Assembly Language
Assembly or assembler language was
the second generation of computer language. By the late
1950s, this language had become popular. Assembly language consists of letters
of the alphabet. This makes programming much easier than trying to program a
series of zeros and ones. As an added programming assist, assembly language
makes use of mnemonics, or memory aids, which are easier for the human programmer to recall than are
numerical codes.
Assembler
An assembler is a program that takes basic computer instructions and converts them into a
pattern of bits that the computer's processor can use to perform its basic
operations. Some people call these instructions assembler language and others
use the term assembly language In other words An assembler is a computer program for translating assembly language
— essentially, a mnemonic representation of machine language — into object code. A cross assembler (see cross compiler) produces code for one processor,
but runs on another.
As
well as translating assembly instruction mnemonics into opcodes, assemblers provide the ability
to use symbolic names for memory locations (saving tedious calculations and
manually updating addresses when a program is slightly modified), and macro facilities for performing textual
substitution — typically used to encode common short sequences of instructions
to run inline instead of in a subroutine.
High Level Language
The introduction of the compiler in 1952 spurred the
development of third-generation computer languages. These languages
enable a programmer to create program files
using commands that are similar to spoken English. Third-level computer
languages have become the major means of communication between the digital
computer and its user. By 1957, the International Business Machine Corporation
(IBM) had created a language called FORTRAN (FORmula TRANslater). This language
was designed for scientific work involving complicated mathematical formulas.
It became the first high-level programming language (or "source
code") to be used by many computer users.
Within the next few years,
refinements gave rise to ALGOL (ALGOrithmic Language) and COBOL (COmmon
Business Oriented Language). COBOL is noteworthy because it improved the record
keeping and data management ability of
businesses, which stimulated business expansion.
Advantages:
Ø Portable or machine independent
Ø
Programmer-friendly
Disadvantages:
Ø
Not
as efficient as low-level languages
Ø
Need
to be translated
Examples
: C, C++, Java, FORTRAN, Visual Basic, and
Interpreter
An interpreter is a computer program that executes other programs. This is in
contrast to a compiler which does not execute its input
program (the source code) but translates it into executable machine code (also called object code) which is output to a file
for later execution. It may be possible to execute the same source code either
directly by an interpreter or by compiling it and then executing the machine
code produced.
It
takes longer to run a program under an interpreter than to run the compiled
code but it can take less time to interpret it than the total required to
compile and run it. This is especially important when prototyping and testing
code when an edit-interpret-debug cycle can often be much shorter than an
edit-compile-run-debug cycle.
Interpreting
code is slower than running the compiled code because the interpreter must analyses
each statement in the program each time it is executed and then perform the
desired action whereas the compiled code just performs the action. This
run-time analysis is known as "interpretive overhead". Access to
variables is also slower in an interpreter because the mapping of identifiers
to storage locations must be done repeatedly at run-time rather than at compile
time.
COMPILER
A program
that translates source code into object code. The compiler derives its
name from the way it works, looking at the entire piece of source code and
collecting and reorganizing the instructions. Thus, a compiler differs from an interpreter, which analyzes and executes each line of source code in
succession, without looking at the entire program. The advantage of
interpreters is that they can execute a program immediately. Compilers require
some time before an executable program emerges. However, programs produced by
compilers run
much faster than the same programs executed by an interpreter.
Every
high-level programming language (except
strictly interpretive languages) comes with a compiler. In effect, the compiler
is the language,
because it defines which instructions are acceptable.
Fourth Generation Language
Fourth-generation languages attempt
to make communicating with computers as much like the
processes of thinking and talking to other people as possible. The problem is
that the computer still only understands zeros and ones, so a compiler and
interpreter must still convert the source code into the machine code that the
computer can understand. Fourth-generation languages typically consist of
English-like words and phrases. When they are implemented on microcomputers,
some of these languages include graphic devices such as icons and onscreen push
buttons for use during programming and when running the resulting application.
Many fourth-generation languages use Structured Query
Language (SQL) as the basis for operations. SQL was developed at IBM to develop
information stored in relational databases. Examples of fourth-generation
languages include PROLOG, an Artificial Intelligence language
UNIT-2
Basic Structure of a C Program:
|
Documentation Section |
|
Linking Section |
|
Definition Section |
|
Global Declaration
Section |
|
main() { Declaration part; Executable part; } |
|
Subprogram |
·
Documentation section: The documentation section consists of a set of comment
lines giving the name of the program, the author and other details, which the
programmer would like to use later.
·
Link section: The link section provides instructions to the compiler to link
functions from the system library.
·
Definition section: The definition section defines all symbolic
constants.
·
Global declaration section: There are some variables
that are used in more than one function. Such variables are called global
variables and are declared in the global declaration section that is outside of
all the functions. This section also declares all the user-defined functions.
·
main () function section: Every C program must have one main
function section. This section contains two parts; declaration part and
executable part.
Declaration part: The declaration
part declares all the variables used in the executable part.
Executable part: There is at least
one statement in the executable part. These two parts must appear between the
opening and closing braces.
The
program execution begins at the opening brace and ends at the closing brace.
The closing brace of the main function is the logical end of the program. All
statements in the declaration and executable part end with a semicolon.
·
Subprogram section: The subprogram section contains all the user-defined
functions that are called in the main () function. User-defined functions are generally
placed immediately after the main () function, although they may appear in any
order.
Note: All section, except the
main () function section may be absent when they are not required.
Sample C Program:
#include<stdio.h> <———————Preprocessing Directive
void main()
{ <——————–Start of a Program
/*………….Printing Starts………….*/
printf(“Welcome to C Programming Language”);
} <———————-End of a Program
·
In C many library functions are grouped category-wise and stored
in different files known as header files. Ex. stdio.h–>standard input output
header file
·
To use the functions defined in the header file that need to be
included in the program
·
This can be achieved by the preprocessing directive “#include”
·
“#include” includes the content of header file at the beginning
of program.
C-Language keywords
|
auto |
break |
case |
char |
const |
|
continue |
default |
do |
double |
else |
|
enum |
extern |
float |
for |
goto |
|
if |
int |
long |
register |
return |
|
short |
signed |
sizeof |
static |
struct |
|
switch |
typedef |
union |
unsigned |
void |
|
volatile |
while |
|
||
Data Types
A C language programmer has to tell the system
before-hand, the type of numbers or characters he is using in his program.
These are data types. There are many data types in C language. A C programmer
has to use appropriate data type as per his requirement.
C language
data types can be broadly classified as:
·
Primary
data type
·
Derived
data type
·
User
defined data type
Primary data type
All
C Compilers accept the following fundamental data types
|
1. |
Integer |
int |
|
2. |
Character |
char |
|
3. |
Floating
Point |
float |
|
4. |
Double
precision floating point |
double |
|
5. |
Void |
void |
The
size and range of each data type is given in the table below
|
DATA TYPE |
RANGE OF VALUES |
|
char |
-128
to 127 |
|
int |
-32768
to +32767 |
|
float |
3.4
e-38 to 3.4 e+38 |
|
double |
1.7
e-308 to 1.7 e+308 |
Integer Type:
Integers
are whole numbers with a machine dependent range of values. A good programming
language as to support the programmer by giving a control on a range of numbers
and storage space. C has 3 classes of integer storage namely short int, int and
long int. All of these data types have signed and unsigned forms. A short int
requires half the space than normal integer values. Unsigned numbers are always
positive and consume all the bits for the magnitude of the number. The long and
unsigned integers are used to declare a longer range of values.
Floating Point Types:
Floating
point number represents a real number with 6 digits precision. Floating point
numbers are denoted by the keyword float. When the accuracy of the floating
point number is insufficient, we can use the double to define the number. The
double is same as float but with longer precision. To extend the precision
further we can use long double which consumes 80 bits of memory space.
Void Type:
Using
void data type, we can specify the type of a function. It is a good practice to
avoid functions that does not return any values to the calling function.
Character Type:
A
single character can be defined as a defined as a character type of data.
Characters are usually stored in 8 bits of internal storage. The qualifier
signed or unsigned can be explicitly applied to char. While unsigned characters
have values between 0 and 255, signed characters have values from –128 to 127.
Size and Range of Data Types on 16 bit
machine.
|
type |
SIZE (Bits) |
Range |
|
Char or Signed Char |
8 |
-128 to 127 |
|
Unsigned Char |
8 |
0 to 255 |
|
Int or Signed int |
16 |
-32768 to 32767 |
|
Unsigned int |
16 |
0 to 65535 |
|
Short int or Signed short int |
8 |
-128 to 127 |
|
Unsigned short int |
8 |
0 to 255 |
|
Long int or signed long int |
32 |
-2147483648 to 2147483647 |
|
Unsigned long int |
32 |
0 to 4294967295 |
|
Float |
32 |
3.4 e-38 to 3.4 e+38 |
|
Double |
64 |
1.7e-308 to 1.7e+308 |
|
Long Double |
80 |
3.4 e-4932 to 3.4 e+4932 |
Variable:
Variable is a name of memory location
where we can store any data. It can store only single data (Latest data) at a
time. In C, a variable must be declared before it can be used. Variables can be
declared at the start of any block of code, but most are found at the start of
each function.
A
declaration begins with the type, followed by the name of one or more
variables. For example,
Syntax:- DataType Name_of_Variable_Name;
Example:- int a,b,c;
Variable Names
Every
variable has a name and a value. The name identifies the variable, the value
stores data. There is a limitation on what these names can be. Every variable
name in C must start with a letter; the rest of the name can consist of
letters, numbers and underscore characters. C recognizes upper and lower case
characters as being different. Finally, you cannot use any of C's keywords like
main, while, switch etc as variable names.
Examples
of legal variable names include:
x result outfile bestyetx1 x2 out_file best_yetpower impetus gamma hi_score It is conventional to avoid the use of
capital letters in variable names. These are used for names of constants. Some
old implementations of C only use the first 8 characters of a variable name.
Local Variables
Local
variables are declared within the body of a function, and can only be used
within that function only.
Syntax:
Void
main( ){
int
a,b,c;
}
Void
fun1()
{
int
x,y,z;
}
Here
a,b,c are the local variable of void main() function and it can’t be used
within fun1() Function. And x, y and z are local variable of fun1().
Global Variable
A
global variable declaration looks normal, but is located outside any of the
program's functions. This is usually done at the beginning of the program file,
but after preprocessor directives. The variable is not declared again in the
body of the functions which access it.
Syntax:
#include<stdio.h>
int
a,b,c;
void
main()
{
}
Void
fun1()
{
}
Here
a,b,c are global variable .and these variable cab be accessed (used) within a
whole program.
Constants
C constant is usually just the written version
of a number. For example 1, 0, 5.73, 12.5e9. We can specify our constants in
octal or hexadecimal, or force them to be treated as long integers.
- Octal constants are written with
a leading zero - 015.
- Hexadecimal constants are written
with a leading 0x - 0x1ae.
- Long constants are written with a
trailing L - 890L.
Character constants are usually just
the character enclosed in single quotes; 'a', 'b', 'c'. Some characters can't
be represented in this way, so we use a 2 character sequence.
In
addition, a required bit pattern can be specified using its octal equivalent.
'\044'
produces bit pattern 00100100.
Character
constants are rarely used, since string constants are more convenient. A string
constant is surrounded by double quotes e.g. "Brian and Dennis". The
string is actually stored as an array of characters. The null character '\0' is
automatically placed at the end of such a string to act as a string terminator.
Constant
is a special types of variable which can not be changed at the time of
execution. Syntax:
const
int a=20;
C Language Operator Precedence Chart
Operator precedence describes the order in which C reads
expressions. For example, the expression a=4+b*2 contains two operations, an addition and a
multiplication. Does the C compiler evaluate 4+b first, then multiply the result by 2, or does it evaluate b*2 first, then add 4 to the result? The operator precedence chart contains
the answers. Operators higher in the chart have a higher precedence, meaning
that the C compiler evaluates them first. Operators on the same line in the
chart have the same precedence, and the "Associatively" column on the
right gives their evaluation order.
|
Operator
Precedence Chart |
||
|
Operator
Type |
Operator |
Associatively |
|
Primary
Expression Operators |
|
left-to-right |
|
Unary
Operators |
|
right-to-left |
|
Binary
Operators |
|
left-to-right |
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
Ternary
Operator |
|
right-to-left |
|
Assignment
Operators |
|
right-to-left |
|
Comma |
|
left-to-right |
Operators
Introduction
An
operator is a symbol which helps the user to command the computer to do a
certain mathematical or logical manipulations. Operators are used in C language
program to operate on data and variables. C has a rich set of operators which
can be classified as
1. Arithmetic operators
2. Relational Operators
3. Logical Operators
4. Assignment Operators
5. Increments and Decrement Operators
6. Conditional Operators
7. Bitwise Operators
8. Special Operators
1.
Arithmetic Operators
All
the basic arithmetic operations can be carried out in C. All the operators have
almost the same meaning as in other languages. Both unary and binary operations
are available in C language. Unary operations operate on a singe operand,
therefore the number 5 when operated by unary – will have the value –5.
Arithmetic
Operators
|
Operator |
Meaning |
|
+ |
Addition or Unary Plus |
|
– |
Subtraction or Unary Minus |
|
* |
Multiplication |
|
/ |
Division |
|
% |
Modulus Operator |
Examples of arithmetic
operators are
x + y
x - y
-x + y
a * b + c
-a * b
etc.,
here a, b, c, x, y are
known as operands. The modulus operator is a special operator in C language
which evaluates the remainder of the operands after division.
Example
|
. |
Integer
Arithmetic
When
an arithmetic operation is performed on two whole numbers or integers than such
an operation is called as integer arithmetic. It always gives an integer as the
result. Let x = 27 and y = 5 be 2 integer
numbers. Then the integer operation leads to the following results.
x + y = 32
x – y = 22
x * y = 115
x % y = 2
x / y = 5
In integer division the fractional part is truncated.
Floating
point arithmetic
When
an arithmetic operation is preformed on two real numbers or fraction numbers
such an operation is called floating point arithmetic. The floating point
results can be truncated according to the properties requirement. The remainder
operator is not applicable for floating point arithmetic operands.
Let x = 14.0 and y = 4.0 then
x + y = 18.0
x – y = 10.0
x * y = 56.0
x / y = 3.50
Mixed
mode arithmetic
When
one of the operand is real and other is an integer and if the arithmetic
operation is carried out on these 2 operands then it is called as mixed mode
arithmetic. If any one operand is of real type then the result will always be
real thus 15/10.0 = 1.5
2.
Relational Operators
Often
it is required to compare the relationship between operands and bring out a
decision and program accordingly. This is when the relational operator come
into picture. C supports the following relational operators.
|
Operator |
Meaning |
|
< |
is less than |
|
<= |
is less than or equal to |
|
> |
is greater than |
|
>= |
is greater than or equal to |
|
== |
is equal to |
It
is required to compare the marks of 2 students, salary of 2 persons, we can
compare them using relational operators.
A simple relational expression contains only one relational operator and takes
the following form.
exp1 relational operator exp2
Where exp1 and exp2
are expressions, which may be simple constants, variables or combination of
them. Given below is a list of examples of relational expressions and evaluated
values.
6.5 <= 25 TRUE
-65 > 0 FALSE
10 < 7 + 5 TRUE
Relational expressions are used in decision making statements of C language
such as if, while and for
statements to decide the course of action of a running program.
3.
Logical Operators
C
has the following logical operators, they compare or evaluate logical and
relational expressions.
|
Operator |
Meaning |
|
&& |
Logical AND |
|
|| |
Logical OR |
|
! |
Logical NOT |
Logical
AND (&&)
This
operator is used to evaluate 2 conditions or expressions with relational
operators simultaneously. If both the expressions to the left and to the right
of the logical operator is true then the whole compound expression is true.
Example
a > b
&& x = = 10
The expression to the left is a > b and
that on the right is x == 10 the whole
expression is true only if both expressions are true i.e., if a is greater than
b and x is equal to 10.
Logical
OR (||)
The
logical OR is used to combine 2 expressions or the condition evaluates to true
if any one of the 2 expressions is true.
Example
a < m || a
< n
The expression evaluates to true if any one of them is true or if both of them
are true. It evaluates to true if a is less than either m or n and when a is
less than both m and n.
Logical
NOT (!)
The
logical not operator takes single expression and evaluates to true if the
expression is false and evaluates to false if the expression is true. In other
words it just reverses the value of the expression.
For example
! (x >= y) the NOT expression evaluates to true only if the value
of x is neither greater than or equal to y
4.
Assignment Operators
The
Assignment Operator evaluates an expression on the right of the expression and
substitutes it to the value or variable on the left of the expression.
Example
x = a + b
Here the value of a + b is evaluated and substituted to the variable x.
In addition, C has a set of shorthand assignment operators of the form.
var oper = exp;
Here var is a variable, exp is an expression and oper
is a C binary arithmetic operator. The operator oper
= is known as shorthand assignment operator
Example
x + = 1 is
same as x = x + 1
The commonly used
shorthand assignment operators are as follows
Shorthand assignment operators .
|
Statement
with simple assignment operator |
Statement
with shorthand operator |
|
a = a + 1 |
a += 1 |
|
a = a – 1 |
a -= 1 |
|
a = a * (n+1) |
a *= (n+1) |
|
a = a / (n+1) |
a /= (n+1) |
|
a = a % b |
a %= b |
Example for
using shorthand assignment operator
|
. |
Output
2
4
16
5.
Increment and Decrement Operators
The
increment and decrement operators are one of the unary operators which are very
useful in C language. They are extensively used in for and while loops. The
syntax of the operators is given below
1. ++ variable name
2. variable name++
3. – –variable name
4. variable name– –
The increment operator ++
adds the value 1 to the current value of operand and the decrement operator – –
subtracts the value 1 from the current value of operand. ++variable name and variable name++ mean the same thing when they form
statements independently, they behave differently when they are used in
expression on the right hand side of an assignment statement.
Consider the following .
m = 5;
y = ++m; (prefix)
In this case the value of
y and m
would be 6
Suppose if we rewrite the above statement as
m = 5;
y = m++; (post fix)
Then the value of y will be 5 and that of m
will be 6. A prefix operator first adds 1 to the operand and then the result is
assigned to the variable on the left. On the other hand, a postfix operator
first assigns the value to the variable on the left and then increments the
operand.
6.
Conditional or Ternary Operator
The conditional operator
consists of 2 symbols the question mark (?) and
the colon (:)
The syntax for a ternary
operator is as follows .
exp1 ? exp2 : exp3
The ternary operator
works as follows
exp1
is evaluated first. If the expression is true then exp2 is evaluated & its value becomes the value of
the expression. If exp1 is false, exp3 is evaluated and its value becomes the value of
the expression. Note that only one of the expression is evaluated.
For example
a = 10;
b = 15;
x = (a > b) ? a : b
Here x will be assigned to the value of b. The
condition follows that the expression is false therefore b is assigned to x.
|
. |
Output
Input 2 integers
: 34 45
The largest of two numbers is 45
7.
Bitwise Operators
C
has a distinction of supporting special operators known as bitwise operators
for manipulation data at bit level. A bitwise operator operates on each bit of
data. Those operators are used for testing, complementing or shifting bits to
the right on left. Bitwise operators may not be applied to a float or double.
|
Operator |
Meaning |
|
& |
Bitwise AND |
|
| |
Bitwise OR |
|
^ |
Bitwise Exclusive |
|
<< |
Shift left |
|
>> |
Shift right |
8.
Special Operators
C
supports some special operators of interest such as comma operator, size of
operator, pointer operators (& and *) and member selection operators (. and ->).
The size of and the comma operators are discussed here. The remaining operators
are discussed in forth coming chapters.
The
Comma Operator
The
comma operator can be used to link related expressions together. A comma-linked
list of expressions are evaluated left to right and value of right most
expression is the value of the combined expression.
For
example the statement
value = (x = 10, y = 5, x + y);
First
assigns 10 to x and 5 to y and finally assigns 15 to value. Since comma has
the lowest precedence in operators the parenthesis is necessary. Some examples
of comma operator are
In
for loops:
for (n=1, m=10, n <=m; n++,m++)
In while loops
While (c=getchar(), c != ‘10’)
Exchanging
values.
t = x, x = y, y = t;
The
size of Operator
The
operator size of gives the size of the data type or variable in terms of bytes
occupied in the memory. The operand may be a variable, a constant or a data
type qualifier.
Example
m = sizeof (sum);
n = sizeof (long int);
k = sizeof (235L);
The size of operator is normally used
to determine the lengths of arrays and structures when their sizes are not
known to the programmer. It is also used to allocate memory space dynamically
to variables during the execution of the program.
Example program that employs different
kinds of operators. The results of their evaluation are also shown in
comparision .
|
.main() //start of program |
Notice
the way the increment operator ++ works when used in an expression. In the
statement c = ++a – b; new value a = 16 is
used thus giving value 6 to C. That is a is incremented by 1 before using in
expression.
However in
the statement d = b++ + a; The old value b = 10 is used in the expression. Here
b is incremented after it is used in the expression.
We can print the character % by placing
it immediately after another % character in the control string. This is
illustrated by the statement.
printf(“a %% b = %d\n”, a%b);
This program
also illustrates that the expression
c > d ? 1
: 0
Assumes the
value 0 when c is less than d and 1 when c is greater than d.
Type conversions in expressions
Implicit
type conversion
C
permits mixing of constants and variables of different types in an expression.
C automatically converts any intermediate values to the proper type so that the
expression can be evaluated without loosing any significance. This automatic
type conversion is know as implicit type conversion .
During evaluation it adheres
to very strict rules and type conversion. If the operands are of different
types the lower type is automatically converted to the higher type before the
operation proceeds. The result is of higher type.
The following rules apply during evaluating expressions
All short and char are
automatically converted to int then
1. If one operand is long
double, the other will be converted to long double and result will be long
double.
.
2. If one operand is double, the other will be converted to double and result
will be double.
.
3. If one operand is float, the other will be converted to float and result
will be float.
.
4. If one of the operand is unsigned long int, the other will be converted into
unsigned long int and result will be unsigned long int.
.
5. If one operand is long int and other is unsigned int then .
.....a. If unsigned int can be converted to
long int, then unsigned int operand will be
..........converted as such and the result
will be long int.
.....b. Else Both operands will be converted
to unsigned long int and the result will be unsigned long int.
.6. If one of the operand is long int,
the other will be converted to long int and the result will be long int. .
7. If one operand is unsigned
int the other will be converted to unsigned int and the
.....result will be unsigned int.
Explicit
Conversion
Many
times there may arise a situation where we want to force a type conversion in a
way that is different from automatic conversion.
Consider for example the
calculation of number of female and male students in a class
female_students
Ratio = -------------------
male_students
Since if female_students and
male_students are declared as integers, the decimal part will be rounded off
and its ratio will represent a wrong figure. This problem can be solved by
converting locally one of the variables to the floating point as shown below.
Ratio = (float) female_students / male_students
The operator float converts the
female_students to floating point for the purpose of evaluation of the
expression. Then using the rule of automatic conversion, the division is
performed by floating point mode, thus retaining the fractional part of the
result. The process of such a local conversion is known as explicit conversion
or casting a value. The general form is
(type_name) expression
Specifier Meaning
%c – Print a character
%d – Print a Integer
%i – Print a Integer
%e – Print float value in exponential form.
%f – Print float value
%g – Print using %e or %f whichever is smaller
%o – Print actual value
%s – Print a string
%x – Print a hexadecimal integer (Unsigned) using lower case a – F
%X – Print a hexadecimal integer (Unsigned) using upper case A – F
%a – Print a unsigned integer.
%p – Print a pointer value
%hx – hex short
%lo – octal long
%ld – long unsigned integer.
Input and Output
Input
and output are covered in some detail. C allows quite precise control of these.
This section discusses input and output from keyboard and screen.
The
same mechanisms can be used to read or write data from and to files. It is also
possible to treat character strings in a similar way, constructing or analysing
them and storing results in variables. These variants of the basic input and
output commands are discussed in the next section
printf
This
offers more structured output than putchar. Its arguments are, in order; a
control string, which controls what gets printed, followed by a list of values
to be substituted for entries in the control string
Example:
int a,b;
printf(“
a = %d,b=%d”,a,b);.
It
is also possible to insert numbers into the control string to control field
widths for values to be displayed. For example %6d would print a decimal value
in a field 6 spaces wide, %8.2f would print a real value in a field 8 spaces
wide with room to show 2 decimal places. Display is left justified by default,
but can be right justified by putting a - before the format information, for
example %-6d, a decimal integer right justified in a 6 space field
scanf
scanf
allows formatted reading of data from the keyboard. Like printf it has a
control string, followed by the list of items to be read. However scanf wants to
know the address of the items to be read, since it is a function which will
change that value. Therefore the names of variables are preceded by the &
sign. Character strings are an exception to this. Since a string is already a
character pointer, we give the names of string variables unmodified by a
leading &.
Control
string entries which match values to be read are preceeded by the percentage
sign in a similar way to their printf equivalents.
Example:
int a,b;
scan
f(“%d%d”,& a,& b);
getchar
getchar
returns the next character of keyboard input as an int. If there is an error
then EOF (end of file) is returned instead. It is therefore usual to compare
this value against EOF before using it. If the return value is stored in a
char, it will never be equal to EOF, so error conditions will not be handled
correctly.
As
an example, here is a program to count the number of characters read until an
EOF is encountered. EOF can be generated by typing Control - d.
#include <stdio.h> main() { int ch, i = 0; while((ch = getchar()) != EOF) i ++; printf("%d\n", i);}
putchar
putchar
puts its character argument on the standard output (usually the screen).
The
following example program converts any typed input into capital letters. To do
this it applies the function to upper from the character conversion library c type
.h to each character in turn.
#include <ctype.h> /* For definition of toupper */ #include <stdio.h> /* For definition of getchar, putchar, EOF */ main() { char ch; while((ch = getchar()) != EOF) putchar (toupper(ch));}
gets
gets
reads a whole line of input into a string until a new line or EOF is
encountered. It is critical to ensure that the string is large enough to hold
any expected input lines.
When
all input is finished, NULL as defined in studio is returned.
#include <stdio.h> main() { char ch[20]; gets(x); puts(x);}
puts
puts
writes a string to the output, and follows it with a new line character.
Example:
Program which uses gets and puts to double space typed input.
#include <stdio.h> main(){ char line[256]; /* Define string sufficiently large to store a line of input */ while(gets(line) != NULL) /* Read line */ { puts(line); /* Print line */ printf("\n"); /* Print blank line */ }}
Note
that putchar, printf and puts can be freely used together
Expression Statements
Most
of the statements in a C program are expression
statements. An expression statement is simply an expression
followed by a semicolon. The lines
i = 0; i = i + 1;and printf("Hello, world!\n");
are
all expression statements. (In some languages, such as Pascal, the semicolon
separates statements, such that the last statement is not followed by a
semicolon. In C, however, the semicolon is a statement terminator; all simple
statements are followed by semicolons. The semicolon is also used for a few
other things in C; we've already seen that it terminates declarations, too.
UNIT
– 3
CONTROL
FLOW STATEMENT
if- Statement:
It is the basic form where the if
statement evaluate a test condition and direct program execution depending on
the result of that evaluation.
Syntax:
if (Expression)
{
Statement 1;
Statement 2;
}
Where
a statement may consist of a single statement, a compound statement or nothing
as an empty statement. The Expression also referred so as test condition must
be enclosed in parenthesis, which cause the expression to be evaluated first,
if it evaluate to true (a non zero value), then the statement associated with
it will be executed otherwise ignored and the control will pass to the next
statement.
Example:
if (a>b)
{
printf (“a is larger than b”);
}
if-else Statement:
An
if statement may also optionally contain
a second statement, the ``else
clause,'' which is to be executed if the condition is not met. Here is an
example:
if(n > 0)
average = sum / n; else { printf("can't compute average\n"); average = 0; }
NESTED-if- Statement:
It's
also possible to nest one if
statement inside another. (For that matter, it's in general possible to nest
any kind of statement or control flow construct within another.) For example,
here is a little piece of code which decides roughly which quadrant of the
compass you're walking into, based on an x value which is positive if you're walking east, and a y value which is positive if you're
walking north:
if(x > 0)
{ if(y > 0) printf("Northeast.\n"); else printf("Southeast.\n"); } else { if(y > 0) printf("Northwest.\n"); else printf("Southwest.\n"); }
/* Illustates nested if else and multiple arguments to the scanf function. */ #include <stdio.h> main()
{ int invalid_operator = 0; char operator; float number1, number2, result; printf("Enter two numbers and an operator in the format\n"); printf(" number1 operator number2\n"); scanf("%f %c %f", &number1, &operator, &number2); if(operator == '*') result = number1 * number2; else if(operator == '/') result = number1 / number2; else if(operator == '+') result = number1 + number2; else if(operator == '-') result = number1 - number2; else invalid _ operator = 1; if( invalid _ operator != 1 ) printf("%f %c %f is %f\n", number1, operator, number2, result );else
printf("Invalid operator.\n"); } Sample Program Output
Enter two numbers and an operator in the format number1 operator number223.2 + 12
23.2 + 12 is 35.2
switch - case
This
is another form of the multi way decision. It is well structured, but can only
be used in certain cases where;
- Only one variable is tested, all
branches must depend on the value of that variable. The variable must be
an integral type. (int, long, short or char).
- Each possible value of the
variable can control a single branch. A final, catch all, default branch
may optionally be used to trap all unspecified cases.
Hopefully
an example will clarify things. This is a function which converts an integer
into a vague description. It is useful where we are only concerned in measuring
a quantity when it is quite small.
estimate(number)int number;/* Estimate a number as none, one, two, several, many */{ switch(number) { case 0 : printf("None\n"); break; case 1 : printf("One\n"); break; case 2 : printf("Two\n"); break; case 3 : case 4 : case 5 : printf("Several\n"); break; default : printf("Many\n"); break; }} Each
interesting case is listed with a corresponding action. The break statement
prevents any further statements from being executed by leaving the switch.
Since case 3 and case 4 have no following break, they continue on allowing the
same action for several values of number.
Both
if and switch constructs allow the programmer to make a selection from a number
of possible actions.
Loops
Looping
is a way by which we can execute any some set of statements more than one times
continuously .In c there are mainly three types of loops are use :
·
while
·
do
while
·
For
While
Loops
generally consist of two parts: one or more control
expressions which (not surprisingly) control the execution of the
loop, and the body,
which is the statement or set of statements which is executed over and over.
The
general syntax of a while loop is
Initialization
while( expression ){ Statement1 Statement2 Statement3}
The
most basic loop
in C is the while loop. A while loop has one control expression, and
executes as long as that expression is true. This example repeatedly doubles
the number 2 (2, 4, 8, 16, ...) and prints the resulting numbers as long as
they are less than 1000:
int x = 2;
while(x < 1000) { printf("%d\n", x); x = x * 2; }
(Once
again, we've used braces {}
to enclose the group of statements which are to be executed together as the
body of the loop.)
For Loop
Our
second loop, which we've seen at least one example of already, is the for loop. The general syntax of a while loop is
for( Initialization;expression;Increments/decrements )
{ Statement1 Statement2 Statement3}
The
first one we saw was:
for (i = 0; i < 10; i = i + 1) printf ("i is %d\n", i);
(Here we see that the for loop has three control expressions.
As always, the statement can be a brace-enclosed block.)
Do while Loop
This
is very similar to the while loop except that the test occurs at the end of the
loop body. This guarantees that the loop is executed at least once before
continuing. Such a setup is frequently used where data is to be read. The test
then verifies the data, and loops back to read again if it was unacceptable.
do{ printf("Enter 1 for yes, 0 for no :"); scanf("%d", &input_value);} while (input_value != 1 && input_value != 0)
The break Statement
We have already met break in the
discussion of the switch statement. It is used to exit from a loop or a switch,
control passing to the first statement beyond the loop or a switch.
With loops, break can be used to force
an early exit from the loop, or to implement a loop with a test to exit in the
middle of the loop body. A break within a loop should always be protected
within an if statement which provides the test to control the exit condition.
The continue Statement
This is similar to break but is
encountered less frequently. It only works within loops where its effect is to
force an immediate jump to the loop control statement.
- In
a while loop, jump to the test statement.
- In
a do while loop, jump to the test statement.
- In
a for loop, jump to the test, and perform the iteration.
Like a break, continue should be
protected by an if statement. You are unlikely to use it very often.
Take the following example:
int i;
for (i=0;i<10;i++)
{
if (i==5)
continue;
printf("%d",i);
if (i==8)
break;
}
This code will print 1 to 8 except 5.
Continue means, whatever code that follows the continue statement WITHIN the
loop code block will not be exectued and the program will go to the next
iteration, in this case, when the program reaches i=5 it checks the condition
in the if statement and executes 'continue', everything after continue, which
are the printf statement, the next if statement, will not be executed.
Break statement will just stop execution of the look and go to the next
statement after the loop if any. In this case when i=8 the program will jump
out of the loop. Meaning, it wont continue till i=9, 10.
Comment:
- The compiler is "line
oriented", and parses your program in a line-by-line fashion.
- There are two kinds of comments:
single-line and multi-line comments.
- The single-line comment is
indicated by "//"
This
means everything after the first occurrence of "//", UP TO THE END OF
CURRENT LINE, is ignored.
- The multi-line comment is
indicated by the pair "/*" and "*/".
This
means that everything between these two sequences will be ignored. This may
ignore any number of lines.
Here
is a variant of our first program:
/* This is a variant of my first program.* It is not much, I admit.*/int main() {printf("Hello World!\n"); // that is all?return(0);}
UNIT
– 4
Arrays are widely used
data type in ‘C’ language. It is a collection of elements of similar data type.
These similar elements could be of all integers, all floats or all characters.
An array of character is called as string whereas and array of integer or float
is simply called as an array. So array may be defined as a group of elements
that share a common name and that are defined by position or index. The
elements of an arrays are store in sequential order in memory.
There are mainly two types of Arrays are used:
- One dimensional
Array
- Multidimensional Array
One dimensional Array
So
far, we've been declaring simple variables: the declaration
int i;
declares
a single variable, named i,
of type int. It is also possible to declare an array of several
elements. The declaration
int a[10];
declares
an array, named a, consisting of ten elements, each of
type int. Simply speaking, an array is a
variable that can hold more than one value. You specify which of the several
values you're referring to at any given time by using a numeric subscript. (Arrays in programming
are similar to vectors or matrices in mathematics.) We can represent the array a above with a picture like this:
In
C, arrays are zero-based:
the ten elements of a 10-element array are numbered from 0 to 9. The subscript
which specifies a single element of an array is simply an integer expression in
square brackets. The first element of the array is a[0], the second element is a[1], etc. You can use these ``array
subscript expressions'' anywhere you can use the name of a simple variable, for
example:
a[0] = 10; a[1] = 20; a[2] = a[0] + a[1];
Notice
that the subscripted array references (i.e. expressions such as a[0] and a[1]) can appear on either side of the
assignment operator. it is possible to initialize some or all elements of an
array when the array is defined. The syntax looks like this:
int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
The
list of values, enclosed in braces {}, separated by commas, provides the
initial values for successive elements of the array.
The
subscript does not have to be a constant like 0 or 1; it can be any integral
expression. For example, it's common to loop over all elements of an array:
int i; for(i = 0; i < 10; i = i + 1) a[i] = 0;
This
loop sets all ten elements of the array a
to 0.
Arrays
are a real convenience for many problems, but there is not a lot that C will do
with them for you automatically. In particular, you can neither set all
elements of an array at once nor assign one array to another; both of the
assignments
a = 0; /* WRONG */
and
int b[10]; b = a; /* WRONG */
are illegal.
To
set all of the elements of an array to some value, you must do so one by one,
as in the loop example above. To copy the contents of one array to another, you
must again do so one by one:
int b[10]; for(i = 0; i < 10; i = i + 1) b[i] = a[i]; Remember
that for an array declared
int a[10]; there
is no element a[10]; the topmost element is a[9]. This is one reason that zero-based
loops are also common in C. Note that the for loop
for(i = 0; i < 10; i = i + 1) ...
does just what you want in this case:
it starts at 0, the number 10 suggests (correctly) that it goes through 10
iterations, but the less-than comparison means that the last trip through the
loop has i set to 9. (The comparison i <= 9 would also work, but it would be less
clear and therefore poorer style.)
Multidimensional Array
The
declaration of an array of arrays looks like this:
int a2[5][7]; You have to read complicated
declarations like these ``inside out.'' What this one says is that a2 is an array of 5 something’s, and
that each of the something’s is an array of 7 ints. More briefly, ``a2 is an array of 5 arrays of 7 ints,'' or, ``a2 is an array of array of int.'' In the declaration of a2, the brackets closest to the
identifier a2 tell you what a2 first and foremost is. That's how you
know it's an array of 5 arrays of size 7, not the other way around. You can
think of a2 as having 5 ``rows'' and 7
``columns,'' although this interpretation is not mandatory. (You could also
treat the ``first'' or inner subscript as ``x'' and the second as ``y.'' Unless
you're doing something fancy, all you have to worry about is that the
subscripts when you access the array match those that you used when you
declared it, as in the examples below.)
To
illustrate the use of multidimensional arrays, we might fill in the elements of
the above array a2 using this piece of code:
int i, j;
for(i = 0; i < 5; i = i + 1) { for(j = 0; j < 7; j = j + 1) a2[i][j] = 10 * i + j; }
This
pair of nested loops sets a[1][2]
to 12, a[4][1] to 41, etc. Since the first dimension
of a2 is 5, the first subscripting index
variable, i, runs from 0 to 4. Similarly, the
second subscript varies from 0 to 6.
We
could print a2 out (in a two-dimensional way,
suggesting its structure) with a similar pair of nested loops:
for (i = 0; i < 5; i = i + 1)
{ for (j = 0; j < 7; j = j + 1) printf ("%d\t", a2[i][j]); printf ("\n"); }
(The
character \t in the printf string is the tab character.)
Just
to see more clearly what's going on, we could make the ``row'' and ``column''
subscripts explicit by printing them, too:
for(j = 0; j < 7; j = j + 1)
printf("\t%d:", j); printf ("\n"); for(i = 0; i < 5; i = i + 1) { printf("%d:", i); for(j = 0; j < 7; j = j + 1) printf("\t%d", a2[i][j]); printf("\n"); }
This
last fragment would print
0: 1: 2: 3: 4: 5: 6: 0: 0 1 2 3 4 5 61: 10 11 12 13 14 15 162: 20 21 22 23 24 25 263: 30 31 32 33 34 35 364: 40 41 42 43 44 45 46
STRINGS:
Strings are the
combination of number of characters these are used to store any word in any
variable of constant. A string is an array of character. It is internally
represented in system by using ASCII value. Every single character can have its
own ASCII value in the system. A character string is stored in one array of
character type.
e.g. “Ram” contains ASCII value per location,
when we are using strings and then these strings are always terminated by
character ‘\0’. We use conversion specifies %s to set any string we can have
any string as follows:-
char nm [25].
When we store any value in nm variable then
it can hold only 24 character because at the end of the string one character is
consumed automatically by ‘\0’.
#include<string.h>
There are some common inbuilt functions to
manipulation on string in string.h file. these are as follows:
1.
strlen - string length
2.
strcpy - string copy
3. strcmp - string compare
4. strups - string upper
5. strlwr - string lower
6. strcat - string concatenate
FUNCTIONS
A function is a ``black box'' that
we've locked part of our program into. The idea behind a function is that it compartmentalizes part of
the program, and in particular, that the code within the function has some
useful properties:
- It performs some well-defined task, which will be
useful to other parts of the program.
- It might be useful to other programs as well; that
is, we might be able to reuse it (and without having to rewrite it).
- The rest of the program doesn't have to know the
details of how the function is implemented. This can make the rest of the
program easier to think about.
- The function performs its task well. It may be
written to do a little more than is required by the first program that
calls it, with the anticipation that the calling program (or some other
program) may later need the extra functionality or improved performance.
(It's important that a finished function do its job well, otherwise there
might be a reluctance to call it, and it therefore might not achieve the
goal of reusability.)
- By placing the code to perform the useful task into
a function, and simply calling the function in the other parts of the
program where the task must be performed, the rest of the program becomes
clearer: rather than having some large, complicated,
difficult-to-understand piece of code repeated wherever the task is being
performed, we have a single simple function call, and the name of the
function reminds us which task is being performed.
- Since the rest of the program doesn't have to know
the details of how the function is implemented, the rest of the program
doesn't care if the function is reimplemented later, in some different way
(as long as it continues to perform its same task, of course!). This means
that one part of the program can be rewritten, to improve performance or
add a new feature (or simply to fix a bug), without having to rewrite the
rest of the program.
Functions are probably the most
important weapon in our battle against software complexity. You'll want to
learn when it's appropriate to break processing out into functions (and also
when it's not), and how
to set up function interfaces to best achieve the qualities mentioned above: reusability,
information hiding, clarity, and maintainability.
So what defines a function? It has a name that you call it by,
and a list of zero or more arguments
or parameters
that you hand to it for it to act on or to direct its work; it has a body containing the
actual instructions (statements) for carrying out the task the function is
supposed to perform; and it may give you back a return value, of a particular type.
Here is a very simple function, which
accepts one argument, multiplies it by 2, and hands that value back:
int multbytwo(int x)
{ int retval; retval = x * 2; return retval; } On
the first line we see the return type of the function (int),
the name of the function (multbytwo),
and a list of the function's arguments, enclosed in parentheses. Each argument
has both a name and a type; multbytwo
accepts one argument, of type int,
named x.
The name x
is arbitrary, and is used only within the definition of multbytwo.
The caller of this function only needs to know that a single argument of type int
is expected; the caller does not need to know what name the function will use
internally to refer to that argument. (In particular, the caller does not have
to pass the value of a variable named x.)
Next we see, surrounded by the
familiar braces, the body of the function itself. This function consists of one
declaration (of a local variable retval)
and two statements. The first statement is a conventional expression statement,
which computes and assigns a value to retval,
and the second statement is a return
statement, which causes the function to return to its caller, and also
specifies the value which the function returns to its caller.
The return
statement can return the value of any expression, so we don't really need the
local retval
variable; the function could be collapsed to-
int multbytwo(int x)
{ return x * 2; }
How do we call a function? We've been
doing so informally since day one, but now we have a chance to call one that
we've written, in full detail. Here is a tiny skeletal program to call multby2:
#include <stdio.h>
extern int multbytwo(int); int main() { int i, j; i = 3; j = multbytwo(i); printf("%d\n", j); return 0; } This looks much like our other test
programs, with the exception of the new line
extern int multbytwo(int);
This
is an external function
prototype declaration. It is an external declaration, in that it
declares something which is defined somewhere else. (We've already seen the
defining instance of the function multbytwo,
but maybe the compiler hasn't seen it yet.) The function prototype declaration
contains the three pieces of information about the function that a caller needs
to know: the function's name, return type, and argument type(s). Since we don't
care what name the multbytwo
function will use to refer to its first argument, we don't need to mention it.
(On the other hand, if a function takes several arguments, giving them names in
the prototype may make it easier to remember which is which, so names may
optionally be used in function prototype declarations.) Finally, to remind us
that this is an external declaration and not a defining instance, the prototype
is preceded by the keyword extern.
The presence of the function prototype
declaration lets the compiler know that we intend to call this function, multbytwo.
The information in the prototype lets the compiler generate the correct code
for calling the function, and also enables the compiler to check up on our code
(by making sure, for example, that we pass the correct number of arguments to
each function we call).
Down in the body of main, the action
of the function call should be obvious: the line
j = multbytwo(i);
calls multbytwo,
passing it the value of i
as its argument. When multbytwo
returns, the return value is assigned to the variable j.
(Notice that the value of main's
local variable i
will become the value of multbytwo's
parameter x;
this is absolutely not a problem, and is a normal sort of affair.)
This example is written out in
``longhand,'' to make each step equivalent. The variable i
isn't really needed, since we could just as well call
j = multbytwo(3);
And the variable j
isn't really needed, either, since we could just as well call
printf("%d\n", multbytwo(3));
Here, the call to multbytwo
is a sub expression which serves as the second argument to printf.
The value returned by multbytwo
is passed immediately to printf.
(Here, as in general, we see the flexibility and generality of expressions in
C. An argument passed to a function may be an arbitrarily complex sub
expression, and a function call is itself an expression which may be embedded
as a sub expression within arbitrarily complicated surrounding expressions.)
We should say a little more about the
mechanism by which an argument is passed down from a caller into a function.
Formally, C is call by
value, which means that a function receives copies of the values of
its arguments. We can illustrate this with an example. Suppose, in our
implementation of multbytwo,
we had gotten rid of the unnecessary retval
variable like this:
int multbytwo(int x)
{ x = x * 2; return x; }
Recursive Functions
A
recursive function is one which calls itself. This is another complicated idea
which you are unlikely to meet frequently. We shall provide some examples to
illustrate recursive functions.
Recursive
functions are useful in evaluating certain types of mathematical function. You
may also encounter certain dynamic data structures such as linked lists or
binary trees. Recursion is a very useful way of creating and accessing these
structures.
Here
is a recursive version of the Fibonacci function. We saw a non recursive
version of this earlier.
int fib(int num)/* Fibonacci value of a number */{ switch(num) { case 0: return(0); break; case 1: return(1); break; default: /* Including recursive calls */ return(fib(num - 1) + fib(num - 2)); break; }} We
met another function earlier called power. Here is an alternative recursive
version.
double power(double val, unsigned pow){ if(pow == 0) /* pow(x, 0) returns 1 */ return(1.0); else return(power(val, pow - 1) * val);} Notice that each of these definitions
incorporate a test. Where an input value gives a trivial result, it is returned
directly; otherwise the function calls itself, passing a changed version of the
input values. Care must be taken to define functions which will not call themselves
indefinitely, otherwise your program will never finish.
The
definition of fib is interesting, because it calls itself twice when recursion
is used. Consider the effect on program performance of such a function
calculating the Fibonacci function of a moderate size number.
If
such a function is to be called many times, it is likely to have an adverse
effect on program performance.
Don't
be frightened by the apparent complexity of recursion. Recursive functions are
sometimes the simplest answer to a calculation. However there is always an
alternative non-recursive solution available too. This will normally involve
the use of a loop, and may lack the elegance of the recursive solution.
Pointer
a
pointer is a variable that points to or references a memory location in which
data is stored. In the computer, each memory cell has an address that can be
used to access that location so a pointer variable points to a memory location
we can access and change the contents of this memory location via the pointer.
Pointer declaration:
A pointer is a variable that contains the memory location of another
variable in which data is stored. Using pointer, you start by specifying the
type of data stored in the location. The asterisk helps to tell the compiler
that you are creating a pointer variable. Finally you have to give the name of
the variable. The syntax is as shown below.
|
type * variable name |
The following example illustrate the declaration of pointer variable :
|
int *ptr; |
Address operator:
Once we declare a pointer variable then we must point it to something we
can do this by assigning to the pointer the address of the variable you want to
point as in the following example:
|
ptr=# |
The above code tells that the address where num is stores into the variable
ptr. The variable ptr has the value 21260,if num is stored in memory 21260
address then
The following program illustrate the pointer declaration :
|
/* A program to
illustrate pointer declaration*/ main() |
Pointer expressions & pointer arithmetic:
In expressions, like other variables pointer variables can be used. For
example if p1 and p2 are properly initialized and declared pointers, then the
following statements are valid.
|
y=*p1**p2; |
C
allows us to subtract integers to or add integers from pointers as well as to
subtract one pointer from the other. We can also use short hand operators with
pointers p1+=; sum+=*p2; etc., By using relational operators, we can also
compare pointers like the expressions such as p1 >p2 , p1==p2 and p1!=p2 are
allowed.
The following program illustrate the pointer expression and pointer
arithmetic:
|
/*Program to
illustrate the pointer expression and pointer arithmetic*/ |
Pointers and function:
In a function declaration, the pointer are very much used . Sometimes, only
with a pointer a complex function can be easily represented and success. In a
function definition, the usage of the pointers may be classified into two
groups.
1. Call
by reference
2. Call
by value.
Call by value:
We
have seen that there will be a link established between the formal and actual
parameters when a function is invoked. As soon as temporary storage is created
where the value of actual parameters is stored. The formal parameters picks up
its value from storage area the mechanism of data transfer between formal and
actual parameters allows the actual parameters mechanism of data transfer is
referred as call by value. The corresponding formal parameter always represents
a local variable in the called function. The current value of the corresponding
actual parameter becomes the initial value of formal parameter. In the body of
the actual parameter, the value of formal parameter may be changed. In the body
of the subprogram, the value of formal parameter may be changed by assignment
or input statements. This will not change the value of the actual parameters.
|
/* Include< stdio.h
> void main() fncn(p,q) |
Call by Reference:
The
address should be pointers, when we pass address to a function the parameters
receiving. By using pointers, the process of calling a function to pass the
address of the variable is known as call by reference. The function which is
called by reference can change the value of the variable used in the call.
|
/* example of call by
reference*? /* Include< stdio.h
> |
Pointer to arrays:
An
array is actually very much similar like pointer. We can declare as int *a is
an address, because a[0] the arrays first element as a[0] and *a is also an
address the form of declaration is also equivalent. The difference is pointer
can appear on the left of the assignment operator and it is a is a variable
that is lvalue. The array name cannot appear as the left side of assignment
operator and is constant.
|
/* A program to
display the contents of array using pointer*/ |
Pointers and structures :
We
know the name of an array stands for address of its zeros element the same
concept applies for names of arrays of structures. Suppose item is an array
variable of the struct type. Consider the following declaration:
|
struct products |
UNIT - 7
STRUCTURES & UNIONS
What
is a Structure?
- Structure
is a method of packing the data of different types.
- When
we require using a collection of different data items of different data
types in that situation we can use a structure.
- A
structure is used as a method of handling a group of related data items of
different data types.
A
structure is a collection of variables under a single name. These variables can
be of different types, and each has a name which is used to select it from the
structure. A structure is a convenient way of grouping several pieces of
related information together.
A
structure can be defined as a new named type, thus extending the number of
available types. It can use other structures, arrays or pointers as some of its
members, though this can get complicated unless you are careful.
Defining a Structure
A
structure type is usually defined near to the start of a file using a typedef
statement. typedef defines and names a new type, allowing its use throughout
the program. typedefs usually occur just after the #define and #include
statements in a file.
Here
is an example structure definition.
typedef struct { char name[64]; char course[128]; int age; int year;} student;
This
defines a new type student variables of type student can be declared as
follows.
student st_rec;
Notice
how similar this is to declaring an int or float.
The
variable name is st_rec, it has members called name, course, age and year.
Accessing Members of a Structure
Each
member of a structure can be used just like a normal variable, but its name
will be a bit longer. To return to the examples above, member name of structure
st_rec will behave just like a normal array of char, however we refer to it by
the name .
st_rec.name
Here
the dot is an operator which selects a member from a structure.
Where
we have a pointer to a structure we could dereference the pointer and then use
dot as a member selector. This method is a little clumsy to type. Since
selecting a member from a structure pointer happens frequently, it has its own
operator -> which acts as follows. Assume that st_ptr is a pointer to a structure
of type student We would refer to the name member as.
st_ptr -> name /*
Example program for using a structure*/
#include< stdio.h >
void main()
{
int id_no;
char name[20];
char address[20];
char combination[3];
int age;
}newstudent;
printf(”Enter the student information”);
printf(”Now Enter the student id_no”);
scanf(“%d”,&newstudent.id_no);
printf(“Enter the name of the student”);
scanf(“%s”,&new student.name);
printf(“Enter the address of the student”);
scanf(“%s”,&new student.address);printf(“Enter the cmbination of the
student”);
scanf(“%d”,&new student.combination);printf(Enter the age of the student”);
scanf(“%d”,&new student.age);
printf(“Student information\n”);
printf(“student id_number=%d\n”,newstudent.id_no);
printf(“student name=%s\n”,newstudent.name);
printf(“student Address=%s\n”,newstudent.address);
printf(“students combination=%s\n”,newstudent.combination);
printf(“Age of student=%d\n”,newstudent.age);
}
Arrays of structure:
It is possible to define a
array of structures for example if we are maintaining information of all the
students in the college and if 100 students are studying in the college. We
need to use an array than single variables. We can define an array of
structures as shown in the following example:
structure information
{
int id_no;
char name[20];
char address[20];
char combination[3];
int age;
}
student[100];
An array of structures can be assigned initial values just as any other array
can. Remember that each element is a structure that must be assigned corresponding
initial values as illustrated below.
#include< stdio.h >
{
struct info
{
int id_no;
char name[20];
char address[20];
char combination[3];
int age;
}
struct info std[100];
int I,n;
printf(“Enter the number of students”);
scanf(“%d”,&n);
printf(“ Enter Id_no,name address combination age\m”);
for(I=0;I < n;I++)
scanf(“%d%s%s%s%d”,&std[I].id_no,std[I].name,std[I].address,std[I].combination,&std[I].age);
printf(“\n Student information”);
for (I=0;I< n;I++)
printf(“%d%s%s%s%d\n”,
”,std[I].id_no,std[I].name,std[I].address,std[I].combination,std[I].age);
}
Structure within a structure:
A structure may be defined
as a member of another structure. In such structures the declaration of the
embedded structure must appear before the declarations of other structures.
struct date
{
int day;
int month;
int year;
};
struct student
{
int id_no;
char name[20];
char address[20];
char combination[3];
int age;
structure date def;
structure date doa;
}oldstudent, newstudent;
the sturucture student
constains another structure date as its one of its members.
Union:
Unions like
structure contain members whose individual data types may differ from one
another. However the members that compose a union all share the same storage area
within the computers memory where as each member within a structure is assigned
its own unique storage area. Thus unions are used to observe memory. They are
useful for application involving multiple members. Where values need not be
assigned to all the members at any one time. Like structures union can be
declared using the keyword union as follows:
union item
{
int m;
float p;
char c;
}
code;
this declares a variable
code of type union item. The union contains three members each with a different
data type. However we can use only one of them at a time. This is because if
only one location is allocated for union variable irrespective of size. The
compiler allocates a piece of storage that is large enough to access a union
member we can use the same syntax that we use to access structure members. That
is
code.m
code.p
code.c
are all valid member variables. During
accessing we should make sure that we are accessing the member whose value is
currently stored.
For example a statement such as -
code.m=456;
code.p=456.78;
printf(“%d”,code.m);
Would prodece erroneous
result..
Enum
declarations
There
are two kinds of enum type declarations. One kind creates a
named type, as in
enum MyEnumType { ALPHA, BETA, GAMMA }; If you give
an enum type a name, you can use that type
for variables, function arguments and return values, and so on:
enum MyEnumType x; /* legal in both C and C++ */MyEnumType y; // legal only in C++ The other
kind creates an unnamed type. This is used when you want names for constants
but don't plan to use the type to declare variables, function arguments, etc.
For example, you can write
enum { HOMER, MARGE, BART, LISA, MAGGIE };
Values of enum constants
If you don't
specify values for enum constants, the values start at zero
and increase by one with each move down the list. For example, given
enum MyEnumType { ALPHA, BETA, GAMMA };
ALPHA has a value of 0, BETA has a value of 1, and GAMMA has a value of 2.
If you want, you may provide
explicit values for enum constants, as in
enum FooSize { SMALL = 10, MEDIUM = 100, LARGE = 1000 };
There is an implicit
conversion from any enum type to int. Suppose this type exists:
enum MyEnumType { ALPHA, BETA, GAMMA };
Then the
following lines are legal:
int i = BETA; // give i a value of 1int j = 3 + GAMMA; // give j a value of 5
On the other hand, there is not an implicit conversion
from int to an enum type:
MyEnumType x = 2; // should NOT be allowed by compilerMyEnumType y = 123; // should NOT be allowed by compiler
Note
that it doesn't matter whether the int
matches one of the constants of the enum type; the type conversion is always illegal.
Typedefs
A
typedef in C is a declaration. Its purpose is to create new types from existing
types; whereas a variable declaration creates new memory locations. Since a
typedef is a declaration, it can be intermingled with variable declarations,
although common practice would be to state typedefs first, then variable
declarations. A
nice programming convention is to capitalize the first letter of a user-defined
type to distinguish it from the built-in types, which all have lower-case names. Also, typedefs are usually
global declarations.
Example: Use a Typedef To Create A Synonym
for a Type Name
typedef int Integer; //Integer can now be
used in place of int
int a,b,c,d; //4 variables of type int
Integer e,f,g,h; //the same thing
In
general, a typedef should never be used to assign a different name to a
built-in type name; it just confuses the reader. Usually, a typedef associates
a type name with a more complicated type specification, such as an array. A typedef should
always be used in situations where the same type definition is used more than
once for the same purpose.
For example, a vector of 20 elements might represent different aspects of a
scientific measurement.
Example: Use a Typedef To Create A Synonym
for an Array Type
typedef int Vector[20]; //20 integers
Vector a,b;
int a[20], b[20]; //the same thing, but a
typedef is preferred
Typedefs for Enumerated Types
Every
type has constants. For the "int" type, the constants are 1,2,3,4,5;
for "char", 'a','b','c'. When a type has constants that have names,
like the colors of the rainbow, that type is called an enumerated type. Use an enumerated type for
computer representation of common objects that have names like Colors, Playing
Cards, Animals, Birds, Fish etc. Enumerated type constants (since they are
names) make a program easy to read and understand.
We
know that all names in a computer usually are associated with a number. Thus,
all of the names (RED, BLUE, GREEN) for an enumerated type are
"encoded" with numbers. In eC, if you define an enumerated type, like
Color, you cannot add it to an integer; it is not type compatible. In standard
C++, anything goes. Also, in eC an enumerated type must always be declared in a
typedef before use (in fact, all new types must be declared before use).
Example: Use a Typedef To Create An
Enumerated Type
typedef enum {RED, BLUE, GREEN} Color;
Color a,b;
a = RED;
a = RED+BLUE; //NOT ALLOWED in eC
if ((a == BLUE) || (a==b))
cout<<"great";
Notice
that an enumerated type is a code that associates symbols and numbers. The char
type can be thought of as an enumeration of character codes. The default code
for an enumerated type assigns the first name to the value 0 (RED), second name
1 (BLUE), third 2 (GREEN) etc. The user can, however, override any, or all, of
the default codes by specifying alternative values.
UNIT 9
FILE
MANAGEMENT
What is a File?
Abstractly,
a file
is a collection of bytes stored on a secondary storage device, which is
generally a disk of some kind. The collection of bytes may be interpreted, for
example, as characters, words, lines, paragraphs and pages from a textual
document; fields and records belonging to a database; or pixels from a
graphical image. The meaning attached to a particular file
is determined entirely by the data structures and operations used by a program
to process the file. It is conceivable (and it sometimes
happens) that a graphics file will be read and displayed by a program
designed to process textual data. The result is that no meaningful output
occurs (probably) and this is to be expected. A file
is simply a machine decipherable storage media where programs and data are
stored for machine usage.
Essentially there are
two kinds of files that programmers deal with text files and binary files.
These two classes of files will be discussed in the following sections.
ASCII Text files
A
text file
can be a stream of characters that a computer can process sequentially. It is
not only processed sequentially but only in forward direction. For this reason
a text file
is usually opened for only one kind of operation (reading, writing, or
appending) at any given time.
Similarly,
since text files only process characters, they can only read or write data one
character at a time. (In C Programming Language, Functions are provided that
deal with lines of text, but these still essentially process data one character
at a time.) A text stream in C is a special kind of file.
Depending on the requirements of the operating system, newline characters may
be converted to or from carriage-return/linefeed combinations depending on
whether data is being written to, or read from, the file.
Other character conversions may also occur to satisfy the storage requirements
of the operating system. These translations occur transparently and they occur
because the programmer has signalled the intention to process a text file.
Binary files
A binary file
is no different to a text file. It is a collection of bytes. In C Programming
Language a byte and a character are equivalent. Hence a binary file
is also referred to as a character stream, but there are two essential
differences.
1. No special processing of the data occurs and each byte of data is
transferred to or from the disk unprocessed.
2. C Programming Language places no constructs on the file,
and it may be read from, or written to, in any manner chosen by the programmer.
Binary files can be either processed sequentially or, depending on the
needs of the application, they can be processed using random access techniques.
In C Programming Language, processing a file
using random access techniques involves moving the current file
position to an appropriate place in the file
before reading or writing data. This indicates a second characteristic of
binary files
– they a generally processed using read and write operations simultaneously.
For example, a database file will be created and processed as a binary file.
A record update operation will involve locating the appropriate record, reading
the record into memory, modifying it in some way, and finally writing the
record back to disk at its appropriate location in the file.
These kinds of operations are common to many binary files, but are rarely found
in applications that process text files.
Creating a file and
output some data
In
order to create files we have to learn about File
I/O i.e. how to write data into a file and how to read data from a file.
We will start this section with an example of writing data to a file.
We begin as before with the include statement for stdio.h, then define some
variables for use in the example including a rather strange looking new type.
/* Program to create a file and write some data the file */
#include <stdio.h>
#include <stdio.h>
main( )
{
FILE *fp;
char stuff[25];
int index;
fp = fopen("TENLINES.TXT","w"); /* open for writing */
strcpy(stuff,"This is an example line.");
for (index = 1; index <= 10; index++)
fprintf(fp,"%s Line number %d\n", stuff, index);
fclose(fp); /* close the file before ending program */
}
The
type FILE
is used for a file variable and is defined in the stdio.h file.
It is used to define a file pointer for use in file
operations. Before we can write to a file, we must open it. What this really means is
that we must tell the system that we want to write to a file
and what the file name is. We do this with the fopen()
function illustrated in the first line of the program. The file
pointer, fp in our case, points to the file
and two arguments are required in the parentheses, the file
name first, followed by the file type.
The
file
name is any valid DOS file name, and can be expressed in upper or
lower case letters, or even mixed if you so desire. It is enclosed in double
quotes. For this example we have chosen the name TENLINES.TXT. This file
should not exist on your disk at this time. If you have a file
with this name, you should change its name or move it because when we execute
this program, its contents will be erased. If you don’t have a file
by this name, that is good because we will create one and put some data into
it. You are permitted to include a directory with the file
name. The directory must, of course, be a valid directory otherwise an error
will occur. Also, because of the way C handles literal strings, the directory
separation character ‘\’ must be written twice. For example, if the file
is to be stored in the \PROJECTS sub directory then the file
name should be entered as “\\PROJECTS\\TENLINES.TXT”. The second parameter is
the file
attribute and can be any of three letters, r, w, or a, and must be lower case.
Reading (r)
When
an r is used, the file is opened for reading, a w is used to
indicate a file to be used for writing, and an indicates that you desire to append additional
data to the data already in an existing file.
Most C compilers have other file attributes available; check your Reference
Manual for details. Using the r indicates that the file
is assumed to be a text file. Opening a file
for reading requires that the file already exist. If it does not exist, the file
pointer will be set to NULL and can be checked by the program.
Here is a small program that reads a file
and display its contents on screen. /* Program to display the contents of a file on screen */
#include <stdio.h>
void main()
{
FILE *fopen(), *fp;
int c;
fp = fopen("prog.c","r");
c = getc(fp) ;
while (c!= EOF)
{
putchar(c);
c = getc(fp);
}
fclose(fp);
}
Writing (w)
When
a file
is opened for writing, it will be created if it does not already exist and it
will be reset if it does, resulting in the deletion of any data already there.
Using the w indicates that the file is assumed to be a text file.
Here is the program to
create a file and write some data into the file.
#include <stdio.h>
int main()
{
FILE *fp;
file = fopen("file.txt","w");
/*Create a file and add text*/
fprintf(fp,"%s","This is just an example :)"); /*writes data to the file*/
fclose(fp); /*done!*/
return 0;
}
Appending (a):
When
a file
is opened for appending, it will be created if it does not already exist and it
will be initially empty. If it does exist, the data input point will be
positioned at the end of the present data so that any new data will be added to
any data that already exists in the file. Using the a indicates that the file
is assumed to be a text file.
Here is a program that
will add text to a file which already exists and there is some
text in the file.
#include <stdio.h>
int main()
{
FILE *fp
file = fopen("file.txt","a");
fprintf(fp,"%s","This is just an example :)"); /*append some text*/
fclose(fp);
return 0;
}
Outputting to the file
The
job of actually outputting to the file is nearly identical to the outputting we
have already done to the standard output device. The only real differences are
the new function names and the addition of the file
pointer as one of the function arguments. In the example program, fprintf
replaces our familiar printf function name, and the file
pointer defined earlier is the first argument within the parentheses. The
remainder of the statement looks like, and in fact is identical to, the printf
statement.
Closing a file
To
close a file you simply use the function fclose with
the file
pointer in the parentheses. Actually, in this simple program, it is not
necessary to close the file because the system will close all open
files before returning to DOS, but it is good programming practice for you to
close all files in spite of the fact that they will be closed automatically,
because that would act as a reminder to you of what files are open at the end
of each program.
You
can open a file for writing, close it, and reopen it for
reading, then close it, and open it again for appending, etc. Each time you
open it, you could use the same file pointer, or you could use a different one.
The file
pointer is simply a tool that you use to point to a file
and you decide what file it will point to. Compile and run this
program. When you run it, you will not get any output to the monitor because it
doesn’t generate any. After running it, look at your directory for a file
named TENLINES.TXT and type it; that is where your output will be. Compare the
output with that specified in the program; they should agree! Do not erase the file
named TENLINES.TXT yet; we will use it in
some of the other examples in this section.
Reading from a text file
Now
for our first program that reads from a file.
This program begins with the familiar include, some data definitions, and the file
opening statement which should require no explanation except for the fact that
an r is used here because we want to read it.
#include <stdio.h>
main( )
{
FILE *fp;
char c;
funny = fopen("TENLINES.TXT", "r");
if (fp == NULL)
printf("File doesn't exist\n");
else {
do {
c = getc(fp); /* get one character from the file */
putchar(c); /* display it on the monitor */
} while (c != EOF); /* repeat until EOF (end of file) */
}
fclose(fp);
}
In
this program we check to see that the file exists, and if it does, we execute the
main body of the program. If it doesn’t, we print a message and quit. If the file
does not exist, the system will set the pointer equal to NULL which we can
test. The main body of the program is one do while loop in which a single
character is read from the file and output to the monitor until an EOF
(end of file) is detected from the input file.
The file
is then closed and the program is terminated. At this point, we have the
potential for one of the most common and most perplexing problems of
programming in C. The variable returned from the getc function is a character, so
we can use a char variable for this purpose. There is a problem that could
develop here if we happened to use an unsigned char however, because C usually
returns a minus one for an EOF - which an unsigned char type variable is not
capable of containing. An unsigned char type variable can only have the values
of zero to 255, so it will return a 255 for a minus one in C. This is a very
frustrating problem to try to find. The program can never find the EOF and will
therefore never terminate the loop. This is easy to prevent: always have a char
or int type variable for use in returning an EOF. There is another problem with
this program but we will worry about it when we get to the next program and
solve it with the one following that.
After
you compile and run this program and are satisfied with the results, it would
be a good exercise to change the name of TENLINES.TXT and run the program again
to see that the NULL test actually works as stated. Be sure to change the name
back because we are still not finished with TENLINES.TXT.
Comments
Post a Comment