1.Overview
C is a general-purpose,
high-level language that was originally developed by Dennis M. Ritchie to
develop the UNIX operating system at Bell Labs. C was originally first
implemented on the DEC PDP-11 computer in 1972.
In 1978, Brian Kernighan and Dennis Ritchie produced the first
publicly available description of C, now known as the K&R standard.
The UNIX operating system, the C compiler, and essentially all
UNIX applications programs have been written in C. The C has now become a
widely used professional language for various reasons.
o Easy to learn
o Structured language
o It produces efficient programs.
o It can handle low-level activities.
o It can be compiled on a variety of computer platforms.
Facts about C
1. C was invented to write an operating system called UNIX.
2. C is a successor of B language which was introduced around 1970
3. The language was formalized in 1988 by the American National
Standard Institute (ANSI).
4. The UNIX OS was totally written in C by 1973.
5. Today C is the most widely used and popular System Programming
Language.
6. Most of the state-of-the-art software have been implemented using
C.
7. Today's most popular Linux OS and RBDMS MySQL have been written in
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 adopted 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
o Operating Systems
o Language Compilers
o Assemblers
o Text Editors
o Print Spoolers
o Network Drivers
o Modern Programs
o Databases
o Language Interpreters
o Utilities
2. ENVIORNMENT SETUP
Try it Option Online
You really do not need to set up your own environment to start learning C
programming language. Reason is very simple, we already have set up C
Programming environment online, so that you can compile and execute all the
available examples online at the same time when you are doing your theory work.
This gives you confidence in what you are reading and to check the result with
different options. Feel free to modify any example and execute it online.
Try following example using our online compiler option
available in Coding Area.
#include<stdio.h>
int main()
{
/* my first program in C */
printf("Hello, World! \n");
return 0;
}
For most of the examples given in this
tutorial, you will find the Try it option in our website code
sections at the top right corner that will take you to the online compiler. So
just make use of it and enjoy your learning.
Local Environment Setup
If you want to set up your environment for C programming
language, you need the following two software tools available on your computer,
(a) Text Editor and (b) The C Compiler.
Text Editor
This will be used to
type your program. Examples of a few editors include Windows Notepad, OS Edit
command, Brief, Epsilon, EMACS, and vim or vi.
The name and version of
text editors can vary on different operating systems. For example, Notepad will
be used on Windows, and vim or vi can be used on Windows as well as on Linux or
UNIX.
The files you create
with your editor are called the source files and they contain the program
source codes. The source files for C programs are typically named with the
extension ".c".
Before starting your
programming, make sure you have one text editor in place and you have enough
experience to write a computer program, save it in a file, compile it and
finally execute it.
The C Compiler
The source code written in source file is the human readable
source for your program. It needs to be "compiled" into machine
language so that your CPU can actually execute the program as per the
instructions given.
The compiler compiles the source codes into final executable
programs. The most frequently used and free available compiler is the GNU C/C++
compiler, otherwise you can have compilers either from HP or Solaris if you
have the respective operating systems.
The following section
explains how to install GNU C/C++ compiler on various OS. m We keep mentioning
C/C++ together because GNU gcc compiler works for both C and C++ programming
languages.
Installation on Windows
To install GCC on
Windows, you need to install MinGW. To install MinGW, go to the MinGW homepage,
www.mingw.org, and follow the link to the MinGW download page. Download the
latest version of the MinGW installation program, which should be named
MinGW-<version>.exe.
While installing MinGW,
at a minimum, you must install gcc-core, gcc-g++, binutils, and the MinGW
runtime, but you may wish to install more.
Add the bin subdirectory
of your MinGW installation to your PATH environment variable, so that you can
specify these tools on the command line by their simple names.
After the installation
is complete, you will be able to run gcc, g++, ar, ranlib, dlltool, and several
other GNU tools from the Windows command line
3.
PROGRAM STRUCTURE
Hello World Example
A C program basically
consists of the following parts:
o Preprocessor Commands
o Functions
o Variables
o Statements & Expressions
o Comments
Let
us look at a simple code that would print the words "Hello World":
#include <stdio.h>
int main()
{
/* my first program in C */
printf("Hello, World! \n");
return 0;
}
Let
us take a look at the various parts of the above program:
1. The first line of the program #include <stdio.h> is a
preprocessor command, which tells a C compiler to include stdio.h file before
going to actual compilation.
2. The next line int main() is the main function where the program
execution begins.
3. The next line /*...*/ will be ignored by the compiler and it has
been put to add additional comments in the program. So such lines are called
comments in the program.
Compile and Execute C Program
Let us see how to save the source code in a file, and how to compile
and run it. Following are the simple steps:
1. Open a text editor and add the
above-mentioned code.
2. Save the file as hello.c
3. Open a command prompt and go to the
directory where you have saved the file.
4. Type gcc hello.c and press enter to
compile your code.
5. If there are no errors in your code,
the command prompt will take you to the next line and would generate a.out
executable file.
6. Now, type a.out to execute your
program.
7. You will see the output "Hello
World" printed on the screen.
$ gcc hello.c
$ ./a.out
Hello, World!
Make
sure the gcc compiler is in your path and that you are running it in the
directory containing the source file hello.c.
4. BASIC
SYNTAX
Tokens in C
A C program
consists of various tokens and a token is either a keyword, an identifier, a
constant, a string literal, or a symbol. For example, the following C statement
consists of five tokens:
printf("Hello, World! \n");
The
individual tokens are:
printf
(
"Hello, World! \n"
)
;
Semicolons
In a C program, the semicolon is a statement terminator. That is,
each individual statement must be ended with a semicolon. It indicates the end
of one logical entity.
Given below are two different statements:
printf("Hello, World! \n");
return 0;
Comments
Comments are like helping text in your C program and they are
ignored by the compiler. They start with /* and terminate with the characters
*/ as shown below:
/* my first program in C */
You
cannot have comments within comments and they do not occur within a string or
character literals.
Identifiers
A C identifier is a name used to identify a variable, function, or
any other user-defined item. An identifier starts with a letter A to Z, a to z,
or an underscore ‘_’ followed by zero or more letters, underscores, and digits
(0 to 9).
C does not allow punctuation characters such as @, $, and % within
identifiers. C is a case-sensitive programming language. Thus, Manpower and
manpower are two different identifiers in C. Here are some examples of
acceptable identifiers:
mohd
zara
abc
move_name
a_123
myname50 _temp
j
a23b9
retVal
Keywords
The
following list shows the reserved words in C. These reserved words may not be
used as constants or variables or any other identifier names.
auto
|
else
|
long
|
switch
|
break
|
enum
|
register
|
typedef
|
case
|
extern
|
return
|
union
|
char
|
float
|
short
|
unsigned
|
const
|
for
|
signed
|
void
|
continue
|
goto
|
sizeof
|
volatile
|
default
|
if
|
static
|
while
|
do
|
int
|
struct
|
_Packed
|
double
|
|||
Whitespace
in C
A line
containing only whitespace, possibly with a comment, is known as a blank line,
and a C compiler totally ignores it.
Whitespace
is the term used in C to describe blanks, tabs, newline characters and
comments. Whitespace separates one part of a statement from another and enables
the compiler to identify where one element in a statement, such as int, ends
and the next element begins. Therefore, in the following statement:
int
age;
there
must be at least one whitespace character (usually a space) between int and age
for the compiler to be able to distinguish them. On the other hand, in the
following statement:
fruit =
apples + oranges; // get the total fruit
no
whitespace characters are necessary between fruit and =, or between = and
apples, although you are free to include some if you wish to increase
readability.
5. DATA TYPES
Data types in C refer to
an extensive system used for declaring variables or functions of different
types. The type of a variable determines how much space it occupies in storage
and how the bit pattern stored is interpreted.
The
types in C can be classified as follows:
S.N. Types
and Description
1 Basic Types:
They are arithmetic
types and are further classified into: (a) integer types and (b) floating-point
types.
2 Enumerated
types:
They are again arithmetic types and they are used to define
variables that can only assign certain discrete integer values throughout the
program.
3 The type
void:
The type specifier void indicates
that no value is available.
4 Derived
types:
They include (a) Pointer
types, (b) Array types, (c) Structure types, (d) Union types, and (e) Function
types.
The array types and
structure types are referred collectively as the aggregate types. The type of a
function specifies the type of the function's return value. We will see the
basic types in the following section, whereas other types will be covered in
the upcoming chapters.
Integer Types
The following table
provides the details of standard integer types with their storage sizes and value
ranges:
Type
|
Storage
|
Value range
|
size
|
||
char
|
1 byte
|
-128 to 127 or 0 to 255
|
unsigned
|
1 byte
|
0 to 255
|
char
|
||
signed char
|
1 byte
|
-128 to 127
|
int
|
2 or 4 bytes
|
-32,768
to 32,767 or -2,147,483,648
to
|
2,147,483,647
|
||
unsigned int
|
2 or 4 bytes
|
0 to 65,535 or 0 to
4,294,967,295
|
short
|
2 bytes
|
-32,768 to 32,767
|
unsigned
|
2 bytes
|
0 to 65,535
|
short
|
||
long
|
4 bytes
|
-2,147,483,648 to
2,147,483,647
|
unsigned
|
4 bytes
|
0 to 4,294,967,295
|
long
|
||
To get the exact size of a type or a variable on a particular
platform, you can use the sizeofoperator. The expressions sizeof(type) yields
the storage size of the object or type in bytes. Given below is an example to
get the size of int type on any machine:
#include <stdio.h>
#include <limits.h>
int main()
{
pr intf("Storage size for int : %d \n", sizeof(int));
return 0
}
When you compile and execute the above program, it produces the
following result on Linux:
Storage size for int : 4
Floating-Point Types
The following table provides the details of standard
floating-point types with storage sizes and value ranges and their precision:
Type
|
Storage size
|
Value range
|
Precision
|
float
|
4 byte
|
1.2E-38
to 3.4E+38
|
6
decimal places
|
double
|
8 byte
|
2.3E-308
to 1.7E+308
|
15
decimal places
|
long
double
|
10
byte
|
3.4E-4932
to 1.1E+4932
|
19
decimal places
|
The header file float.h defines macros that allow you to use these
values and other details about the binary representation of real numbers in
your programs. The following example prints the storage space taken by a float
type and its range values:
#include <stdio.h>
#include <float.h>
int main()
{
printf("Storage size for
float : %d \n", sizeof(float));
printf("Minimum float
positive value: %E\n", FLT_MIN );
printf("Maximum float
positive value: %E\n", FLT_MAX );
printf("Precision value:
%d\n", FLT_DIG );
return 0;
}
When
you compile and execute the above program, it produces the following result on
Linux:
Storage size for float : 4
Minimum float positive value: 1.175494E-38
Maximum float positive value: 3.402823E+38
Precision value: 6
The void Type
The
void type specifies that no value is available. It is used in three kinds of
situations:
S.N. Types
and Description
1 Function
returns as void
There are various functions in C which do not return any value or
you can say they return void. A function with no return value has the return
type as void. For example, void exit (int status);
2 Function
arguments as void
There are various functions in C which do not accept any
parameter. A function with no parameter can accept a void. For example, int rand(void);
3 Pointers to
void
A pointer of type void * represents the address of an object, but
not its type. For example, a memory allocation function void
*malloc(size_t size); returns a pointer to void which can
be casted to any data type.
6.
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:
Type
Description
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 to define various other types of variables, which we will cover in
subsequent chapters like Enumeration, Pointer, Array, Structure, Union, etc.
For this chapter, let us study only basic variable types.
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:
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 initializes z.
|
|
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 declaration has
its meaning at the time of compilation only, the compiler needs actual variable
declaration at the time of linking the program.
A variable declaration
is useful when you are using multiple files and you define your variable in one
of the files which will be available at the time of linking the program. You
will use the keyword extern to declare a variable at any place. Though you can
declare a variable multiple times in your C program, it can be defined only
once in a file, a function, or a block of code.
Example
Try the following
example, where variables have been declared at the top, but they have been
defined and initialized inside the main function:
#include <stdio.h>
// Variable declaration:
extern int a, b;
extern int c;
extern float f;
int main ()
{
/* variable definition: */
int a, b;
int c;
float f;
/* actual initialization */
a = 10;
b = 20;
c = a + b;
printf("value of c : %d \n", c);
f = 70.0/3.0;
printf("value of f : %f \n", f);
return 0;
}
When the above code is
compiled and executed, it produces the following result:
value of c : 30
value of f : 23.333334
The same concept applies
on function declaration where you provide a function name at the time of its
declaration and its actual definition can be given anywhere else. For example:
// function declaration
int func();
int main()
{
// function call
int i = func();
}
// function definition
int func()
{
return 0;
}
Lvalues and Rvalues in C
There
are two kinds of expressions in C:
Lvalue :
Expressions that refer to a memory location are called
"lvalue" expressions. An lvalue may appear as either the left-hand or
right-hand side of an assignment.
Rvalue :
The term rvalue refers to a data value that is stored at
some address in memory. An rvalue is an expression that cannot have a value
assigned to it which means an rvalue may appear on the right-hand side but not
on the left-hand side of an assignment.
Variables
are lvalues and so they may appear on the left-hand side of an assignment.
Numeric literals are rvalues and so they may not be assigned and cannot appear
on the left-hand side. Take a look at the following valid and invalid
statements:
int g = 20; // valid statement
10 = 20; // invalid statement; would generate compile-time
error
7.
CONSTANTS AND LITERALS
Constants refer to fixed
values that the program may not alter during its execution. These
fixed values are also called literals.
Constants can be of any
of the basic data types like an integer constant, a floating constant, a
character constant, or a string literal. There are enumeration constants as
well.
Constants are treated
just like regular variables except that their values cannot be modified after
their definition
Integer
Literals
An integer literal can
be a decimal, octal, or hexadecimal constant. A prefix specifies the base or
radix: 0x or 0X for hexadecimal, 0 for octal, and nothing for decimal.
An integer literal can
also have a suffix that is a combination of U and L, for unsigned and long,
respectively. The suffix can be uppercase or lowercase and can be in any order.
Here are some examples
of integer literals:
212 /* Legal */
215u /* Legal */
0xFeeL /* Legal */
078 /* Illegal: 8 is not an octal
digit */
032UU /* Illegal: cannot repeat a suffix */
Following are other
examples of various types of integer literals:
85 /* decimal */
0213 /* octal */
0x4b /* hexadecimal */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */
Floating-point Literals
A floating-point literal
has an integer part, a decimal point, a fractional part, and an exponent part.
You can represent floating point literals either in decimal form or exponential
form.
While representing
decimal form, you must include the decimal point, the exponent, or both; and
while representing exponential form, you must include the integer part, the
fractional part, or both. The signed exponent is introduced by e or E.
Here are some examples
of floating-point literals:
3.14159 /* Legal */
314159E-5L /* Legal */
510E /* Illegal: incomplete exponent */
210f /* Illegal: no decimal or exponent */
.e55 /* Illegal: missing integer or fraction
*/
Character Constants
Character literals are
enclosed in single quotes, e.g., 'x' can be stored in a simple variable of char
type.
A character literal can
be a plain character (e.g., 'x'), an escape sequence (e.g., '\t'), or a
universal character (e.g., '\u02C0').
There are certain
characters in C that represent special meaning when preceded by a backslash,
for example, newline (\n) or tab (\t). Here, you have a list of such escape
sequence codes:
Escape Meaning
sequence
\\ \ character
\' ' character
\" " character
\? ? character
\a Alert or bell
\b Backspace
\f Form feed
\n Newline
\r Carriage return
\t Horizontal tab
\v Vertical tab
\ooo Octal number of one to three digits
\xhh . . .
Hexadecimal number of one or more digits
Following is the example
to show a few escape sequence characters:
#include <stdio.h>
int main()
{
printf("Hello\tWorld\n\n");
return 0;
}
When the above code is
compiled and executed, it produces the following result:
Hello World
String Literals
String literals or
constants are enclosed in double quotes "". A string contains
characters that are similar to character literals: plain characters, escape
sequences, and universal characters.
You can break a long
line into multiple lines using string literals and separating them using
whitespaces.
Here are some examples
of string literals. All the three forms are identical strings.
"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"
Defining Constants
There are two simple
ways in C to define constants:
•
Using #define preprocessor
•
Using const keyword
The #define Preprocessor
Given below is the form
to use #define preprocessor to define a constant:
#define identifier value
The following example
explains it in detail:
#include <stdio.h>
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int main()
{
int area;
area = LENGTH * WIDTH
printf("value of area : %d", area);
printf("%c", NEWLINE);
return 0;
}
When the above code is
compiled and executed, it produces the following result:
value of area : 50
The Const Keyword
You can use const prefix
to declare constants with a specific type as follows:
const type variable = value;
The following example
explains it in detail:
#include <stdio.h>
int main()
{
const int
LENGTH = 10;
const int
WIDTH = 5;
const char NEWLINE = '\n';
int area;
area = LENGTH * WIDTH;
printf("value of area : %d", area);
printf("%c", NEWLINE);
return 0;
}
When the above code is
compiled and executed, it produces the following result:
value of area : 50
Note that it is a good
programming practice to define constants in CAPITALS.
8.
STORAGE CLASSES
A
storage class defines the scope (visibility) and life-time of variables and/or
functions within a C Program. They precede the type that they modify. We have
four different storage classes in a C program:
o auto
o register
o static
o extern
The auto
Storage Class
The auto storage class is the default storage
class for all local variables.
{
int mount;
auto int month;
}
The example above defines two variables within the same storage
class. ‘auto’ can only be used within functions, i.e., local variables.
The register Storage
Class
The register storage class is used to define
local variables that should be stored in a register instead of RAM. This means
that the variable has a maximum size equal to the register size (usually one
word) and can't have the unary '&' operator applied to it (as it does not
have a memory location).
{
register int miles;
}
The
register should only be used for variables that require quick access such as
counters. It should also be noted that defining 'register' does not mean that
the variable will be stored in a register. It means that it MIGHT be stored in
a register depending on hardware and implementation restrictions.
The
static Storage Class
The static storage class
instructs the compiler to keep a local variable in existence during the
life-time of the program instead of creating and destroying it each time it
comes into and goes out of scope. Therefore, making local variables static
allows them to maintain their values between function calls.
The static modifier may
also be applied to global variables. When this is done, it causes that
variable's scope to be restricted to the file in which it is declared.
In C programming, when
static is used on a class data member, it causes only one copy of that member
to be shared by all the objects of its class.
#include <stdio.h>
/* function declaration */
void func(void);
static int count = 5; /* global variable */
main()
{
while(count--)
{
func();
}
return 0;
}
/* function definition */
void func( void )
{
static int i = 5; /* local static variable */
i++;
printf("i is %d and count is %d\n", i, count);
}
When the above code is compiled and
executed, it produces the following result:
i is 6 and count is 4
i is 7 and count is 3
i is 8 and count is 2
i is 9 and count is 1
i is 10 and count is 0
The extern Storage Class
The extern storage class
is used to give a reference of a global variable that is visible to ALL the
program files. When you use 'extern', the variable cannot be initialized,
however, it points the variable name at a storage location that has been
previously defined.
When you have multiple
files and you define a global variable or function, which will also be used in
other files, then extern will be used in another file to provide the reference
of defined variable or function. Just for understanding, extern is used to
declare a global variable or function in another file.
The extern modifier is
most commonly used when there are two or more files sharing the same global
variables or functions as explained below.
First File: main.c
#include <stdio.h>
int count;
extern void write_extern();
main()
{
count = 5;
write_extern();
}
Second File: support.c
#include <stdio.h>
extern int count;
void write_extern(void)
{
printf("count is %d\n", count);
}
Here, extern is being
used to declare count in the second file, whereas it has its definition in the
first file, main.c. Now, compile these two files as follows:
$gcc main.c support.c
It will produce the executable
program a.out. When this program is executed, it produces the following result:
5
9. OPERATORS
An operator is a symbol that tells the compiler to perform
specific mathematical or logical functions. C language is rich in built-in
operators and provides the following types of operators:
· Arithmetic
Operators
· Relational
Operators
· Logical
Operators
· Bitwise
Operators
· Assignment
Operators
· Misc
Operators
We will, in this
chapter, look into the way each operator works.
Arithmetic Operators
The following table shows all the arithmetic operators supported
by the C language. Assume variable A holds 10 and
variable B holds 20, then:
Operator
|
Description
|
Example
|
+
|
Adds two operands.
|
A + B = 30
|
-
|
Subtracts second
operand from the first.
|
A - B = -10
|
*
|
Multiplies both
operands.
|
A * B = 200
|
/
|
Divides numerator by
de-numerator.
|
B / A = 2
|
%
|
Modulus
Operator and remainder of after an
|
B % A = 0
|
integer division.
|
||
--
|
Decrement
operator decreases the integer value by one.
|
A--=9
|
++
|
Increment operator
increases the integer value
|
A++ = 11
|
by one.
|
||
Example
Try the following example to understand all the arithmetic
operators available in
C:
#include <stdio.h>
main()
{
int a = 21;
int b = 10;
int c ;
c = a + b;
printf("Line 1 - Value of c is %d\n", c ); c = a - b;
printf("Line 2 - Value of c is %d\n", c ); c = a * b;
printf("Line 3 - Value of c is %d\n", c ); c = a / b;
printf("Line 4 - Value of c is %d\n", c ); c = a % b;
printf("Line 5 - Value of c is %d\n", c ); c = a++;
printf("Line 6 - Value of c is %d\n", c ); c = a--;
printf("Line 7 - Value of c is %d\n", c );
}
When you compile and execute the above program, it produces the
following result:
Line 1 - Value of c is 31
Line 2 - Value of c is 11
Line 3 - Value of c is 210
Line 4 - Value of c is 2
Line 5 - Value of c is 1
Line 6 - Value of c is 21
Line 7 - Value of c is 22
Relational Operators
The following table shows all the relational operators supported
by C. Assume variable A holds 10 and variable B holds 20, then:
Operator
|
Description
|
Example
|
==
|
Checks if the values of
two operands are equal
|
(A == B)
is not
|
or not.
If yes, then the condition becomes
|
true.
|
|
true.
|
||
!=
|
Checks if the values of
two operands are equal
|
(A != B) is true.
|
or not. If the values
are not equal, then the
|
||
condition becomes true.
|
||
>
|
Checks if the value of
left operand is greater
|
(A >
B) is not
|
than the value of right
operand. If yes, then
|
true.
|
|
the condition becomes
true.
|
||
<
|
Checks if the value of
left operand is less than
|
(A < B) is true.
|
the value
of right operand. If yes, then the
|
||
condition becomes true.
|
||
>=
|
Checks if the value of
left operand is greater
|
(A >= B)
is not
|
than or equal to the
value of right operand. If
|
true.
|
|
yes, then the condition
becomes true.
|
||
<=
|
Checks if the value of
left operand is less than
|
(A <= B) is true.
|
or equal to the value
of right operand. If yes,
|
||
then the condition
becomes true.
|
||
Example
Try the following example to understand all the relational
operators available in
C:
#include <stdio.h>
main()
{
int a = 21;
int b = 10;
int c ;
if( a == b )
{
printf("Line 1 - a is equal to b\n" );
}
else
{
printf("Line 1 - a is not equal to b\n" );
}
if ( a < b )
{
printf("Line 2 - a is less than b\n" );
}
else
{
printf("Line 2 - a is not less than b\n" );
}
if ( a > b ){
printf("Line 3 - a is greater than b\n" );
}
else{
printf("Line 3 - a is not greater than b\n" );
}
/* Lets change value of a and b */
a = 5;
b = 20;
if ( a <= b )
{
printf("Line 4 - a is either less than or equal
to b\n" );
}
if ( b >= a )
{
printf("Line 5 - b is either greater
than or equal to b\n" );
}
}
When you compile and execute the above program, it produces the
following result:
Line 1 - a is not equal to b
Line 2 - a is not less than b
Line 3 - a is greater than b
Line 4 - a is either less than or equal to
b
Line 5 - b is either greater than or equal to b
Logical Operators
Following table shows all the logical operators supported by C
language. Assume variable A holds 1 and variable B holds 0, then:
Operator
|
Description
|
Example
|
&&
|
Called
Logical AND operator. If both the
|
(A
&& B) is
|
operands
are non-zero, then the condition
|
false.
|
|
becomes true.
|
||
||
|
Called Logical OR
Operator. If any of the two operands is
non-zero, then the condition
becomes true.
|
(A || B) is true.
|
!
|
Called
Logical NOT Operator. It is used to
reverse
the logical state of its operand.
If a
condition
is true, then Logical NOT operator will
make it
false.
|
!(A
&& B) is
true.
|
Example
Try the following example to understand all the logical operators
available in C:
#include <stdio.h>
main()
{
int a = 5;
int b = 20;
int c ;
if ( a && b )
{
printf("Line 1 - Condition is true\n" );
}
if ( a || b )
{
printf("Line 2 - Condition is true\n" );
}
/* lets change the value
of a and b */
a = 0;
b = 10;
if ( a && b )
{
printf("Line 3 - Condition is true\n" );
}
else
{
printf("Line 3 - Condition is not true\n" );
}
if ( !(a && b) )
{
printf("Line 4 - Condition is true\n" );
}
}
When you compile and execute the above program, it produces the
following result:
Line 1 - Condition is true
Line 2 - Condition is true
Line 3 - Condition is not true
Line 4 - Condition is true
Bitwise Operators
Bitwise operators work on bits and perform bit-by-bit operation.
The truth table for &, |, and ^ is as follows:
p
|
q
|
p & q
|
p | q
|
p ^ q
|
0
|
0
|
0
|
0
|
0
|
0
|
1
|
0
|
1
|
1
|
1
|
1
|
1
|
1
|
0
|
1
|
0
|
0
|
1
|
1
|
Assume A = 60 and B = 13; in binary format, they will be as
follows:
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
The following table lists the bitwise operators supported by C.
Assume variable ‘A’ holds 60 and variable ‘B’ holds 13, then:
Operator
|
Description
|
Example
|
&
|
Binary AND Operator
copies a bit to the result
|
(A & B) = 12, i.e.,
|
if it exists in both
operands.
|
0000 1100
|
|
|
|
Binary OR Operator
copies a bit if it exists in
|
(A | B) = 61, i.e.,
|
either operand.
|
0011 1101
|
|
^
|
Binary XOR Operator
copies the bit if it is set
|
(A ^ B) = 49, i.e.,
|
in one operand but not
both.
|
0011 0001
|
|
~
|
Binary Ones
Complement Operator is unary
|
(~A ) = -61, i.e.,
|
and has the effect of
'flipping' bits.
|
1100 0011 in 2's
|
|
complement form.
|
||
<<
|
Binary Left Shift
Operator. The left operands
|
A <<
2 = 240,
|
value is
moved left by the number of bits
|
i.e., 1111 0000
|
|
specified by the right
operand.
|
||
>>
|
Binary Right Shift
Operator. The left operands
|
A >> 2 = 15,
i.e.,
|
value is moved right by
the number of bits
|
0000 1111
|
|
specified by the right
operand.
|
||
Example
Try the following example to understand all the bitwise operators
available in C:
#include <stdio.h>
main()
{
unsigned int a =
60; /* 60 = 0011 1100 */
unsigned int b =
13; /* 13 = 0000 1101 */
int c =
0;
c = a &
b;
/* 12 = 0000 1100 */
printf("Line 1 - Value of c is
%d\n", c );
c = a |
b;
/* 61 = 0011 1101 */
printf("Line 2 - Value of c is
%d\n", c );
c = a ^
b;
/* 49 = 0011 0001 */
printf("Line 3 - Value of c is
%d\n", c );
c = ~a; /*-61 = 1100
0011 */
printf("Line 4 - Value of c is
%d\n", c );
c = a <<
2; /*
240 = 1111 0000 */
printf("Line 5 - Value of c is
%d\n", c );
c = a >>
2; /* 15 =
0000 1111 */
printf("Line 6 - Value of c is
%d\n", c );
}
When you compile and execute the above program, it produces the
following result:
Line 1 - Value of c is 12
Line 2 - Value of c is 61
Line 3 - Value of c is 49
Line 4 - Value of c is -61
Line 5 - Value of c is 240
Line 6 - Value of c is 15
Assignment Operators
The following tables lists the assignment operators supported by
the C language:
Operator
|
Description
|
Example
|
=
|
Simple
assignment operator. Assigns
|
C = A + B will assign
|
values from
right side operands to left
|
the value of A + B to
|
|
side operand.
|
C
|
|
+=
|
Add AND assignment
operator. It adds the
|
C += A is equivalent
|
right
operand to the left operand and
|
to C = C + A
|
|
assigns the result to
the left operand.
|
||
-=
|
Subtract
AND assignment operator. It
|
C -=
A is equivalent
|
subtracts the right
operand from the left
|
to C = C - A
|
|
operand and assigns the
result to the left
|
||
operand.
|
||
*=
|
Multiply
AND assignment operator. It
|
C *= A is equivalent
|
multiplies the right
operand with the left
|
to C = C * A
|
|
operand and assigns the
result to the left
|
||
operand.
|
||
/=
|
Divide
AND assignment operator. It
|
C /=
A is equivalent
|
divides the
left operand with the right
|
to C = C / A
|
|
operand and assigns the
result to the left
|
||
operand.
|
||
%=
|
Modulus AND
assignment operator. It
|
C %= A is equivalent
|
takes
modulus using two operands and
|
to C = C % A
|
|
assigns the result to
the left operand.
|
||
<<=
|
Left shift AND
assignment operator.
|
C <<= 2 is same
as C
|
= C << 2
|
||
>>=
|
Right shift AND
assignment operator.
|
C >>= 2 is same
as C
|
= C >> 2
|
||
&=
|
Bitwise AND assignment
operator.
|
C &= 2 is same as C
|
= C
& 2
|
||
^=
|
Bitwise
exclusive OR and assignment operator.
|
C ^= 2
is same as C = C ^ 2
|
|=
|
Bitwise
inclusive OR and assignment operator.
|
C |= 2
is same as C = C | 2
|
Example
Try the following example to understand all the assignment
operators available in C:
#include <stdio.h>
main()
{
int a = 21;
int c ;
c = a;
printf("Line 1 - = Operator Example, Value of c = %d\n",
c );
c += a;
printf("Line 2 - += Operator Example, Value of c =
%d\n", c );
c -= a;
printf("Line 3 - -= Operator Example, Value of c =
%d\n", c );
c *= a;
printf("Line 4 - *= Operator Example, Value of c =
%d\n", c );
c /= a;
printf("Line 5 - /= Operator Example, Value of c =
%d\n", c );
c = 200;
c %= a;
printf("Line 6 - %= Operator Example, Value of c =
%d\n", c );
c <<= 2;
printf("Line 7 - <<= Operator Example, Value of c =
%d\n", c );
c >>= 2;
printf("Line 8 - >>= Operator Example, Value of c =
%d\n", c );
c &= 2;
printf("Line 9 - &= Operator Example, Value of c =
%d\n", c );
c ^= 2;
printf("Line 10 - ^= Operator Example, Value of c =
%d\n", c );
c |= 2;
printf("Line 11 - |= Operator Example, Value of c =
%d\n", c );
}
When you compile and execute the above program, it produces the
following result:
Line 1 - = Operator Example, Value of c = 21
Line 2 - += Operator Example, Value of c = 42
Line 3 - -= Operator Example, Value of c = 21
Line 4 - *= Operator Example, Value of c = 441
Line 5 - /= Operator Example, Value of c = 21
Line 6 - %= Operator Example, Value of c = 11
Line 7 - <<= Operator Example, Value of c = 44
Line 8 - >>= Operator Example, Value of c = 11
Line 9 - &= Operator Example, Value of c = 2
Line 10 - ^= Operator Example, Value of c = 0
Line 11 - |= Operator Example, Value of c = 2
Misc Operators ↦sizeof & ternary
Besides the operators discussed above, there are a few other
important operators including sizeof and ? : supported by the C Language.
Operator
|
Description
|
Example
|
||
sizeof()
|
Returns the size of a
variable.
|
sizeof(a),
|
where
|
a
is
|
integer, will return 4.
|
||||
&
|
Returns the address of
a variable.
|
&a; returns the
actual
|
||
address
|
of
|
the
|
||
variable.
|
||||
*
|
Pointer to a variable.
|
*a;
|
||
? :
|
Conditional Expression.
|
If Condition is
true ?
|
||
then value
X
|
:
|
|||
otherwise value Y
|
||||
Example
Try following example to understand all the miscellaneous
operators available in
C:
#include <stdio.h>
main()
{
int a = 4;
short b;
double c;
int* ptr;
/* example of sizeof operator */
printf("Line 1 - Size of variable a = %d\n", sizeof(a)
);
printf("Line 2 - Size of variable b = %d\n", sizeof(b)
);
printf("Line 3 - Size of variable c= %d\n", sizeof(c) );
/* example of & and * operators */
ptr = &a; /* 'ptr' now contains the address of 'a'*/
printf("value of a is %d\n", a);
printf("*ptr is %d.\n", *ptr);
/* example of ternary operator */
a = 10;
b = (a == 1) ? 20: 30;
printf( "Value of b is %d\n", b );
b = (a == 10) ? 20: 30;
printf( "Value of b is %d\n", b );
}
When you compile and execute the above program, it produces the
following result:
value of a is 4
*ptr is 4.
Value of b is 30
Value of b is 20
Operators Precedence in C
Operator precedence determines the grouping of terms in an
expression and decides how an expression is evaluated. Certain operators have
higher precedence than others; for example, the multiplication operator has a
higher precedence than the addition operator.
For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because
operator * has a higher precedence than +, so it first gets multiplied with 3*2
and then adds into 7.
Here, operators with the highest precedence appear at the top of
the table, those with the lowest appear at the bottom. Within an expression,
higher precedence operators will be evaluated first.
Category
|
Operator
|
Associativity
|
Postfix
|
() [] -> . ++ - -
|
Left to right
|
Unary
|
+ - ! ~ ++ - - (type)*
& sizeof
|
Right to left
|
Multiplicative
|
* / %
|
Left to right
|
Additive
|
+ -
|
Left to right
|
Shift
|
<<>>
|
Left to right
|
Relational
|
<<= >>=
|
Left to right
|
Equality
|
== !=
|
Left to right
|
Bitwise AND
|
&
|
Left to right
|
Bitwise XOR
|
^
|
Left to right
|
Bitwise OR
|
|
|
Left to right
|
Logical AND
|
&&
|
Left to right
|
Logical OR
|
||
|
Left to right
|
Conditional
|
?:
|
Right to left
|
Assignment
|
= += -= *= /=
%=>>= <<= &= ^= |=
|
Right to left
|
Comma
|
,
|
Left to right
|
Example
Try the following example to understand operator precedence in C:
#include <stdio.h>
main()
{
int a = 20;
int b = 10;
int c = 15;
int d = 5;
int e;
e = (a + b) * c / d; // ( 30 * 15 ) / 5
printf("Value of (a + b) * c / d is : %d\n", e );
e = ((a + b) * c) / d; // (30 * 15 ) / 5
printf("Value of ((a + b) * c) / d is : %d\n" , e );
e = (a + b) * (c / d); // (30) * (15/5)
printf("Value of (a + b) * (c / d) is : %d\n", e );
e = a + (b * c) / d; // 20 + (150/5)
printf("Value of a + (b * c) / d is : %d\n" , e );
return 0;
}
When you compile and execute the above program, it produces the
following result:
Value of (a + b) * c / d is : 90
Value of ((a + b) * c) / d
is : 90
Value of (a + b) * (c / d)
is : 90
Value of a + (b * c) / d
is
: 50
10. DECISION MAKING
Decision-making structures require that
the programmer specifies one or more conditions to be evaluated or tested by
the program, along with a statement or statements to be executed if the
condition is determined to be true, and optionally, other statements to be
executed if the condition is determined to be false.
Shown below is the general form of a
typical decision-making structure found in most of the programming languages:
C programming language assumes any non-zeroand non-null values
as true, and if it is either zeroor null,
then it is assumed as false value.
C programming language provides the following types of
decision-making statements.
Statement
|
Description
|
|
if statement
|
An if statement consists
of a boolean expression
|
|
followed by one or more
statements.
|
||
if...else statement
|
An if
statement can be followed by an
optional else statement,
which
executes when the Boolean expression is false
|
|
the
Boolean expression is false
|
You
can use one if or else if statement inside
another
if or else if statement(s).
|
|
switch
statement
|
A switch statement
allows a variable to be tested for equality against a list of values
|
|
nested
switch statements
|
You can
use one switch statement inside another
switch
statement(s).
|
|
if Statement
An if statement consists of a Boolean expression followed by one
or more statements.
Syntax
The syntax of an ‘if’ statement in C programming language is:
if(boolean_expression)
{
/*
statement(s) will execute if the boolean expression is true */
}
If the Boolean expression evaluates to true, then the block
of code inside the ‘if’ statement will be executed. If the Boolean expression
evaluates to false, then the first set of code after the end of the ‘if’
statement (after the closing curly brace) will be executed.
C programming language assumes any non-zero and non-null
values as true and if it is either zero or null, then it is assumed as false value.
Flow Diagram
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 10;
/* check the boolean condition using if
statement */
if( a < 20 )
{
/* if condition is true then print the
following */
printf("a is less than 20\n"
);
}
printf("value of a is :
%d\n", a);
return 0;
}
When the above code is compiled and executed, it produces
the following result:
a is less than 20;
value of a is : 10
if…else Statement
An if statement can be followed by an
optional else statement, which executes when the Boolean expression is false.
Syntax
The
syntax of an if...else statement in C programming language is:
#include
<stdio.h>
int
main ()
{
/*
local variable definition */
int
a = 10;
/*
check the boolean condition using if statement */
if(
a < 20 )
{
/*
if condition is true then print the following */
printf("a
is less than 20\n" );
}
printf("value
of a is : %d\n", a);
return
0;
}
If the Boolean expression evaluates to true, then the if block
will be executed, otherwise, the else block will be executed.
C programming
language assumes any non-zero and non-null values as true, and if it is either
zero or null, then it is assumed as false value.
Flow Diagram
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 100;
/* check the boolean condition */
if( a < 20 )
{
/* if condition is true then print the
following */
printf("a is less than 20\n"
);
}
else
{
/* if condition is false then print the
following */
printf("a is not less than
20\n" );
}
printf("value of a is :
%d\n", a);
return 0;
}
When the above code is compiled and executed, it produces
the following result:
a is not less than 20;
value of a is : 100
if...else if...else Statement
An if statement can be followed by an optional else
if...else statement, which is very useful to test various conditions using
single if...else if statement.
When using if…else if…else statements, there are few points
to keep in mind:
o An if can have zero or one else's and
it must come after any else if's.
o An if can have zero to many else if's
and they must come before the else.
o Once an else if succeeds, none of the
remaining else if's or else's will be
Syntax
The syntax of an if...else if...else statement in C
programming language is:
if(boolean_expression 1)
{
/* Executes when the boolean expression
1 is true */
}
else if( boolean_expression 2)
{
/* Executes when the boolean expression
2 is true */
}
else if( boolean_expression 3)
{
/* Executes when the boolean expression
3 is true */
}
else
{
/* executes when the none of the above
condition is true */
}
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 100;
/* check the boolean condition */
if( a == 10 )
{
/* if
condition is true then print the following */
printf("Value of a is 10\n"
);
}
else if( a == 20 )
{
/* if else if condition is true */
printf("Value of a is 20\n"
);
}
else if( a == 30 )
{
/* if else if condition is true */
printf("Value of a is 30\n"
);
}
else
{
/* if none of the conditions is true */
printf("None of the values is
matching\n" );
}
printf("Exact value of a is:
%d\n", a );
return 0;
}
When the above code is compiled and executed, it produces
the following result:
None of the values is matching
Exact value of a is: 100
Nested if Statements
It is always legal in C programming to nest if-else
statements, which means you can use one if or else if statement inside another
if or else if statement(s).
Syntax
The syntax for a nested if statement is as follows:
if( boolean_expression 1)
{
/* Executes when the boolean expression
1 is true */
if(boolean_expression 2)
{
/* Executes when the boolean expression
2 is true */
}
}
You can nest else if...else in the similar way as you have
nested if statements.
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
/* check the boolean condition */
if( a == 100 )
{
/* if condition is true then check the
following */
if( b == 200 )
{
/* if condition is true then print the
following */
printf("Value of a is 100 and b is
200\n" );
}
}
printf("Exact value of a is :
%d\n", a );
printf("Exact value of b is :
%d\n", b );
return 0;
}
When the above code is compiled and executed, it produces
the following result:
Value of a is 100 and b is 200
Exact value of a is : 100
Exact value of b is : 200
Switch Statement
A switch statement allows a variable to be tested
for equality against a list of values. Each value is called a case, and the
variable being switched on is checked for each switch case.
Syntax
The syntax for a switch statement in C
programming language is as follows:
switch(expression){
case constant-expression :
statement(s);
break; /* optional */
case constant-expression :
statement(s);
break; /* optional */
/* you can have any number of case statements */ default : /*
Optional */
statement(s);
}
The following rules apply to a switch statement:
o The expression used in a switch statement
must have an integral or enumerated type, or be of a class type in which the
class has a single conversion function to an integral or enumerated type.
o You can have any number of case statements within a switch. Each
case is followed by the value to be compared to and a colon.
o The constant-expression for a case must be the
same data type as the variable in the switch, and it must be a constant or a
literal.
o When the variable being switched on is equal to a case, the
statements following that case will execute until a break statement
is reached.
o When a break statement is reached, the switch
terminates, and the flow of control jumps to the next line following the switch
statement.
o Not every case needs to contain a break. If no break appears,
the flow of control will fall throughto subsequent cases until a
break is reached.
o A switch statement can have an optional defaultcase,
which must appear at the end of the switch. The default case can be used for
performing a task when none of the cases is true. No break is
needed in the default case.
Flow Diagram
Example
#include
<stdio.h>
int
main ()
{
/*
local variable definition */
char
grade = 'B';
switch(grade)
{
case
'A' :
printf("Excellent!\n"
);
break;
case
'B' :
case
'C' :
printf("Well
done\n" );
break;
case
'D' :
printf("You
passed\n" );
break;
case
'F' :
printf("Better
try again\n" );
break;
default
:
printf("Invalid
grade\n" );
}
printf("Your
grade is %c\n", grade );
return
0;
}
When the above code is compiled and executed, it produces
the following result:
Well done
Your grade is B
Nested switch Statements
It is possible to have a switch as a part of the statement
sequence of an outer switch. Even if the case constants of the inner and outer
switch contain common values, no conflicts will arise.
Syntax
The syntax for a nested switch statement
is as follows:
switch(ch1) {
case 'A':
printf("This A is part of outer switch" );
switch(ch2) {
case 'A':
printf("This A is part of inner switch" ); break;
case 'B': /* case code */
}
break;
case 'B': /* case code */
}
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
switch(a) {
case 100:
printf("This is part of outer
switch\n", a ); switch(b) {
case 200:
printf("This is part of inner
switch\n", a );
}
}
printf("Exact value of a is :
%d\n", a );
printf("Exact value of b is :
%d\n", b );
return 0;
}
When the above code is compiled and executed, it produces
the following result:
This is part of outer switch
This is part of inner switch
Exact value of a is : 100
Exact value of b is : 200
The ? : Operator:
We have covered conditional operator ? : in
the previous chapter which can be used to replace if...else statements.
It has the following general form:
Exp1 ? Exp2 : Exp3;
Where Exp1, Exp2, and Exp3 are expressions. Notice the use
and placement of the colon.
The value of a ? expression is determined like this:
1. Exp1 is evaluated. If it is true, then Exp2 is evaluated and
becomes the value of the entire ? expression.
2. If Exp1 is false, then Exp3 is evaluated and its value becomes the
value of the expression.
C Program Notes By Ramesh Mahato
No comments:
Post a Comment