Asansol Engineering College

CSE 2nd Semester

Lecture Notes
On
PROGRAMMING FOR PROBLEM SOLVING

Prepared By:
Dr. Sujit Kumar Singh
Associate Professor,
Department of Computer Science & Engineering
 STRUCTURE OF A C PROGRAM

C program structure so that we can take it as a reference in

the upcoming chapters.
Hello World Example
A C program basically consists of the following parts −
Preprocessor Commands
Functions
Variables
Statements & Expressions
Comments
Let us look at a simple code that would print the words "Hello
World" −.

Dr. Sujit Kumar Singh

 STRUCTURE OF A C PROGRAM

Let us take a look at the various parts of the

#include <stdio.h> above program −

int main() { The first line of the program #include

/* my first <stdio.h> is a preprocessor command, which
program in C */ tells a C compiler to include stdio.h file before
going to actual compilation.
printf("Hello, The next line int main() is the main function
World! \n"); where the program execution begins.
The next line /*...*/ will be ignored by the
return 0; compiler and it has been put to add additional
}−. comments in the program. So such lines are
called comments in the program.
The next line printf(...) is another function
available in C which causes the message
"Hello, World!" to be displayed on the screen.
The next line return 0; terminates the main()
function and returns the value 0.

Dr. Sujit Kumar Singh

 Types of Errors in C 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 −
Open a text editor and add the above-mentioned code.
Save the file as hello.c
Open a command prompt and go to the directory where you
have saved the file.
Type gcc hello.c and press enter to compile your code.
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.
Now, type a.out to execute your program.
You will see the output "Hello World" printed on the screen.

Dr. Sujit Kumar Singh

 C Program

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;
Dr. Sujit Kumar Singh
 C Program

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
Dr. Sujit Kumar Singh
 C Program

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 continuegoto sizeof volatile
defaultif static while do int struct _Packed
double

Dr. Sujit Kumar Singh

 C Program

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.
Dr. Sujit Kumar Singh
 DATA TYPES IN C

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 −
Sr.No. Types & 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.
N.B The array types and structure types are referred collectively as
the aggregate types.
Dr. Sujit Kumar Singh
 INTEGER TYPE

Dr. Sujit Kumar Singh

 DATA TYPES IN C

To get the exact size of a type or a variable on a particular platform,

you can use the sizeof operator. The expressions sizeof(type) yields
the storage size of the object or type in bytes.
Floating-Point Types
The following table provide the details of standard floating-point
types with storage sizes and value ranges and their precision −

Dr. Sujit Kumar Singh

 Data Type

The void Type

The void type specifies that no value is available. It is
used in three kinds of situations −

Dr. Sujit Kumar Singh

 C 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 −

Dr. Sujit Kumar Singh

 C VARIABLES

Dr. Sujit Kumar Singh

 C VARIABLES

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; Dr. Sujit Kumar Singh
 C VARIABLES

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.
Dr. Sujit Kumar Singh
 C VARIABLES

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;
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 you are using multiple files and
you define your variable in one of the files which will be available at
the time of linking of 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.
Dr. Sujit Kumar Singh
 C VARIABLES

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
Dr. Sujit Kumar Singh
 C 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
Dr. Sujit Kumarliterals
Singh−
 C CONSTANTS AND LITERALS

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 */
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.
Dr. Sujit Kumar Singh
 C CONSTANTS AND LITERALS

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 −
Dr. Sujit Kumar Singh
 C CONSTANTS AND LITERALS

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

Dr. Sujit Kumar Singh

 C CONSTANTS AND LITERALS

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 white spaces.
Here are some examples of string literals. All the three forms
are identical strings.
"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"

Dr. Sujit Kumar Singh

 C CONSTANTS AND LITERALS

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 −

Dr. Sujit Kumar Singh

 C CONSTANTS AND LITERALS

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;
}

Dr. Sujit Kumar Singh

 C CONSTANTS AND LITERALS

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;
} Dr. Sujit Kumar Singh
 C - 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 −
auto
register
static
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 with in the same storage
class. 'auto' can only be Dr.
used within
Sujit functions,
Kumar Singhi.e., local variables.
 C - Storage Classes

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. Dr. Sujit Kumar Singh
 C - Storage Classes

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 global variable, it
causes only one copy of that member to be shared by all the
objects of its class.

Dr. Sujit Kumar Singh

 C - Storage Classes

#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);
} Dr. Sujit Kumar Singh
 C - Storage Classes

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
Dr.variables or functions
Sujit Kumar Singhas explained below.
 C - 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 −
Dr. Sujit Kumar Singh
 C - OPERATORS

Dr. Sujit Kumar Singh

 C - OPERATORS

Relational Operators
The following table shows all the relational operators
supported by C. Assume variable A holds 10 and variable B
holds 20 then −

Dr. Sujit Kumar Singh

 C - OPERATORS

Logical Operators
Following table shows all the logical operators supported by
C language. Assume variable A holds 1 and variable B holds
0, then −

Dr. Sujit Kumar Singh

 C - OPERATORS

Bitwise Operators
Bitwise operator works on bits and perform bit-by-bit
operation. The truth tables for &, |, and ^ is as follows −

Dr. Sujit Kumar Singh

 C - OPERATORS

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 −

Dr. Sujit Kumar Singh

 C - OPERATORS

Dr. Sujit Kumar Singh

 C - OPERATORS

Assignment
Operators
The
following
table lists
the
assignment
operators
supported
by the C
language −

Dr. Sujit Kumar Singh

 C - OPERATORS

Misc Operators ↦ sizeof & ternary

Besides the operators discussed above, there are a few other
important operators including sizeof and ? : supported by the C
Language.

Dr. Sujit Kumar Singh

 C - OPERATORS

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.

Dr. Sujit Kumar Singh

 C - OPERATORS

Dr. Sujit Kumar Singh

 DECISION MAKING IN C

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.
Show below is the general
form of a typical decision
making structure found in
most of the programming
languages −
Dr. Sujit Kumar Singh
 DECISION MAKING IN C

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.
C programming language provides the following types of
decision making statements.

Dr. Sujit Kumar Singh

 DECISION MAKING IN C

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 −
Exp1 is evaluated. If it is true, then Exp2 is evaluated and
becomes the value of the entire ? expression.
If Exp1 is false, then Exp3 is evaluated and its value
becomes the value of the expression.

Dr. Sujit Kumar Singh

 DECISION MAKING IN C

You may encounter

situations, when a block of
code needs to be executed
several number of times. In
general, statements are
executed sequentially: The
first statement in a function
is executed first, followed by
the second, and so on.
Programming languages
provide various control
structures that allow for more
complicated execution paths.
A loop statement allows us to
execute a statement or group
of statements multiple times.
Given below is the general
form of a loop statement in
most of the programming
languages −
Dr. Sujit Kumar Singh
 DECISION MAKING IN C

C programming language provides the following types

of loops to handle looping requirements.

Dr. Sujit Kumar Singh

 DECISION MAKING IN C

Loop Control Statements

Loop control statements change execution from its normal
sequence. When execution leaves a scope, all automatic
objects that were created in that scope are destroyed.
C supports the following control statements.

Dr. Sujit Kumar Singh

 DECISION MAKING IN C

The Infinite Loop

A loop becomes an infinite loop if a condition never becomes false.
The for loop is traditionally used for this purpose. Since none of the
three expressions that form the 'for' loop are required, you can
make an endless loop by leaving the conditional expression empty.
#include <stdio.h>
int main () {
for( ; ; ) {
printf("This loop will run forever.\n");
}
return 0;
}
Note: When the conditional expression is absent, it is assumed to
be true. You may have an initialization and increment expression,
but C programmers more commonly use the for(;;) construct to
signify an infinite loop.
Dr. Sujit Kumar Singh
 FUNCTION IN C

A function is a group of statements that together perform a

task. Every C program has at least one function, which is
main(), and all the most trivial programs can define additional
functions.
You can divide up your code into separate functions. How you
divide up your code among different functions is up to you, but
logically the division is such that each function performs a
specific task.
A function declaration tells the compiler about a function's
name, return type, and parameters. A function definition
provides the actual body of the function.
The C standard library provides numerous built-in functions
that your program can call. For example, strcat() to
concatenate two strings, memcpy() to copy one memory
location to another location, and many more functions.
A function can also be referred as a method or a sub-routine or
a procedure, etc. Dr. Sujit Kumar Singh
 FUNCTION IN C

Defining a Function
The general form of a function definition in C programming
language is as follows −
return_type function_name( parameter list ) {
body of the function
}
A function definition in C programming consists of a function
header and a function body. Here are all the parts of a
function −

Dr. Sujit Kumar Singh

 FUNCTION IN C

Return Type − A function may return a value. The

return_type is the data type of the value the function returns.
Some functions perform the desired operations without
returning a value. In this case, the return_type is the
keyword void.
Function Name − This is the actual name of the function.
The function name and the parameter list together
constitute the function signature.
Parameters − A parameter is like a placeholder. When a
function is invoked, you pass a value to the parameter. This
value is referred to as actual parameter or argument. The
parameter list refers to the type, order, and number of the
parameters of a function. Parameters are optional; that is, a
function may contain no parameters.
Function Body − The function body contains a collection of
statements that define what the function does.
Dr. Sujit Kumar Singh
 FUNCTION IN C

Example
Given below is the source code for a function called max().
This function takes two parameters num1 and num2 and
returns the maximum value between the two −
/* function returning the max between two numbers */
int max(int num1, int num2) {
/* local variable declaration */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
} Dr. Sujit Kumar Singh
 FUNCTION IN C

Function Declarations
A function declaration tells the compiler about a function
name and how to call the function. The actual body of the
function can be defined separately.
A function declaration has the following parts −
return_type function_name( parameter list );
For the above defined function max(), the function
declaration is as follows −
int max(int num1, int num2);
Parameter names are not important in function declaration
only their type is required, so the following is also a valid
declaration −
int max(int, int);
}
Dr. Sujit Kumar Singh
 FUNCTION IN C

Function declaration is required when you define a function in

one source file and you call that function in another file. In
such case, you should declare the function at the top of the
file calling the function.
Calling a Function
While creating a C function, you give a definition of what the
function has to do. To use a function, you will have to call that
function to perform the defined task.
When a program calls a function, the program control is
transferred to the called function. A called function performs a
defined task and when its return statement is executed or
when its function-ending closing brace is reached, it returns
the program control back to the main program.
To call a function, you simply need to pass the required
parameters along with the function name, and if the function
returns a value, then you can store the returned value. For
example −} Dr. Sujit Kumar Singh
 FUNCTION IN C

Function Arguments
If a function is to use arguments, it must declare variables
that accept the values of the arguments. These variables are
called the formal parameters of the function.
Formal parameters behave like other local variables inside
the function and are created upon entry into the function and
destroyed upon exit.
While calling a function, there are two ways in which
arguments can be passed to a function −

Dr. Sujit Kumar Singh

 SCOPE IN C

By default, C uses call by value to pass arguments. In

general, it means the code within a function cannot alter the
arguments used to call the function.
A scope in any programming is a region of the program
where a defined variable can have its existence and beyond
that variable it cannot be accessed. There are three places
where variables can be declared in C programming language
−
Inside a function or a block which is called local variables.
Outside of all functions which is called global variables.
In the definition of function parameters which are called
formal parameters.
Let us understand what are local and global variables, and
formal parameters.

Dr. Sujit Kumar Singh

 SCOPE IN C

Local Variables #include <stdio.h>

int main () {
Variables that are declared /* local variable declaration */
inside a function or block int a, b;
are called local variables. int c;
They can be used only by
statements that are inside /* actual initialization */
that function or block of a = 10;
b = 20;
code. Local variables are c = a + b;
not known to functions printf ("value of a = %d, b = %d
outside their own. The and c = %d\n", a, b, c);
following example shows return 0;
how local variables are }
used. Here all the variables
a, b, and c are local to
main() function.

Dr. Sujit Kumar Singh

 SCOPE IN C

Global Variables
Global variables are defined #include <stdio.h>
outside a function, usually on /* global variable declaration */
top of the program. Global int g;
variables hold their values int main () {
throughout the lifetime of your /* local variable declaration */
program and they can be int a, b;
/* actual initialization */
accessed inside any of the
a = 10;
functions defined for the
b = 20;
program.
g = a + b;
A global variable can be printf ("value of a = %d, b = %d
accessed by any function. That and g = %d\n", a, b, g);
is, a global variable is available return 0;
for use throughout your entire }
program after its declaration.
The following program show
how global variables are used
in a program.
Dr. Sujit Kumar Singh
 SCOPE IN C

A program can have same name for local and global

variables but the value of local variable inside a function will
take preference. Here is an example −
#include <stdio.h>
/* global variable declaration */
int g = 20;
int main () {
/* local variable declaration */
int g = 10;
printf ("value of g = %d\n", g);
return 0;
}

Dr. Sujit Kumar Singh

 SCOPE IN C

#include <stdio.h>
When the above
/* global variable declaration */
code is compiled
int a = 20;
and executed, it int main () {
produces the /* local variable declaration in main function
following result − */
value of g = 10 int a = 10;
int b = 20;
Formal int c = 0;
Parameters printf ("value of a in main() = %d\n", a);
Formal c = sum( a, b);
parameters, are printf ("value of c in main() = %d\n", c);
treated as local return 0;
variables with-in }
a function and /* function to add two integers */
they take int sum(int a, int b) {
precedence over printf ("value of a in sum() = %d\n", a);
global variables. printf ("value of b in sum() = %d\n", b);
Following is an
return a + b;
example −
} Dr. Sujit Kumar Singh
 SCOPE IN C

When the above code is compiled and executed, it produces

the following result −
value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30
Initializing Local and Global Variables
When a local variable is defined, it is not initialized by the
system, you must initialize it yourself. Global variables are
initialized automatically by the system when you define
them as follows −

Dr. Sujit Kumar Singh

 SCOPE IN C

It is a good programming practice to initialize variables

properly, otherwise your program may produce unexpected
results, because uninitialized variables will take some
garbage value already available at their memory location.

Dr. Sujit Kumar Singh

 SCOPE IN C

Arrays a kind of data structure that can store a fixed-size

sequential collection of elements of the same type. An array
is used to store a collection of data, but it is often more
useful to think of an array as a collection of variables of the
same type.
Instead of declaring individual variables, such as number0,
number1, ..., and number99, you declare one array variable
such as numbers and use numbers[0], numbers[1], and ...,
numbers[99] to represent individual variables. A specific
element in an array is accessed by an index.
All arrays consist of contiguous memory locations. The
lowest address corresponds to the first element and the
highest address to the last element.

Dr. Sujit Kumar Singh

 SCOPE IN C

Declaring Arrays
To declare an array in C, a programmer specifies the type of
the elements and the number of elements required by an
array as follows −type arrayName [ arraySize ];
This is called a single-dimensional array. The arraySize must
be an integer constant greater than zero and type can be
any valid C data type. For example, to declare a 10-element
array called balance of type double, use this statement −
double balance[10];
Here balance is a variable array which is sufficient to hold up
to 10 double numbers.

Dr. Sujit Kumar Singh

 SCOPE IN C

Initializing Arrays
You can initialize an array in C either one by one or using a
single statement as follows −
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
The number of values between braces { } cannot be larger
than the number of elements that we declare for the array
between square brackets [ ].
If you omit the size of the array, an array just big enough to
hold the initialization is created. Therefore, if you write −
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
You will create exactly the same array as you did in the
previous example. Following is an example to assign a single
element of the array −

Dr. Sujit Kumar Singh

 SCOPE IN C
balance[4] = 50.0;
The above statement assigns the 5th element in the array
with a value of 50.0. All arrays have 0 as the index of their
first element which is also called the base index and the
last index of an array will be total size of the array minus
1. Shown below is the pictorial representation of the array
we discussed above −

Accessing Array Elements

An element is accessed by indexing the array name. This is done by placing
the index of the element within square brackets after the name of the array.
For example −
double salary = balance[9];
The above statement will take the 10th element from the array and assign
the value to salary variable. The following example Shows how to use all
the three above mentioned concepts viz. declaration, assignment, and
accessing arrays −
Dr. Sujit Kumar Singh
 SCOPE IN C

#include <stdio.h>
int main () {
int n[ 10 ]; /* n is an array of 10 integers */
int i,j;
/* initialize elements of array n to 0 */
for ( i = 0; i < 10; i++ ) {
n[ i ] = i + 100; /* set element at location i to i + 100 */
}
/* output each array element's value */
for (j = 0; j < 10; j++ ) {
printf("Element[%d] = %d\n", j, n[j] );
}
return 0;
} Dr. Sujit Kumar Singh
 SCOPE IN C

When the above code is compiled and executed, it

produces the following result −
Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

Dr. Sujit Kumar Singh

 SCOPE IN C

Arrays in Detail
Arrays are important to C and should need a lot more
attention. The following important concepts related to array
should be clear to a C programmer −

Dr. Sujit Kumar Singh

 SCOPE IN C

Pointers in C are easy and fun to learn. Some C programming

tasks are performed more easily with pointers, and other
tasks, such as dynamic memory allocation, cannot be
performed without using pointers. So it becomes necessary
to learn pointers to become a perfect C programmer. Let's
start learning them in simple and easy steps.
As you know, every variable is a memory location and every
memory location has its address defined which can be
accessed using ampersand (&) operator, which denotes an
address in memory. Consider the following example, which
prints the address of the variables defined −

Dr. Sujit Kumar Singh

 SCOPE IN C

#include <stdio.h>
int main () {
int var1;
char var2[10];
printf("Address of var1 variable: %x\n", &var1 );
printf("Address of var2 variable: %x\n", &var2 );
return 0;
}

Dr. Sujit Kumar Singh

 SCOPE IN C

Pointers in C are easy and fun to learn. Some C programming

tasks are performed more easily with pointers, and other
tasks, such as dynamic memory allocation, cannot be
performed without using pointers. So it becomes necessary
to learn pointers to become a perfect C programmer. Let's
start learning them in simple and easy steps.
As you know, every variable is a memory location and every
memory location has its address defined which can be
accessed using ampersand (&) operator, which denotes an
address in memory. Consider the following example, which
prints the address of the variables defined −

Dr. Sujit Kumar Singh

 SCOPE IN C

When the above code is compiled and executed, it produces the

following result −
Address of var1 variable: bff5a400
Address of var2 variable: bff5a3f6
What are Pointers?
A pointer is a variable whose value is the address of another
variable, i.e., direct address of the memory location. Like any
variable or constant, you must declare a pointer before using it to
store any variable address. The general form of a pointer variable
declaration is −
type *var-name;
Here, type is the pointer's base type; it must be a valid C data
type and var-name is the name of the pointer variable. The
asterisk * used to declare a pointer is the same asterisk used for
multiplication. However, in this statement the asterisk is being
used to designate a variable as a pointer. Take a look at some of
the valid pointer declarations − Kumar Singh
Dr. Sujit
 SCOPE IN C

int *ip; /* pointer to an integer */

double *dp; /* pointer to a double */
float *fp; /* pointer to a float */
char *ch /* pointer to a character */
The actual data type of the value of all pointers, whether
integer, float, character, or otherwise, is the same, a long
hexadecimal number that represents a memory address. The
only difference between pointers of different data types is
the data type of the variable or constant that the pointer
points to.

Dr. Sujit Kumar Singh

 SCOPE IN C

How to Use Pointers? #include <stdio.h>

int main () {
There are a few important
int var = 20; /* actual variable
operations, which we will do
declaration */
with the help of pointers
int *ip; /* pointer variable
very frequently. (a) We
declaration */
define a pointer variable, (b)
ip = &var; /* store address of var in
assign the address of a
pointer variable*/
variable to a pointer and (c)
printf("Address of var variable: %x\
finally access the value at
n", &var );
the address available in the
/* address stored in pointer variable
pointer variable. This is done
*/
by using unary operator *
printf("Address stored in ip variable:
that returns the value of the
%x\n", ip );
variable located at the
/* access the value using the
address specified by its
pointer */
operand. The following
printf("Value of *ip variable: %d\n",
example makes use of these
*ip );
operations −
return 0;
Dr. }
Sujit Kumar Singh
 Pointer in C

When the above code is compiled and executed, it produces

the following result −
Address of var variable: bffd8b3c
Address stored in ip variable: bffd8b3c
Value of *ip variable: 20
NULL Pointers
It is always a good practice to assign a NULL value to a
pointer variable in case you do not have an exact address to
be assigned. This is done at the time of variable declaration.
A pointer that is assigned NULL is called a null pointer.

The NULL pointer is a constant with a value of zero defined in

several standard libraries. Consider the following program −

Dr. Sujit Kumar Singh

 Pointer in C

#include <stdio.h>
int main () {
int *ptr = NULL;
printf("The value of ptr is : %x\n", ptr );
return 0;
}
When the above code is compiled and executed, it produces
the following result −
The value of ptr is 0−

Dr. Sujit Kumar Singh

 Pointer in C

In most of the operating systems, programs are not

permitted to access memory at address 0 because that
memory is reserved by the operating system. However, the
memory address 0 has special significance; it signals that
the pointer is not intended to point to an accessible memory
location. But by convention, if a pointer contains the null
(zero) value, it is assumed to point to nothing.
To check for a null pointer, you can use an 'if' statement as
follows −
if(ptr) /* succeeds if p is not null */
if(!ptr) /* succeeds if p is null */
Pointers in Detail
Pointers have many but easy concepts and they are very
important to C programming. The following important pointer
concepts should be clear to any C programmer −
Dr. Sujit Kumar Singh
 Pointer in C

Dr. Sujit Kumar Singh

 Strings in C

Strings are actually one-dimensional array of characters

terminated by a null character '\0'. Thus a null-terminated
string contains the characters that comprise the string
followed by a null.
The following declaration and initialization create a string
consisting of the word "Hello". To hold the null character at
the end of the array, the size of the character array
containing the string is one more than the number of
characters in the word "Hello."
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
If you follow the rule of array initialization then you can write
the above statement as follows −
char greeting[] = "Hello";
Following is the memory presentation of the above defined
string in C/C++ −
Dr. Sujit Kumar Singh
 Strings in C

Actually, you do not place the null character at the end of a

string constant. The C compiler automatically places the '\0'
at the end of the string when it initializes the array. Let us
try to print the above mentioned string −
#include <stdio.h>
int main () {
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
printf("Greeting message: %s\n", greeting );
return 0;
}
Dr. Sujit Kumar Singh
 Strings in C

When the above

code is compiled
and executed, it
produces the
following result −
Greeting
message: Hello
C supports a wide
range of
functions that
manipulate null-
terminated
strings −

Dr. Sujit Kumar Singh

 Strings in C

The following example uses some of the above-mentioned functions −

#include <stdio.h>
#include <string.h>
int main () {
char str1[12] = "Hello";
char str2[12] = "World";
char str3[12];
int len ;
/* copy str1 into str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );
/* concatenates str1 and str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 );
/* total lenghth of str1 after concatenation */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );
return 0;
} Dr. Sujit Kumar Singh
 Strings in C

When the above code is compiled and executed, it produces

the following result −
strcpy( str3, str1) : Hello
strcat( str1, str2): HelloWorld
strlen(str1) : 10

Dr. Sujit Kumar Singh

 C STRUCTURES

Arrays allow to define type of variables that can hold several

data items of the same kind. Similarly structure is another
user defined data type available in C that allows to combine
data items of different kinds.
Structures are used to represent a record. Suppose you want
to keep track of your books in a library. You might want to
track the following attributes about each book −
•Title
•Author
•Subject
•Book ID
Defining a Structure
To define a structure, you must use the struct statement. The
struct statement defines a new data type, with more than one
member. The format of the struct statement is as follows −
Dr. Sujit Kumar Singh
 C STRUCTURES

struct [structure tag] {

member definition;
member definition;
...
member definition;
} [one or more structure variables];
The structure tag is optional and each member definition is a
normal variable definition, such as int i; or float f; or any
other valid variable definition. At the end of the structure's
definition, before the final semicolon, you can specify one or
more structure variables but it is optional. Here is the way
you would declare the Book structure −

Dr. Sujit Kumar Singh

 C STRUCTURES

struct Books {
char title[50];
char author[50];
char subject[100];
int book_id;
} book;
Accessing Structure Members
To access any member of a structure, we use the member
access operator (.). The member access operator is coded as
a period between the structure variable name and the
structure member that we wish to access. You would use the
keyword struct to define variables of structure type. The
following example shows how to use a structure in a program
−
Dr. Sujit Kumar Singh
 C STRUCTURES
#include <stdio.h>
#include <string.h> strcpy( Book2.title, "Telecom Billing");
struct Books { strcpy( Book2.author, "Zara Ali");
char title[50]; strcpy( Book2.subject, "Telecom Billing
Tutorial");
char author[50];
Book2.book_id = 6495700;
char subject[100];
/* print Book1 info */
int book_id;
printf( "Book 1 title : %s\n", Book1.title);
};
printf( "Book 1 author : %s\n", Book1.author);
int main( ) {
printf( "Book 1 subject : %s\n", Book1.subject);
struct Books Book1; /*
Declare Book1 of type Book */ printf( "Book 1 book_id : %d\n",
Book1.book_id);
struct Books Book2; /*
/* print Book2 info */
Declare Book2 of type Book */
printf( "Book 2 title : %s\n", Book2.title);
/* book 1 specification */
printf( "Book 2 author : %s\n", Book2.author);
strcpy( Book1.title, "C
Programming"); printf( "Book 2 subject : %s\n", Book2.subject);
strcpy( Book1.author, "Nuha printf( "Book 2 book_id : %d\n",
Ali"); Book2.book_id);

strcpy( Book1.subject, "C return 0;

Programming Tutorial"); }
Book1.book_id = 6495407;
/* book 2 specification */
Dr. Sujit Kumar Singh
 C STRUCTURES

When the above code is compiled and executed, it produces

the following result −
Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700
Structures as Function Arguments
You can pass a structure as a function argument in the same
way as you pass any other variable or pointer.
Dr. Sujit Kumar Singh
 C STRUCTURES

Pointers to Structures
You can define pointers to structures in the same way as you
define pointer to any other variable −
struct Books *struct_pointer;
Now, you can store the address of a structure variable in the
above defined pointer variable. To find the address of a
structure variable, place the '&'; operator before the
structure's name as follows −
struct_pointer = &Book1;
To access the members of a structure using a pointer to that
structure, you must use the → operator as follows −

Dr. Sujit Kumar Singh

 C -unions

A union is a special data type available in C that allows to store

different data types in the same memory location. You can define
a union with many members, but only one member can contain a
value at any given time. Unions provide an efficient way of using
the same memory location for multiple-purpose.
Defining a Union
To define a union, you must use the union statement in the same
way as you did while defining a structure. The union statement
defines a new data type with more than one member for your
program. The format of the union statement is as follows −
union [union tag] {
member definition;
member definition;
...
member definition;
} [one or more union variables];
Dr. Sujit Kumar Singh
 C -unions

The union tag is optional and each member definition is a

normal variable definition, such as int i; or float f; or any other
valid variable definition. At the end of the union's definition,
before the final semicolon, you can specify one or more union
variables but it is optional. Here is the way you would define a
union type named Data having three members i, f, and str −
union Data {
int i;
float f;
char str[20];
} data;
Now, a variable of Data type can store an integer, a floating-
point number, or a string of characters. It means a single
variable, i.e., same memory location, can be used to store
multiple types of data. You can use any built-in or user defined
data types inside a union based on your requirement.
Dr. Sujit Kumar Singh
 C -unions

The memory occupied by a union will be large enough to hold the largest member
of the union. For example, in the above example, Data type will occupy 20 bytes of
memory space because this is the maximum space which can be occupied by a
character string. The following example displays the total memory size occupied by
the above union −
#include <stdio.h>
#include <string.h>
union Data {
int i;
float f;
char str[20];
};

int main( ) {
union Data data;
printf( "Memory size occupied by data : %d\n", sizeof(data));
return 0;
}
When the above code is compiled and executed,
Dr. Sujit Kumarit produces
Singh the following result −
 C -unions

Memory size occupied by data : 20

Accessing Union Members
To access any member of a union, we use
the member access operator (.). The
member access operator is coded as a
period between the union variable name
and the union member that we wish to int main( ) {
access. You would use the keyword union union Data data;
to define variables of union type. The data.i = 10;
following example shows how to use data.f = 220.5;
unions in a program − strcpy( data.str, "C
Live Demo Programming");
#include <stdio.h> printf( "data.i : %d\n", data.i);
printf( "data.f : %f\n", data.f);
#include <string.h>
printf( "data.str : %s\n",
union Data { data.str);
int i; retuRn 0;
float f; }
char str[20];
}; Dr. Sujit Kumar Singh
 C -unions

When the above code is compiled and executed, it produces

the following result −
data.i : 1917853763
data.f : 4122360580327794860452759994368.000000
data.str : C Programming
Here, we can see that the values of i and f members of union
got corrupted because the final value assigned to the
variable has occupied the memory location and this is the
reason that the value of str member is getting printed very
well.
Now let's look into the same example once again where we
will use one variable at a time which is the main purpose of
having unions −

Dr. Sujit Kumar Singh

 C -unions

data.f = 220.5;
#include <stdio.h> printf( "data.f : %f\n", data.f);
#include <string.h>
strcpy( data.str, "C Programming");
union Data { printf( "data.str : %s\n", data.str);
int i;
return 0;
float f; }
char str[20]; When the above code is compiled and
executed, it produces the following
}; result −
int main( ) {
data.i : 10
union Data data; data.f : 220.500000
data.i = 10; data.str : C Programming

printf( "data.i : %d\n",

data.i);

Dr. Sujit Kumar Singh

 C –FILE I/O

A file represents a sequence of bytes, regardless of it being a

text file or a binary file. C programming language provides
access on high level functions as well as low level (OS level)
calls to handle file on your storage devices. This chapter will
take you through the important calls for file management.
Opening Files
You can use the fopen( ) function to create a new file or to
open an existing file. This call will initialize an object of the
type FILE, which contains all the information necessary to
control the stream. The prototype of this function call is as
follows −
FILE *fopen( const char * filename, const char * mode );
Here, filename is a string literal, which you will use to name
your file, and access mode can have one of the following
values −

Dr. Sujit Kumar Singh

 C –FILE I/O

Dr. Sujit Kumar Singh

 C –FILE I/O

Closing a File
To close a file, use the fclose( ) function. The prototype of this
function is −
int fclose( FILE *fp );
The fclose(-) function returns zero on success, or EOF if there is
an error in closing the file. This function actually flushes any
data still pending in the buffer to the file, closes the file, and
releases any memory used for the file. The EOF is a constant
defined in the header file stdio.h.
There are various functions provided by C standard library to
read and write a file, character by character, or in the form of a
fixed length string.
Writing a File
Following is the simplest function to write individual characters
to a stream −
int fputc( int c, FILE *fpDr.
); Sujit Kumar Singh
 C –FILE I/O

The function fputc() writes the character value of the argument c to the output
stream referenced by fp. It returns the written character written on success
otherwise EOF if there is an error. You can use the following functions to write a
null-terminated string to a stream −
int fputs( const char *s, FILE *fp );
The function fputs() writes the string s to the output stream referenced by fp. It
returns a non-negative value on success, otherwise EOF is returned in case of
any error. You can use int fprintf(FILE *fp,const char *format, ...) function as well
to write a string into a file. Try the following example.
Make sure you have /tmp directory available. If it is not, then before
proceeding, you must create this directory on your machine.
#include <stdio.h>
main() {
FILE *fp;
fp = fopen("/tmp/test.txt", "w+");
fprintf(fp, "This is testing for fprintf...\n");
fputs("This is testing for fputs...\n", fp);
fclose(fp);
} Dr. Sujit Kumar Singh
 C –FILE I/O

When the above code is compiled and executed, it creates a new file
test.txt in /tmp directory and writes two lines using two different functions.
Let us read this file in the next section.
Reading a File
Given below is the simplest function to read a single character from a file −
int fgetc( FILE * fp );
The fgetc() function reads a character from the input file referenced by fp.
The return value is the character read, or in case of any error, it returns
EOF. The following function allows to read a string from a stream −
char *fgets( char *buf, int n, FILE *fp );
The functions fgets() reads up to n-1 characters from the input stream
referenced by fp. It copies the read string into the buffer buf, appending a
null character to terminate the string.
If this function encounters a newline character '\n' or the end of the file EOF
before they have read the maximum number of characters, then it returns
only the characters read up to that point including the new line character.
You can also use int fscanf(FILE *fp, const char *format, ...) function to read
strings from a file, but it stops reading after encountering the first space
character.}
Dr. Sujit Kumar Singh
 C –FILE I/O

The C programming language provides several functions for

memory allocation and management. These functions can be
found in the <stdlib.h> header file.

Dr. Sujit Kumar Singh

 C –FILE I/O

Allocating Memory Dynamically

While programming, if you are aware of the size of an array,
then it is easy and you can define it as an array. For example,
to store a name of any person, it can go up to a maximum of
100 characters, so you can define something as follows −
char name[100];
But now let us consider a situation where you have no idea
about the length of the text you need to store, for example,
you want to store a detailed description about a topic. Here
we need to define a pointer to character without defining
how much memory is required and later, based on
requirement, we can allocate memory as shown in the below
example −

Dr. Sujit Kumar Singh

 C –FILE I/O

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
char name[100];
char *description;
strcpy(name, "Zara Ali");
/* allocate memory dynamically */
description = malloc( 200 * sizeof(char) );
if( description == NULL ) {
fprintf(stderr, "Error - unable to allocate required memory\n");
} else {
strcpy( description, "Zara ali a DPS student in class 10th");
}
printf("Name = %s\n", name );
printf("Description: %s\n", description );
} Dr. Sujit Kumar Singh
 C –FILE I/O
When the above code is compiled and executed, it produces the
following result.
Name = Sony Singh
Description: Sony Singh DPS student in class 10th
Same program can be written using calloc(); only thing is you need to
replace malloc with calloc as follows −
calloc(200, sizeof(char));
So you have complete control and you can pass any size value while
allocating memory, unlike arrays where once the size defined, you
cannot change it.
Resizing and Releasing Memory
When your program comes out, operating system automatically release
all the memory allocated by your program but as a good practice when
you are not in need of memory anymore then you should release that
memory by calling the function free().
Alternatively, you can increase or decrease the size of an allocated
memory block by calling the function realloc(). Let us check the above
program once again and make use of realloc() and free() functions −

Dr. Sujit Kumar Singh

 C –COMMAND LINE ARGUMENTS

It is possible to pass some values from the command line to your C programs when
they are executed. These values are called command line arguments and many times
they are important for your program especially when you want to control your program
from outside instead of hard coding those values inside the code.
The command line arguments are handled using main() function arguments where argc
refers to the number of arguments passed, and argv[] is a pointer array which points to
each argument passed to the program. Following is a simple example which checks if
there is any argument supplied from the command line and take action accordingly −
#include <stdio.h>
int main( int argc, char *argv[] ) {
if( argc == 2 ) {
printf("The argument supplied is %s\n", argv[1]);
}
else if( argc > 2 ) {
printf("Too many arguments supplied.\n");
}
else {
printf("One argument expected.\n");
}
}
Dr. Sujit Kumar Singh
 C –COMMAND LINE ARGUMENTS

When the above code is compiled and executed with single

argument, it produces the following result.
$./a.out testing
The argument supplied is testing
When the above code is compiled and executed with a two
arguments, it produces the following result.
$./a.out testing1 testing2
Too many arguments supplied.
When the above code is compiled and executed without passing any
argument, it produces the following result.
$./a.out
One argument expected
It should be noted that argv[0] holds the name of the program itself
and argv[1] is a pointer to the first command line argument
supplied, and *argv[n] is the last argument. If no arguments are
supplied, argc will be one, and if you pass one argument then argc is
set at 2. Dr. Sujit Kumar Singh
 C –COMMAND LINE ARGUMENTS

You pass all the command line arguments separated by a space, but if
argument itself has a space then you can pass such arguments by putting
them inside double quotes "" or single quotes ''. Let us re-write above example
once again where we will print program name and we also pass a command
line argument by putting inside double quotes −
#include <stdio.h>
int main( int argc, char *argv[] ) {
printf("Program name %s\n", argv[0]);
if( argc == 2 ) {
printf("The argument supplied is %s\n", argv[1]);
}
else if( argc > 2 ) {
printf("Too many arguments supplied.\n");
}
else {
printf("One argument expected.\n");
}
} Dr. Sujit Kumar Singh
 C –COMMAND LINE ARGUMENTS

When the above code is compiled and executed with a single

argument separated by space but inside double quotes, it
produces the following result.
$./a.out "testing1 testing2"
Program name ./a.out
The argument supplied is testing1 testing2

Dr. Sujit Kumar Singh

 C –COMMAND LINE ARGUMENTS

When the above code is compiled and executed with a single

argument separated by space but inside double quotes, it
produces the following result.
$./a.out "testing1 testing2"
Program name ./a.out
The argument supplied is testing1 testing2

Dr. Sujit Kumar Singh