PROGRAMMING in ‘C’

LECTURE NOTES

Year : 2024 -2025

Subject Code : ES101/102

Class : B.Tech

Branch : CSE
Prepared By : Mr. Ajay Kumar Tiwari,
Assistant Professor, CSE, MAIT

MAHARAJA AGRASEN INSTITUTE OF

TECHNOLOGY
ROHINI,

DELHI

CSE, MAIT
 UNIT-I
INTRODUCTION TO PROGRAMMING

COMPUTER SYSTEMS

A Computer is an electronic device that stores manipulates and retrieves the data. We can also refer
computer computes the information supplied to it and generates data.
A System is a group of several objects with a process. For Example: Educational System involves
teacher, students (objects). Teacher teaches subject to students i.e., teaching (process). Similarly, a
computer system can have objects and process.
The following are the objects of computer System
User (A person who uses the computer)
Hardware
Software
Hardware: Hardware of a computer system can be referred as anything which we can touch and
feel. Example: Keyboard and Mouse.
The hardware of a computer system can be classified as
 Input Devices (I/P)
 Processing Devices (CPU)
 Output Devices(O/P)

KEYBOARD ALU, CU, MONITOR

MU

CPU
INPUT
OUTPUT

ALU: It performs the Arithmetic and Logical Operations such as

+, -, *, / (Arithmetic Operators) and &&, || ( Logical Operators)
CU: Every Operation such as storing, computing and retrieving the data should be governed by the
control unit.

MU: The Memory unit is used for storing the data. The Memory unit is classified into two types.
They are
1) Primary Memory
2) Secondary Memory

CSE, MAIT
Primary memory: The following are the types of memories which are treated as primary ROM: It
represents Read Only Memory that stores data and instructions even when the computer is turned off.
The Contents in the ROM can‘t be modified once if they are written. It is used to store the BIOS
information.
RAM: It represents Random Access Memory that stores data and instructions when the computer is
turned on. The contents in the RAM can be modified any no. of times by instructions. It is used to
store the programs under execution.
Cache memory: It is used to store the data and instructions referred by processor.
Secondary Memory: The following are the different kinds of memories
Magnetic Storage: The Magnetic Storage devices store information that can be read, erased and
rewritten a number of times.
Example: Floppy Disks, Hard Disks, Magnetic Tapes
Optical Storage: The optical storage devices that use laser beams to read and write stored data.
Example: CD (Compact Disk), DVD (Digital Versatile Disk)

COMPUTER SOFTWARE
Software of a computer system can be referred as anything which we can feel and see. Example:
Windows, icons
Computer software is divided in to two broad categories: system software and application software.
System software manages the computer resources .It provides the interface between the hardware and
the users. Application software, on the other hand is directly responsible for helping users solve their
problems.

System Software
System software consists of programs that manage the hardware resources of a computer and
perform required information processing tasks. These programs are divided into three classes: the
operating system, system support, and system development.

The operating system provides services such as a user interface, file and database access, and
interfaces to communication systems such as Internet protocols. The primary purpose of this software
is to keep the system operating in an efficient manner while allowing the users access to the system.

System support software provides system utilities and other operating services. Examples of system
utilities are sort programs and disk format programs. Operating services consists of programs that
provide performance statistics for the operational staff and security monitors to protect the system and
data.

CSE, MAIT
The last system software category, system development software, includes the language translators
that convert programs into machine language for execution, debugging tools to ensure that the
programs are error free and computer –assisted software engineering (CASE) systems.

Application software
Application software is broken in to two classes: general-purpose software and application – specific
software. General purpose software is purchased from a software developer and can be used for
more than one application. Examples of general purpose software include word processors, database
management systems, and computer aided design systems. They are labeled general purpose because
they can solve a variety of user computing problems.
Application –specific software can be used only for its intended purpose.
A general ledger system used by accountants and a material requirements planning system used by a
manufacturing organization are examples of application-specific software. They can be used only for
the task for which they were designed they cannot be used for other generalized tasks.
The relationship between system and application software is shown below. In this figure, each circle
represents an interface point .The inner core is hard ware. The user is represented by the out layer. To
work with the system, the typical user uses some form of application software. The application
software in turn interacts with the operating system, which is a part of the system software layer. The
system software provides the direct interaction with the hard ware. The opening at the bottom of the
figure is the path followed by the user who interacts directly with the operating system when
necessary.

CSE, MAIT
COMPUTING ENVIRONMENTS
The word compute is used to refer to the process of converting information to data. The advent of
several new kinds of computers created a need to have different computing environments.
The following are the different kinds of computing environments available
 Personal Computing Environment
 Time Sharing Environment
 Client/Server Environment
 Distributed Computing Environment
Personal Computing Environment
In 1971, Marcian E. Hoff, working for INTEL combined the basic elements of the central processing
unit into the microprocessor. If we are using a personal computer then all the computer hardware
components are tied together. This kind of computing is used to satisfy the needs of a single user, who
uses the computer for the personal tasks.
Ex: Personal Computer

Time-Sharing Environment
The concept of time sharing computing is to share the processing of the computer basing on the
criteria time. In this environment all the computing must be done by the central computer.The
complete processing is done by the central computer. The computer which ask for processing are only
dumb terminals.

CSE, MAIT
Client/Server Environment
A Client/Server Computing involves the processing between two machines. A client Machine is the
one which requests processing. Server Machine is the one which offers the processing. Hence the
client is Capable enough to do processing. A portion of processing is done by client and the
core(important) processing is done by Server.

Distributed Computing
A distributed computing environment provides a seamless integration of computing functions between
different servers and clients. A client not just a requestor for processing the information from the
server. The client also has the capability to process information. All the machines Clients/Servers
share the processing task. Example: Ebay on Internet

COMPUTER LANGUAGES
To write a program (tells what to do) for a computer, we must use a computer language. Over the
years computer languages have evolved from machine languages to natural languages. The following
is the summary of computer languages
1940’s -- Machine Languages
1950’s -- Symbolic Languages/Assembly Language
1960’s -- High Level Languages

CSE, MAIT
Machine Language
In the earliest days of computers, the only programming languages available were machine languages.
Each computer has its own machine language which is made of streams of 0‘s and 1‘s. The
instructions in machine language must be in streams of 0‘s and 1‘s. This is also referred as binary
digits. These are so named as the machine can directly understood the programs
Advantages:
 High speed execution
 The computer can understood instructions immediately
 No translation is needed.

Disadvantages:
 Machine dependent
 Programming is very difficult
 Difficult to understand
 Difficult to write bug free programs
 Difficult to isolate an error

Example Additon of two numbers

2 0010
+ 3 0011

5 0101

Symbolic Languages (or) Assembly Language

In the early 1950‘s Admiral Grace Hopper, a mathematician and naval officer, developed the concept
of a special computer program that would convert programs into machine language. These early
programming languages simply mirrored the machine languages using symbols or mnemonics to
represent the various language instructions. These languages were known as symbolic languages.
Because a computer does not understand symbolic language it must be translated into the machine
language. A special program called an Assembler translates symbolic code into the machine
language. Hence they are called as Assembly language.

CSE, MAIT
Advantages:
 Easy to understand and use
 Easy to modify and isolate error
 High efficiency
 More control on hardware
Disadvantages:
 Machine Dependent Language
 Requires translator
 Difficult to learn and write programs
 Slow development time
 Less efficient
Example:
2 PUSH2,A

3 PUSH3,B
+ ADDA,B
5
PRINTC

High-Level Languages

The symbolic languages greatly improved programming efficiency they still required programmers to
concentrate on the hardware that they were using working with symbolic languages was also very
tedious because each machine instruction had to be individually coded. The desire to improve
programmer efficiency and to change the focus from the computer to the problems being solved led to
the development of high-level languages.
High-level languages are portable to many different computer allowing the programmer to
concentrate on the application problem at hand rather than the intricacies of the computer.
C A systems implementation Language
C++ C with object oriented enhancements
JAVA Object oriented language for internet and general applications using basic C syntax

Advantages:
 Easy to write and understand
 Easy to isolate an error
 Machine independent language
 Easy to maintain
 Better readability
 Low Development cost

CSE, MAIT
  Easier to document
 Portable
Disadvantages:
 Needs translator
 Requires high execution time
 Poor control on hardware
 Less efficient

Example: C language
#include<stdio.h>
void main()
{
int a,b,c;
scanf("%d%d%",&a,&b);
c=a+b;
printf("%d",c);
}
Difference between Machine, Assembly, High Level Languages

Feature Machine Assembly High Level

Form 0‘s and 1‘s Mnemonic codes Normal English
Machine Dependent Dependent Dependent Independent
Translator Not Needed Needed(Assembler) Needed(Compiler)
Execution Time Less Less High
Languages Only one Different Manufacturers Different Languages
Nature Difficult Difficult Easy
Memory Space Less Less More

Language Translators
These are the programs which are used for converting the programs in one language into machine
language instructions, so that they can be executed by the computer.

Compiler: It is a program which is used to convert the high level language programs into
machine language
Assembler: It is a program which is used to convert the assembly level language programs into
machine language

CSE, MAIT
Interpreter: It is a program, it takes one statement of a high level language program, translates it into
machine language instruction and then immediately executes the resulting machine language
instruction and so on.
Comparison between a Compiler and Interpreter

COMPILER INTERPRETER
A Compiler is used to compile an entire An interpreter is used to translate each line of the
program and an executable program is program code immediately as it is entered
generated through the object program

The executable program is stored in a disk for The executable program is generated in RAM
future use or to run it in another computer
and the interpreter is required for each run of the

program

The compiled programs run faster The Interpreted programs run slower

Most of the Languages use compiler A very few languages use interpreters.

CREATING AND RUNNING PROGRAMS

The procedure for turning a program written in C into machine Language. The process is presented in
a straightforward, linear fashion but you should recognize that these steps are repeated many times
during development to correct errors and make improvements to the code.
The following are the four steps in this process
 Writing and Editing the program
 Compiling the program
 Linking the program with the required modules
 Executing the program

CSE, MAIT
 TEXT EDITOR

COMPILER

Library LINKE
R

RUNNER

OUTPUT

Sl. No. Phase Name of Code Tools File Extension

1 TextEditor Source Code C Compilers .C
Edit,
Notepad Etc..,

2 Compiler Object Code C Compiler .OBJ

3 Linker Executable C Compiler .EXE
Code

4 Runner Executable C Compiler .EXE

Code

Writing and Editing Programs

The software used to write programs is known as a text editor. A text editor helps us enter, change and
store character data. Once we write the program in the text editor we save it using a filename stored
with an extension of .C. This file is referred as source code file.

CSE, MAIT
Compiling Programs
The code in a source file stored on the disk must be translated into machine language. This is the job
of the compiler. The Compiler is a computer program that translates the source code written in a high-
level language into the corresponding object code of the low-level language. This translation process
is called compilation. The entire high level program is converted into the executable machine code
file. The Compiler which executes C programs is called as C Compiler. Example Turbo C, Borland C,
GC etc.,
The C Compiler is actually two separate programs:
 The Preprocessor
 The Translator
The Preprocessor reads the source code and prepares it for the translator. While preparing the code, it
scans for special instructions known as preprocessor commands. These commands tell the
preprocessor to look for special code libraries. The result of preprocessing is called the translation
unit.
After the preprocessor has prepared the code for compilation, the translator does the actual work of
converting the program into machine language. The translator reads the translation unit and writes the
resulting object module to a file that can then be combined with other precompiled units to form the
final program. An object module is the code in the machine language.

Linking Programs
The Linker assembles all functions, the program‘s functions and system‘s functions into one
executable program.

Executing Programs
To execute a program we use an operating system command, such as run, to load the program into
primary memory and execute it. Getting the program into memory is the function of an operating
system program known as the loader. It locates the executable program and reads it into memory.
When everything is loaded the program takes control and it begin execution.

ALGORITHM
Algorithm is a finite sequence of instructions, each of which has a clear meaning and can be
performed with a finite amount of effort in a finite length of time. No matter what the input values
may be, an algorithm terminates after executing a finite number of instructions.
We represent an algorithm using a pseudo language that is a combination of the constructs of a
programming language together with informal English statements.
The ordered set of instructions required to solve a problem is known as an algorithm. The

CSE, MAIT
characteristics of a good algorithm are:
Precision – the steps are precisely stated (defined).
Uniqueness – results of each step are uniquely defined and only depend on the input and the result of
the preceding steps.
Finiteness – the algorithm stops after a finite number of instructions are executed.
Input – the algorithm receives input.
Output – the algorithm produces output.
Generality – the algorithm applies to a set of inputs.
Example
Q. Write a algorithm to find out number is odd or even?
Ans.
step 1 : start
step 2 : input number
step 3 : rem=number mod 2
step 4 : if rem=0 then print "number even"
else print "number odd"
end if
step 5 :stop

PSEUDO CODE:

The pseudo code in C consists of words and phrases that make pseudo code looks similar to the
program but not a program. Pseudo codes are written with respect to a programming language, but
programming language syntax or grammar is not strictly followed.

The pseudo-code notation specifies operations that a machine can perform in as human-friendly (e.g.,
easy to read) way as possible while avoiding ambiguity.

Pseudo code allows the designer to focus on the logic of the algorithm without being distracted by
details of language syntax.

Pseudo code describes the entire logic of the algorithm so that the implementation becomes a mere
mechanical task of translating line by line into source code.

Pseudo code is a generic way of describing an algorithm without using any specific programming
language-related notations.

CSE, MAIT
FLOWCHART
Flowchart is a diagrammatic representation of an algorithm. Flowchart is very helpful in writing
program and explaining program to others.
Symbols Used In Flowchart
Different symbols are used for different states in flowchart, For example: Input/Output and decision
making has different symbols. The table below describes all the symbols that are used in making
flowchart

Symbol Purpose Description

Used to indicate the flow of logic by connecting symbols.

Flow line

Terminal(Stop/Start) Used to represent start and end of flowchart.

Input/Output Used for input and output operation.

Used for airthmetic operations and data- manipulations.

Processing

CSE, MAIT
 Used to represent the operation in which there are two
Desicion alternatives, true and false.

On-page Connector Used to join different flowline

Off-page Connector Used to connect flowchart portion on different page.

Predefined Process/Function Used to represent a group of statements performing one

processing task.

Examples of flowcharts in programming

Draw a flowchart to add two numbers entered by user.

Draw flowchart to find the largest among three different numbers entered by user.

CSE, MAIT
INTRODUCTION TO C LANGUAGE
C is a general-purpose high level language that was originally developed by Dennis Ritchie for the
Unix operating system. It was first implemented on the Digital Equipment Corporation PDP-11
computer in 1972.
The Unix operating system and virtually all Unix applications are written in the C language. C has
now become a widely used professional language for various reasons.
 Easy to learn
 Structured language
 It produces efficient programs.
 It can handle low-level activities.
 It can be compiled on a variety of computers.
Facts about C
 C was invented to write an operating system called UNIX.
 C is a successor of B language which was introduced around1970
 The language was formalized in 1988 by the American National Standard Institue (ANSI).
 By 1973 UNIX OS almost totally written in C.
 Today C is the most widely used System Programming Language.
 Most of the state of the art software have been implemented using C
Why to use C?
C was initially used for system development work, in particular the programs that make-up the
operating system. C was adoped as a system development language because it produces code that runs
nearly as fast as code written in assembly language. Some examples of the use of C might be:
 Operating Systems
 Language Compilers
 Assemblers
 Text Editors
 Print Spoolers
 Network Drivers
 Modern Programs
 Data Bases
 Language Interpreters
 Utilities C Program File

All the C programs are written into text files with extension ".c" for example hello.c. You can use "vi"
editor to write your C program into a file.

CSE, MAIT
HISTORY TO C LANGUAGE
C is a general-purpose language which has been closely associated with the UNIX operating system
for which it was developed - since the system and most of the programs that run it are written in C.
Many of the important ideas of C stem from the language BCPL, developed by Martin Richards. The
influence of BCPL on C proceeded indirectly through the language B, which was written by Ken
Thompson in 1970 at Bell Labs, for the first UNIX system on a DECPDP-
BCPL and B are "type less" languages whereas C provides a variety of data types.
In 1972 Dennis Ritchie at Bell Labs writes C and in 1978 the publication of The C Programming
Language by Kernighan & Ritchie caused a revolution in the computing world.
In 1983, the American National Standards Institute (ANSI) established a committee to provide a
modern, comprehensive definition of C. The resulting definition, the ANSI standard, or "ANSI C",
was completed late 1988.

BASIC STRUCTURE OF C PROGRAMMING

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 such as using the #include directive.
Definition section: The definition section defines all symbolic constants such using the #define
directive.
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

CSE, MAIT
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: If the program is a multi-function program then 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.

PROCESS OF COMPILING AND RUNNING C PROGRAM

We will briefly highlight key features of the C Compilation model here.

The C Compilation Model

The Preprocessor
The Preprocessor accepts source code as input and is responsible for
Removing comments
Interpreting special preprocessor directives denoted by #.
Forexample
#include -- includes contents of a named file. Files usually called header files. e.g
#include <math.h> -- standard library maths file.
#include <stdio.h> -- standard library I/O file
#define -- defines a symbolic name or constant. Macro substitution.
#define MAX_ARRAY_SIZE100
C Compiler
The C compiler translates source to assembly code. The source code is received from the
preprocessor.

CSE, MAIT
Assembler
The assembler creates object code. On a UNIX system you may see files with a .o suffix (.OBJ on
MSDOS) to indicate object code files.
Link Editor
If a source file references library functions or functions defined in other source files the link editor
combines these functions (with main ()) to create an executable file.
C TOKENS
C tokens are the basic buildings blocks in C language which are constructed together to write a C
program.
Each and every smallest individual unit in a C program is known as C tokens.
C tokens are of six types. They are
Keywords (eg: int, while),
Identifiers (eg: main, total),
Constants (eg: 10, 20),
Strings (eg: “total”, “hello”),
Special symbols (eg: (), {}),
Operators (eg: +, /,-,*)

C KEYWORDS

C keywords are the words that convey a special meaning to the c compiler. The keywords cannot be
used as variable names.
The list of C keywords is given below:

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

CSE, MAIT
C IDENTIFIERS
Identifiers are used as the general terminology for the names of variables, functions and arrays. These
are user defined names consisting of arbitrarily long sequence of letters and digits with either a letter
or the underscore (_) as a first character.
There are certain rules that should be followed while naming c identifiers: They must begin with a
letter or underscore (_).
They must consist of only letters, digits, or underscore. No other special character is allowed. It
should not be a keyword.
It must not contain whitespace.
It should be up to 31 characters long as only first 31 characters are significant. Some examples of c
identifiers:
Name Remark
_A9 Valid
Temp.var Invalid as it contains special character other than the underscore
void Invalid as it is a keyword

C CONSTANTS
A C constant refers to the data items that do not change their value during the program execution.
Several types of C constants that are allowed in C are:
Integer Constants
Integer constants are whole numbers without any fractional part. It must have at least one digit and
may contain either + or – sign. A number with no sign is assumed to be positive.
There are three types of integer constants:
Decimal Integer Constants
Integer constants consisting of a set of digits, 0 through 9, preceded by an optional – or + sign.
Example of valid decimal integer constants
341, -341, 0,8972
Octal Integer Constants
Integer constants consisting of sequence of digits from the set 0 through 7 starting with 0 is said to be
octal integer constants.
Example of valid octal integer constants 010, 0424, 0,0540
Hexadecimal Integer Constants
Hexadecimal integer constants are integer constants having sequence of digits preceded by 0x or 0X.
They may also include alphabets from A to F representing numbers 10 to 15.
Example of valid hexadecimal integer constants 0xD, 0X8d, 0X, 0xbD
It should be noted that, octal and hexadecimal integer constants are rarely used in programming.

CSE, MAIT
Real Constants
The numbers having fractional parts are called real or floating point constants. These may be
represented in one of the two forms called fractional form or the exponent form and may also have
either + or – sign preceding it.
Example of valid real constants in fractional form or decimal notation 0.05, -0.905, 562.05, 0.015
Representing a real constant in exponent form
The general format in which a real number may be represented in exponential or scientific form is
mantissa e exponent
The mantissa must be either an integer or a real number expressed in decimal notation.
The letter e separating the mantissa and the exponent can also be written in uppercase i.e. E And, the
exponent must be an integer.
Examples of valid real constants in exponent form are:
252E85, 0.15E-10,-3e+8
Character Constants
A character constant contains one single character enclosed within single quotes. Examples of valid
character constants
‘A’ , ‘Z’, ‘5’
It should be noted that character constants have numerical values known as ASCII values, for
example, the value of ‘A’ is 65 which is its ASCII value.
Escape Characters/ Escape Sequences
C allows us to have certain non graphic characters in character constants. Non graphic characters are
those characters that cannot be typed directly from keyboard, for example, tabs, carriage return, etc.
These non graphic characters can be represented by using escape sequences represented by a
backslash (\) followed by one or more characters.
NOTE: An escape sequence consumes only one byte of space as it represents a single character.

Escape Sequence Description

a Audible alert(bell)
b Backspace
f Form feed
n New line
r Carriage return
t Horizontal tab
v Vertical tab
\ Backslash

CSE, MAIT
 ‘’ Double quotation mark
“” Single quotation mark
? Question mark
Null

STRING CONSTANTS
String constants are sequence of characters enclosed within double quotes. For example,
“hello”
“abc”
“hello911”
Every sting constant is automatically terminated with a special character, called the null character
which represents the end of the string.
For example, “hello” will represent “hello” in the memory.
Thus, the size of the string is the total number of characters plus one for the null character.

SPECIAL SYMBOLS
The following special symbols are used in C having some special meaning and thus, cannot be used
for some other purpose.
[] () {} , ; : * … = #
Braces{}: These opening and ending curly braces marks the start and end of a block of code
containing more than one executable statement.
Parentheses(): These special symbols are used to indicate function calls and function parameters.
Brackets[]: Opening and closing brackets are used as array element reference. These indicate single
and multidimensional subscripts.

VARIABLES
A variable is nothing but a name given to a storage area that our programs can manipulate. Each
variable in C has a specific type, which determines the size and layout of the variable's memory; the
range of values that can be stored within that memory; and the set of operations that can be applied to
the variable.

The name of a variable can be composed of letters, digits, and the underscore character. It must begin
with either a letter or an underscore. Upper and lowercase letters are distinct because C is case-
sensitive. Based on the basic types explained in the previous chapter, there will be the following basic
variable types –

CSE, MAIT
DATA TYPE:

Type Description

Char Typically a single octet (one byte). This is an integer type.

Int The most natural size of integer for the machine.

Float A single-precision floating point value.

Double A double-precision floating point value.

Void Represents the absence of type.

C programming language also allows defining various other types of variables like Enumeration,
Pointer, Array, Structure, Union,etc.

Variable Definition in C
A variable definition tells the compiler where and how much storage to create for the variable. A
variable definition specifies a data type and contains a list of one or more variables of that type as
follows−

type variable_list;

Here, type must be a valid C data type including char, w_char, int, float, double, bool, or any user-
defined object; and variable_list may consist of one or more identifier names separated by commas.
Some valid declarations are shown here −

int i, j, k;
char c, ch;
float f, salary;
double d;

The line int i, j, k; declares and defines the variables i, j, and k; which instruct the compiler to create
variables named i, j and k of type int.

Variables can be initialized (assigned an initial value) in their declaration. The initializer consists of
an equal sign followed by a constant expression as follows−

CSE, MAIT
type variable_name = value;

Some examples are −

extern int d = 3, f=5; // declaration of d and f.

int d = 3, f=5; // definition and initializing d and f.
byte z=22; // definition and initializesz.
char x= 'x'; // the variable x has the value'x'.

For definition without an initializer: variables with static storage duration are implicitly initialized
with NULL (all bytes have the value 0); the initial value of all other variables are undefined.

Variable Declaration in C
A variable declaration provides assurance to the compiler that there exists a variable with the given
type and name so that the compiler can proceed for further compilation without requiring the
complete detail about the variable. A variable definition has its meaning at the time of compilation
only; the compiler needs actual variable definition at the time of linking the program. A variable
declaration is useful when multiple files are used.

OPERATORS AND EXPRESSIONS

C language offers many types of operators. They are,

1. Arithmetic operators
2. Assignment operators
3. Relational operators
4. Logica loperators
5. Bit wise operators
6. Conditional operators (ternary operators)
7. Increment/decrement operators
8. Special operators

CSE, MAIT
S.no Types of Operators Description

These are used to perform mathematical calculations like

addition, subtraction, multiplication, division and
modulus
1 Arithmetic_operators

These are used to assign the values for the variables in C

2 Assignment_operators programs.

These operators are used to compare the value of two

3 Relational operators variables.

4 Logical operators These operators are used to perform logical operations on

the given two variables.

These operators are used to perform bit operations on given

5 Bit wise operators two variables.

Conditional operators return one value if condition is true and

Conditional (ternary) operators
6 returns another value is condition is false.

These operators are used to either increase or decrease the

Increment/decrement operators
7 value of the variable by one.

8 Special operators &, *, size of( ) and ternary operators.

CSE, MAIT
ARITHMETIC OPERATORS IN C

C Arithmetic operators are used to perform mathematical calculations like addition,

subtraction, multiplication, division and modulus in C programs.

Arithmetic
S.no Operators Operation Example

1 + Addition A+B

2 – Subtraction A-B

3 * multiplication A*B

4 / Division A/B

5 % Modulus A%B

EXAMPLE PROGRAM FOR C ARITHMETIC OPERATORS

In this example program, two values 40 and 20 are used to perform arithmetic operations such as
addition, subtraction, multiplication, division, modulus and output is displayed for each
operation.
#include <stdio.h>
int main()
{

int a=40,b=20, add, sub, mul, div, mod;

add =a+b;
sub = a-b;
mul = a*b;
div = a/b;
mod = a%b;
printf("Addition of a, b is : %d\n", add);

CSE, MAIT
 printf("Subtraction of a, b is : %d\n", sub);
printf("Multiplication of a, b is : %d\n", mul);
printf("Division of a, b is : %d\n", div);
printf("Modulus of a, b is : %d\n", mod);
}

OUTPUT:

Addition of a, b is : 60
Subtraction of a, b is : 20
Multiplication of a, b is : 800
Division of a, b is : 2
Modulus of a, b is : 0

ASSIGNMENT OPERATORS IN C
In C programs, values for the variables are assigned using assignment operators.
For example, if the value 10 is to be assigned for the variable sum, it can be assigned as
sum= 10

Other assignment operators in C language are given below.

CSE, MAIT
 Operators Example Explanation

Simple
assignment 10 is assigned to
operator = sum = 10 variable sum

sum += This is same as

+= 10 sum = sum + 10

This is same as
-= sum -= 10 sum = sum – 10

sum *= This is same as

*= 10 sum = sum * 10

This is same as
/+ sum /= 10 sum = sum / 10

This is same as
sum %= sum = sum % 10
%= 10
Compound
assignment
operators This is same as
sum = sum & 10
&= sum&=10

sum ^= This is same as

^= 10 sum = sum ^ 10

EXAMPLE PROGRAM FOR C ASSIGNMENT OPERATORS:

In this program, values from 0 – 9 are summed up and total 45 is displayed as output.
Assignment operators such as―= and ―+= are used in this program to assign the values and
to sum up the values.

CSE, MAIT
 # include <stdio.h>
int main()
{
int Total=0, i;
for(i=0; i<10; i++)
{
Total+=i; // This is same as Total = Toatal+i
}
printf("Total = %d", Total);
}

OUTPUT:

Total = 45

RELATIONAL OPERATORS IN C
Relational operators are used to find the relation between two variables. i.e. to compare the
values of two variables in a C program.

S.no Operators Example Description

x is greater than y
1 > x>y

2 < x<y x is less than y

x is greater than
3 >= x >= y
or equal to y
x is less than or
4 <= x <= y
equal to y
5 == x==y x is equal to y

x is not equal to
6 != x != y
y

EXAMPLE PROGRAM FOR RELATIONAL OPERATORS IN C

In this program, relational operator (= =) is used to compare 2 values whether they are equal are not.
If both values are equal, output is displayed as values are equal. Else, output is displayed as values are
not equal.

CSE, MAIT
Note: double equal sign (= =) should be used to compare 2 values. We should not single equal
sign(=).
#include<stdio.h>
int main()
{
int m=40,n=20;
if (m = = n)
{
printf("m and n are equal");
}

else

printf("m and n are not equal");

OUTPUT:

m and n are not equal

LOGICAL OPERATORS IN C

These operators are used to perform logical operations on the given expressions.
There are 3 logical operators in C language.
 logical AND (&&),
 logical OR (||) and
 logical NOT (!).

CSE, MAIT
 S.no Operators Name Example Description

It returns true
when both
logical
conditions
1 && AND (x>5)&&(y<5) aretrue

It returns true
when at-least
one of the
logical condition is
2 || OR (x>=10)||(y>=10) true

It reverses the
state of the
operand
―((x>5)&&
(y<5))‖

If―((x>5)
&& (y<5))‖ is
true, logical
logical NOT operator
3 ! NOT !((x>5)&&(y<5)) makes itfalse

EXAMPLE PROGRAM FOR LOGICAL OPERATORS IN C:

In this program, operators (&&, || and !) are used to perform logical operations on the given
expressions.
#include <stdio.h>
int main()
{
int m=40,n=20;
int o=20,p=30;
if (m>n && m !=0)
{
printf("&& Operator : Both conditions are true\n");
}

CSE, MAIT
if (o>p || p!=20)
{
printf("|| Operator : Only one condition is true\n");
}
if (!(m>n && m !=0))
{
printf("! Operator : Both conditions are true\n");
}
else
{
printf("! Operator : Both conditions are true. But, status is inverted as false\n");
}
}

OUTPUT:

&& Operator : Both conditions are true

|| Operator : Only one condition is true
! Operator : Both conditions are true. But, status is inverted as false

CSE, MAIT
&& operator – ―if clause becomes true only when both conditions (m>n and m! =0) is true. Else, it
becomes false.
||Operator – if clause becomes true when any one of the condition (o>p || p!=20) is true. It becomes false
when none of the condition is true.
! Operator – It is used to reverses the state of the operand.
If the conditions (m>n && m!=0) is true, true (1) is returned. This value is inverted by ! operator.
So, ! (m>n and m!=0) returns false(0).

BIT WISE OPERATORS IN C

These operators are used to perform bit operations. Decimal values are converted into binary values which
are the sequence of bits and bit wise operators work on these bits.
Bit wise operators in C language are & (bitwise AND), | (bitwise OR), ~ (bitwise NOT), ^ (XOR),
<< (left shift) and >> (right shift).

TRUTH TABLE FOR BIT WISE OPERATION BIT WISE OPERATORS

x x
& ^
Operator_symbol Operator_name
x y x|y y y

0 0 0 0 0 & Bitwise_AND

0 1 1 0 1 | Bitwise OR

1 0 1 0 1 ~ Bitwise_NOT

1 1 1 1 0 ^ XOR

<< Left Shift

>> Right Shift

Consider x=40 and y=80. Binary form of these values are given below. x =00101000
y= 01010000

CSE, MAIT
All bit wise operations for x and y are given below.
x&y = 00000000 (binary) = 0 (decimal)
x|y = 01111000 (binary) = 120 (decimal)
~x = 11111111111111111111111111 11111111111111111111111111111111010111
.. ..= -41 (decimal)
x^y = 01111000 (binary) = 120 (decimal)
x << 1 = 01010000 (binary) = 80(decimal)
x >> 1 = 00010100 (binary) = 20(decimal)

Note:
Bit wise NOT : Value of 40 in binary is
0000000000000000000000000000000000000000000000000000000000101000. So, all 0‘s are
converted into 1‘s in bit wise NOT operation.
Bit wise left shift and right shift: In left shift operation x << 1 , 1 means that the bits will be left
shifted by one place. If we use it as x << 2 , then, it means that the bits will be left shifted by 2 places.

EXAMPLE PROGRAM FOR BIT WISE OPERATORS IN C

In this example program, bit wise operations are performed as shown above and output is displayed in
decimal format.
#include <stdio.h>
int main()
{
int m = 40, n = 80, AND_opr, OR_opr, XOR_opr, NOT_opr ;
AND_opr = (m&n);
OR_opr = (m|n);
NOT_opr = (~m);
XOR_opr = (m^n);
printf("AND_opr value = %d\n",AND_opr );
printf("OR_opr value = %d\n",OR_opr );
printf("NOT_opr value = %d\n",NOT_opr );
printf("XOR_opr value = %d\n",XOR_opr );
printf("left_shift value = %d\n", m << 1);
printf("right_shift value = %d\n", m >> 1);
}

CSE, MAIT
OUTPUT:

AND_opr value = 0
OR_opr value = 120
NOT_opr value = -41
XOR_opr value = 120
left_shift value = 80
right_shift value = 20

CONDITIONAL OR TERNARY OPERATORS IN C

Conditional operators return one value if condition is true and returns another value is condition
is false.
This operator is also called as ternary operator.
Syntax : (Condition? true_value:false_value);

Example : (A > 100 ? 0 :1);

In above example, if A is greater than 100, 0 is returned else 1 is returned. This is equal to if else
conditional statements.

EXAMPLE PROGRAM FOR CONDITIONAL/TERNARY OPERATORS IN C

#include <stdio.h>
int main()
{
int x=1, y;
y = ( x = =1 ? 2 : 0 ) ;
printf("x value is %d\n", x);
printf("y value is %d", y);
}

OUTPUT:

x value is 1
y value is 2

C – Increment/decrement Operators PREVNEXT

Increment operators are used to increase the value of the variable by one and decrement operators are
used to decrease the value of the variable by one in C programs.

CSE, MAIT
Syntax:
Increment operator: ++var_name ;( or) var_name++ ;
Decrement operator: --var_name; (or) var_name - - ;
Example:
Increment operator : ++i; i ++ ;
Decrement operator : – – i ; i––;
EXAMPLE PROGRAM FOR INCREMENT OPERATORS IN C
In this program, value of ―i is incremented one by one from 1 up to 9 using ―i++ operator and output is
displayed as 1 2 3 4 5 6 7 8 9.
//Example for increment operators

#include <stdio.h>
int main()
{
int i=1; while(i<10)
{
printf("%d ",i); i++;
}
}

OUTPUT:

123456789

EXAMPLE PROGRAM FOR DECREMENT OPERATORS IN C

In this program, value of ‘i’ is decremented one by one from 20 up to 11 using i-- operator and
output is displayed as 20 19 18 17 16 15 14 13 12 11.

//Example for decrement operators

#include <stdio.h>
int main()
{
int i=20; while(i>10)
{
printf("%d ",i); i--;
}
}

CSE, MAIT
OUTPUT:

20 19 18 17 16 15 14 13 12 11

DIFFERENCE BETWEEN PRE/POST INCREMENT & DECREMENT OPERATORS IN C

Below table will explain the difference between pre/post increment and decrement operators in C.

S.no Operator type Operator Description

1 Pre increment
++i Value of i is incremented
before assigning it to variable
i.
Value of i is incremented
after assigning it to
i++
variable i.
2 Post–increment

Value of i is decremented
before assigning it to
— –i
variable i.
3 Pre decrement

Value of i is decremented
after assigning it to
i– —
variable i.
4 Post_decrement

EXAMPLE PROGRAM FOR PRE – INCREMENT OPERATORS IN C

//Example for increment operators #include <stdio.h>
int main()
{
int i=0; while(++i < 5 )
{
printf("%d ",i);
}
return 0;

CSE, MAIT
}

CSE, MAIT
 OUTPUT:
1234

Step 1 : In above program, value of i is incremented from 0 to 1 using pre-increment operator.

Step2:This incremented value 1 iscompared with 5 in while expression.
Step 3 : Then, this incremented value 1 is assigned to the variable i.
Above 3 steps are continued until while expression becomes false and output is displayed as
1 2 3 4.

EXAMPLE PROGRAM FOR POST – INCREMENT OPERATORS IN C

#include <stdio.h>
int main()
{
int i=0; while(i++ < 5 )
{
printf("%d ",i);
}
return 0;
}

OUTPUT:
12345

Step 1 : In this program, value of i =0 is compared with 5 in while expression.

Step 2 : Then, value of i is incremented from 0 to 1 using post-increment operator.
Step 3 : Then, this incremented value 1 is assigned to the variable i.
Above 3 steps are continued until while expression becomes false and output is displayed as
1 2 3 4 5.

CSE, MAIT
 EXAMPLE PROGRAM FOR PRE – DECREMENT OPERATORS IN C

#include <stdio.h>
int main()
{
int i=10; while(--i > 5 )
{
printf("%d ",i);
}
return 0;
}

OUTPUT:
9876

Step 1 : In above program, value of i is decremented from 10 to 9 using pre-decrement operator.

Step2:This decremented value 9 is compared with 5 in while expression.
Step 3 : Then, this decremented value 9 is assigned to the variable i.
Above 3 steps are continued until while expression becomes false and output is displayed as
9 8 7 6.

EXAMPLE PROGRAM FOR POST – DECREMENT OPERATORS IN C:

#include <stdio.h>
int main()
{
int i=10; while(i-- > 5 )
{printf("%d ",i);
}

return 0;

CSE, MAIT
OUTPUT:
98765

Step 1 : In this program, value of i 10 is compared with 5 in while expression.

Step 2 : Then, value of i is decremented from 10 to9 using post-decrement operator.
Step 3 : Then, this decremented value 9 is assigned to the variable i.
Above 3 steps are continued until while expression becomes false and output is displayed as
9 8 7 6 5.

SPECIAL OPERATORS IN C:

Below are some of special operators that C language offers.

S.no Operators Description

This is used to get the address of

the variable.

Example : &a will give address of

1 & a.

This is used as pointer to a variable.

Example : * a where, * is
pointer to the variablea.
2 *

This gives the size of the variable.

Example : size of (char) will give

us 1.
3 Sizeof ()

CSE, MAIT
 EXAMPLE PROGRAM FOR & AND * OPERATORS IN C
In this program, & symbol is used to get the address of the variable and * symbol is used to
get the value of the variable that the pointer is pointing to. Please refer C –pointer topic
to know more about pointers.
#include <stdio.h>
int main()
{
int *ptr, q; q = 50;
/* address of q is assigned to ptr */ ptr = &q;
/* display q's value using ptr variable */ printf("%d", *ptr);
return 0;
}

OUTPUT:

50

EXAMPLE PROGRAM FOR SIZE OF () OPERATOR IN C

Size of () operator is used to find the memory space allocated for each C data types.
#include <stdio.h>
#include <limits.h>
int main()
{
int a;
char b;
float c;
double d;
printf("Storage size for int data type:%d \n",sizeof(a));
printf("Storage size for char data type:%d \n",sizeof(b));
printf("Storage size for float data type:%d \n",sizeof(c));
printf("Storage size for double datatype:%d\n",sizeof(d));
return0;
}

CSE, MAIT
 OUTPUT:

Storage size for int data type:4

Storage size for char data type:1
Storage size for float data type:4
Storage size for double data type:8

EXPRESSIONS
Arithmetic expression in C is a combination of variables, constants and operators written in a proper
syntax. C can easily handle any complex mathematical expressions but these mathematical
expressions have to be written in a proper syntax. Some examples of mathematical expressions
written in proper syntax of C are
Note: C does not have any operator for exponentiation.

C OPERATOR PRECEDENCE AND ASSOCIATIVITY

C operators in order of precedence (highest to lowest). Their associativity indicates in what order
operators of equal precedence in an expression are applied.
Operator Description Associativity
() Parentheses (function call) (see Note 1) left-to-right
[] Brackets (array subscript)
. Member selection operator
-> Arrow operator
++, -- Postfix increment/decrement (see Note 2)
++ ,-- Prefix increment/decrement right-to-left
+, - Unary plus/minus
!~ Logical negation/bitwise complement
(type) Cast (convert value to temporary value of type)
* Dereference
& Address (of operand)
sizeof Determine size in bytes on this implementation
* ,/, % Multiplication/division/modulus left-to-right
+- Addition/subtraction left-to-right
<<,>> Bitwise shift left, Bitwise shift right left-to-right
<,<= Relational less than/less than or equal to left-to-right
>,>= Relational greater than/greater than or equal to

CSE, MAIT
 = =,!= Relational is equal to/is not equal to left-to-right
& Bitwise AND left-to-right
^ Bitwise exclusive OR left-to-right
| Bitwise inclusive OR left-to-right
&& Logical AND left-to-right
|| Logical OR left-to-right
?: Ternary conditional right-to-left
= Assignment right-to-left
+=,-= Addition/subtraction assignment
*=,/= Multiplication/division assignment
%=,&= Modulus/bitwise AND assignment
^= ,|= Bitwise exclusive/inclusive OR assignment
<<=,>>= Bitwise shift left/right assignment
, Comma (separate expressions) left-to-right
Note1:
Parentheses are also used to group sub-expressions to force a different
precedence; such parenthetical expressions can be nested and are evaluated
Note2: from inner to outer.

Postfix increment/decrement have high precedence, but the actual increment or

decrement of the operand is delayed (to be accomplished sometime before the
statement completes execution). So in the statement y = x * z++; the current
value of z is used to evaluate the expression (i.e., z++ evaluates to z) and z only
incremented after all else is done.

EVALUATION OF EXPRESSION
At first, the expressions within parenthesis are evaluated. If no parenthesis is present, then the
arithmetic expression is evaluated from left to right. There are two priority levels of operators in C.
High priority: * /%
Low priority: + -
The evaluation procedure of an arithmetic expression includes two left to right passes through the
entire expression. In the first pass, the high priority operators are applied as they are encountered and
in the second pass, low priority operations are applied as they are encountered. Suppose, we have an
arithmetic expression as:
x = 9 – 12 / 3 + 3 *2 -1
This expression is evaluated in two left to right passes as:

CSE, MAIT
First Pass

Step 1: x = 9-4 + 3 * 2 – 1
Step 2: x = 9 – 4 + 6 – 1
Second Pass
Step 1: x = 5 + 6 – 1
Step 2: x = 11 – 1
Step 3: x = 10

But when parenthesis is used in the same expression, the order of evaluation gets changed.
For example,
x = 9 – 12 / (3 + 3) * (2 –1)
When parentheses are present then the expression inside the parenthesis are evaluated first from left to
right. The expression is now evaluated in three passes as:
First Pass

Step 1: x = 9 – 12 / 6 * (2 – 1)
Step 2: x= 9 – 12 / 6 * 1

Second Pass

Step 1: x= 9 – 2 * 1
Step 2: x = 9 – 2

Third Pass
Step 3:x=7 There may even arise a case where nested parentheses are present (i.e. parenthesis
inside parenthesis). In such case, the expression inside the innermost set of parentheses isevaluated
first and then the outer parentheses are evaluated. For example, we have an expression as:
x = 9 – ((12 / 3) + 3 * 2) –1
The expression is now evaluated as:
First Pass:

Step 1: x = 9 – (4 + 3 * 2) – 1
Step 2: x= 9 – (4 + 6) – 1
Step 3: x= 9 – 10 -1

Second Pass

Step 1: x= - 1 – 1
Step 2: x = -2
CSE, MAIT
Note: The number of evaluation steps is equal to the number of operators in the arithmetic
expression.

TYPE CONVERSION IN EXPRESSIONS

When variables and constants of different types are combined in an expression then they are
converted to same data type. The process of converting one predefined type into another is called type
conversion.
Type conversion in c can be classified into the following two types:
Implicit Type Conversion
When the type conversion is performed automatically by the compiler without programmer‘s
intervention, such type of conversion is known as implicit type conversion or type promotion. The
compiler converts all operands into the data type of the largest operand.
The sequence of rules that are applied while evaluating expressions are given below: All short and
char are automatically converted to int, then,
If either of the operand is of type long double, then others will be converted to long double and result
will be long double.
Else, if either of the operand is double, then others are converted to double.
Else, if either of the operand is float, then others are converted to float.
Else, if either of the operand is unsigned long int, then others will be converted to unsigned long int.
Else, if one of the operand is long int, and the other is unsigned int, then
if a long int can represent all values of an unsigned int, the unsigned int is converted to long int.
otherwise, both operands are converted to unsigned long int.
Else, if either operand is long int then other will be converted to long int.
Else, if either operand is unsigned int then others will be converted to unsigned int.
It should be noted that the final result of expression is converted to type of variable on left side of
assignment operator before assigning value to it.
Also, conversion of float to int causes truncation of fractional part, conversion of double to float
causes rounding of digits and the conversion of long int to int causes dropping of excess higher order
bits.

Explicit Type Conversion

The type conversion performed by the programmer by posing the data type of the expression of
specific type is known as explicit type conversion.
The explicit type conversion is also known as type casting. Type casting in c is done in the following
form: (data_type)expression;
where, data_type is any valid c data type, and expression may be constant, variable or expression.
For example, x=(int)a+b*d;

CSE, MAIT
The following rules have to be followed while converting the expression from one type to another to
avoid the loss of information:
All integer types to be converted to float. All float types to be converted to double.
All character types to be converted to integer.

FORMATTED INPUT AND OUTPUT

The C Programming Language is also called the Mother of languages. The C language was developed
by Dennis Ritchie between 1969 and 1973 and is a second and third generation of languages. The C
language provides both low and high level features it provides both the power of low-level languages
and the flexibility and simplicity of high-level languages.
C provides standard functions scanf () and printf (), for performing formatted input and output. These
functions accept, as parameters, a format specification string and a list of variables.
The format specification string is a character string that specifies the data type of each variable to be
input or output and the size or width of the input and output.
Now to discuss formatted output in functions.
Formatted Output
The function printf () is used for formatted output to standard output based on a format specification.
The format specification string, along with the data to be output, are the parameters to the printf()
function.
Syntax:
printf (format,data1,data2,… );
In this syntax format is the format specification string. This string contains, for each variable to be
output, a specification beginning with the symbol % followed by a character called the conversion
character.
Example:
printf (“%”, data1);
The character specified after % is called a conversion character because it allows one data type to be
converted to another type and printed.
See the following table conversion character and their meanings.

Conversion Meaning
Character

d The data is converted to decimal (integer)

c The data is taken as a character.

CSE, MAIT
 s The data is a string and character from the string , are printed until a NULL,
character is reached.

f The data is output as float or double with a default Precision 6.

Symbols Meaning
\n For new line (linefeed return)
\t For tab space (equivalent of 8 spaces)
Example
printf (“%c\n”,data1);
The format specification string may also have text.
Example
printf (“Character is:%c\n”, data1);
The text "Character is:" is printed out along with the value of data1.
Example with program
#include<stdio.h>
#include<conio.h>
Main()
{
Char alphabh= ‘A’;
int number1= 55;
float number2=22.34;
printf(“char= %c\n”,alphabh);
printf”(int= %d\n”,number1);
printf(“float= %f\n”,number2);
getch();
clrscr();
retrun 0;
}
Output Here…
char =A
int= 55
float=22.340000
What is the output of the statement?
printf(“Integer is: %d Alphabet is:%c\n”,number1, alpha);
Where number1 contains 44 and alpha contains "Krishna Singh".
Give the answer below.
Between the character % and the conversion character, there may be:

CSE, MAIT
A minus sign: Denoting left adjustment of the data.
A digit: Specifying the minimum width in which the data is to be output, if the data hasa larger
number of characters then the specified width occupied by the output is larger. If the data consists of
fewer characters then the specified width, it is padded to the right or to the left (if minus sign is not
specified) with blanks. If the digit is prefixed with a zero, the padding is done with zeros instead of
blanks.
A period: Separating the width from the nextdigit.
A digit following the period: specifying the precision (number of decimal placesfor numeric data) or
the maximum number of characters to be output.
Letter 1: To indicate that the data item is a long integer and not an int.

Format specification string Data Output

|%2d| 9 |9|

|%2d| 123 |123|

|%03d| 9 |009|

|%-2d| 7 |7|

|%5.3d| 2 |002|

|%3.1d| 15 |15|

|%3.5d| 15 |0015|

|%5s| ―Outputsting‖ |Output string|

|%15s| ―Outputsting‖ |Output string|

|%-15s| ―Outputsting‖ |Output string|

|%15.5s| ―Outputsting‖ |Output string|

|%.5s| ―Outputsting‖ |Output|

|%15.5s| ―Outputsting‖ |Output|

|%f| 87.65 |87.650000|

|%.4.1s| 87.65 |87.71|

Example based on the conversion character:

#include<stdio.h>
#include<conio.h>
main()
{

CSE, MAIT
int num=65;
printf(Value of num is: %d\n:, num);
printf(Character equivalent of %d is%c\n, num , num);
getch();
clrscr();
rerurn 0;
}
OutputHere…
char=A
int= 55
flaot=22.340000
Formatted Input
The function scanf () is used for formatted input from standard input and provides many of the
conversion facilities of the function printf().
Syntax
scanf (format, num1, num2,……);
The function scnaf() reads and converts characters from the standards input depending on the format
specification string and stores the input in memory locations represented by the other arguments
(num1, num2,….).
For Example:
Scanf (“%c %d”,&Name,&Roll No);
Note: the data names are listed as &Name and &Roll No instead of Name and Roll No. respectively.
This is how data names are specified in a scanf () function. In case of string type data names, the data
name is not preceded by the character &.
Example with program
Write a function to accept and display the element number and the weight of a proton. The element
number is an integer and weight is fractional.
Solve here:
#include<stdio.h>
#include<conio.h>
main()
{
inte_num;
Floate_wt;
printf(“Enter the Element No. and Weight of a Proton\n”);
scanf(“%d %f”,&e_num,&e_wt);
printf (“The Element No.is:%d\n”,e_num);

CSE, MAIT
printf(“The Weight of a Proton is:%f\n”,e_wt);
getch();
return 0;
}

CSE, MAIT