LEARN C PROGRAMMING STEP BY STEP -Gopal Raha Many people are really interested in learning and implementing C programs on their favorite platforms like DOS/Windows or Linux. If you are the one looking for a step-by-step guide to get started, this tutorial is for you.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
LEARN C PROGRAMMING STEP BY STEP -Gopal Raha
Many people are really interested in learning and implementing C programs on their favorite
platforms like DOS/Windows or Linux. If you are the one looking for a step-by-step guide to get
started, this tutorial is for you.
P a g e | 1
LEARN C PROGRAMMING
STEP BY STEP
-Gopal Raha
P a g e | 2
Dedicated to
My Dad,Mom and Gore Sir,
Who inspire me to write this book.
P a g e | 3
Preface
What is a programming language?--Human beings need language to communicate between
them. Similarly to communicate with computers we need a programming language. All the
events in life can be communicated to computers with the help of programming language. C
is the basic of all programming language. Before the introduction of C we had only Machine
level languages. C is just like any other communication Language.
If you learn C programming thoroughly you can easily learn other programming
languages. To learn C we just need to know the syntax of C program only. i.e order in which
we have to write the contents.This book is intended to introduce C programming to beginning
programmers. Over several years of studying, I have noted a large number of students appear
to have difficulty in grasping the fundamentals of C Language. So I am trying to explain
them with the help of simple examples.
This book will help you get a quick start with C programming. This book is a guide
for the beginners and also for those who have little knowledge on C Programming
fundamentals.
There are different types of programming languages such as Structure oriented,
Object oriented etc. C is the most commonly used Structure oriented programming language.
Compiler for some languages are developed using C only. With the help of this tutorial I am
trying to explain all the basics of C.In order to successfully complete this tutorial, you won't
need any prior knowledge of the C programming language. First of all I will start with the
most basic concepts and take you up to the highest level of C programming including the
usually intimidating concepts of structures, union,file, pointers and dynamic memory
allocation,etc.
Once you have mastered C, you will find Object Oriented Language such as
c++,java, etc are easy to learn.
So let's start our Journey.........
-AUTHOR
P a g e | 4
Contents
1. Introduction 5
2. Turbo C++ IDE 6
3. A Basic C Program 8
4. Fundamentals 12
5. Input/Output Functions 37
6. Control Statements 44
7. Arrays 58
8. Strings 65
9. Functions 92
10. Storage Classes 98
11. Structure 102
12. Union 107
13. Pointers 110
14. Dynamic memory allocation 114
15. File 126
16. Graphics 138
17. The C Preprocessor 183
18. Standard Library Functions 185
19. Examples 187
20. Reference 191
P a g e | 5
Introduction To C Programming Language
The C language was invented at Bell Labs by Dennis Ritchie in 1972 to allow the writing of
the UNIX operating system, then developed by Ken Thompson and Dennis Ritchie.
The UNIX operating system, born in the late 1960s – early 1970s, was written
directly in assembly language for the machines which it was intended. Born in the late 1960s
– early 1970s, was written directly in assembly language for the machines which it was
intended. If the assembly language for writing such a system, it was nevertheless not easy to
use. Such language is in fact a particular type of processor, which makes the whole system
should be rewritten to make it work on a new architecture. This is its main creator, Ken
Thompson, wanted to use a language more quickly evolved to rewrite UNIX.
Among the languages available at the time, BCPL (Basic Combined
Programming Language for, which is a simplification of CPL), created by Martin Richards in
1966, was interesting. Without going into detailed descriptions, BCPL is a simple language,
procedural, and not typed. Its simplicity makes it easy to create BCPL compilers on machines
of the time, when resources were very limited (the first computer used by Keith Thompson
was to launch a Unix PDP-7, which had a memory of 4000 words 18 bits, or less than 9 KB).
Ken Thompson has evolved to design the B language, which he implemented the first UNIX
machines. However, some limitations of language B were UNIX could be rewritten in this
language.
From 1971, Dennis Ritchie B did evolve to address these issues. Like the
programmers increment versions of their programs, Ritchie “Nudge” the letter B to call the
new language C. This evolution is “stabilized” to 1973, from which UNIX and UNIX system
utilities have been rewritten successfully in C.
Subsequently in 1978, Brian W. Kernighan documentation very active
language, and finally publish the book with reference Ritchie The C Programming
Language. Often called K & R C language as specified in the first edition of this book.
In the years that followed, the C language was carried on many other machines.
These ports were often made at the beginning, from the pcc compiler Steve Johnson, but then
the original compilers were developed independently. During these years, every C compiler
was written in accordance with the specifications of K & R, but some added extensions, such
as data types or additional features, or different interpretations of certain parts of the book
(not necessarily very precise). Because of this, it was less easy to write C programs that can
run unchanged on many architectures.
P a g e | 6
Turbo C++ Integrated Development
Environment
IDE is nothing but Integrated Development Environment in which one can develop,
run, test and debug the application. The Turbo C++ IDE appears as shown in figure.
The C Developing Environment is a screen display with windows and pull-down
menus. The program listing, error messages and other information are displayed in separate
windows. The menus may be used to invoke all the operations necessary to develop the
program, including editing, compiling, linking, and debugging and program execution. If the
menu bar is inactive, it may be invoked by pressing the [F10] function key. To select
different menu, move the highlight left or right with cursor (arrow) keys. You can also revoke
the selection by pressing the key combination for the specific menu.
Invoking the Turbo C IDE
The default directory of Turbo C compiler is c:\tc\bin. So to invoke the IDE from the
windows you need to double click the TC icon in the directory c:\tc\bin.
The alternate approach is that we can make a shortcut of tc.exe on the desktop.
Opening New Window in Turbo C
To type a program, you need to open an Edit Window. For this, open file menu and click
“new”. A window will appear on the screen where the program may be typed.
Writing a Program in Turbo C
P a g e | 7
When the Edit window is active, the program may be typed. Use the certain key
combinations to perform specific edit functions.
Saving a Program in Turbo C
To save the program, select save command from the file menu. This function can also be
performed by pressing the [F2] button. A dialog box will appear asking for the path and name
of the file.Provide an appropriate and unique file name. You can save the program after
compiling too but saving it before compilation is more appropriate.
Making an Executable File in Turbo C
The source file is required to be turned into an executable file. This is called “Making” of the
.exe file. The steps required to create an executable file are:
1. Create a source file, with a .c extension.
2. Compile the source code into a file with the .obj extension.
3. Link your .obj file with any needed libraries to produce an executable program
All the above steps can be done by using Run option from the menu bar or using key
combination Ctrl+F9 (By this linking & compiling is done in one step).
Compiling and linking in the Turbo C IDE
In the Turbo C IDE, compiling and linking can be performed together in one
step. There are two ways to do this: you can select Make EXE from the compile menu, or you
can press the [F9] key
Correcting Errors in Turbo C
If the compiler recognizes some error, it will let you know through the Compiler window.
You’ll see that the number of errors is not listed as 0, and the word “Error” appears instead
of the word “Success” at the bottom of the window. The errors are to be removed by
returning to the edit window. Usually these errors are a result of a typing mistake. The
compiler will not only tell you what you did wrong, they’ll point you to the exact place in
your code where you made the mistake.
Executing a Programs in Turbo C
If the program is compiled and linked without errors, the program is executed by selecting
Run from the Run Menu or by pressing the [Ctrl+F9] key combination.
Exiting Turbo C IDE
An Edit window may be closed in a number of different ways. You can click on
the small square in the upper left corner, you can select close from the window menu, or you
can press the Alt+F3 combination. To exit from the IDE, select Exit from the File Menu or
press Alt+X Combination.
P a g e | 8
A Simple C Program
Every C program must have one special function main (). This is the point where
execution begins when the program is running. We will see later that this does not have to be
the first statement in the program, but it must exist as the entry point. The group
of statements defining the main () enclosed in a pair of braces ({}) are executed
sequentially. Each expression statement must end with a semicolon. The closing brace of the
main function signals the end of the program. The main function can be located anywhere in
the program but the general practice is to place it as the first function.
Here is an elementary C program.
Main ()
{
}
There is no way to simplify this program, or to leave anything out. Unluckily, the
program does not do anything. Following the “main” program name is a couple of
parentheses, which are an indication to the compiler that this is a function. The 2 curly
brackets { }, properly called braces, are used to specify the limits of the program itself. The
actual program statements go between the 2 braces and in this case, there are no statements
because the program does absolutely nothing. You will be able to compile and run this
program, but since it has no executable statements, it does nothing. Keep in mind however,
that it is a legal C program.
Main ( ) function should return zero or one.Turbo C accepts both int and void main ( ) and
Turbo C coders use both int and void main ( ) in their programs.But in my belief, void main (
) is not a standard usage. The reason is, whenever a program gets executed it returns an
integer to the OS. If it returns ‘zero’, the program is executed successfully. Otherwise it
means the program has been ended with error. So main ( ) shouldn’t be declared as void.d as
void.
Main( ) should be declared as
int main( )
{
……………..
……………..
return 0 ;
}
.For a much more interesting program, load the program
P a g e | 9
int main ()
{
printf (“Welcome to C language”);
return 0;
}
and display it on your monitor. It is same as the previous program except that it has one
executable statement between the braces.
The executable statement is another function. Again, we won’t care about what a
function is, but only how to use this one. In order to output text to the monitor, it’s placed
within the function parentheses and bounded by quotes. The end result is that whatever is
included between the quotes will be showed on the monitor when the program is run.
Notice the semi-colon; at the end of the line. C uses a semi-colon as a statement
terminator, so semi-colon is required as a signal to the compiler that this line is complete.
This program is also executable, so you’ll be able to compile and run it to see if it does what
you think it should. With some compilers, you may get an error message while compiling,
indicating that the function printf () should have a prototype.
#include<stdio.h>
#include<conio.h>
int main ()
{
printf (“Welcome to C language”);
return 0;
}
Here you’ll be able to see #include at the beginning of the program. It is a pre-
processor directive. It’s not a part of our program; it’s an instruction to the compiler to make
it do something. It says the C compiler to include the contents of a file, in this case the system
file stdio.h. This is the name of the standard library definition file for all Standard Input
Output. Your program will almost certainly want to send stuff to the screen and read things
from the keyboard. Stdio.h is the name of the file in which the functions that we want to use
are defined. A function is simply a group of related statements that we can use later. Here the
function we used is printf . To use printf correctly C needs to know what it looks like, i.e.
what things it can work on and what value it returns. The actual code which performs the
printf will be tied in later by the linker. Note that without the definition of what printf looks
like the compiler makes a guess when it sees the use of it. This can lead to the call failing
when the program runs, a common cause of programs crashing.
P a g e | 10
The <> characters around the name tell C to look in the system area for the file
stdio.h. If I had given the name “abc.h” instead it would tell the compiler to look in the
current directory. This means that I can arrange libraries of my own routines and use them in
my programs.
Imagine you run above program and then change it and run it again you may find
that the previous output is still stucked there itself, at this time clrscr(); would clear the
previous screen.
One more thing to remember while using clrscr() is that it should be called only after the
variable declaration, like
int p,q,r;
clrscr()
Here is an example of minimal C program that displays the string Welcome to C language
(this famous example included in all languages moreover been done originally in C in 1978
from the creators of the language, Brian Kernighan and Dennis Ritchie) Example
#include<stdio.h>
#include<conio.h>
int main ()
{
clrscr();
printf (“Welcome to C language”);
return 0;
}
When you execute above program you won’t see ‘Welcome to C language’ on
the console because the screen will just flash and go away .If you want to see the line you
can use getch() function just below the printf() statement. Actually it waits until a key is
pressed.
Example:
P a g e | 11
P a g e | 12
Fundamentals
1. Identifiers
Identifiers are the names that are given to various program elements such as variables,
symbolic constants and functions.Variable or function identifier that is called a symbolic
constant name.
Identifier can be freely named, the following restrictions.
Alphanumeric characters ( a ~ z , A~Z , 0~9 ) and half underscore ( _ ) can only be used.
The first character of the first contain letters ( a ~ z , A~Z ) or half underscore ( _ ) can only be used.
Case is distinguishable. That is, word and WORD is recognized as a separate identifier. Reserved words are not allowed. However, part of an identifier reserved words can be
included.
Here are the rules you need to know:
1. Identifier name must be a sequence of letter and digits, and must begin with a
letter.
2. The underscore character (‘_’) is considered as letter.
3. Names shouldn't be a keyword (such as int , float, if ,break, for etc)
4. Both upper-case letter and lower-case letter characters are allowed. However,
they're not interchangeable.
5. No identifier may be keyword.
6. No special characters, such as semicolon,period,blank space, slash or comma
are permitted
Examples of legal and illegal identifiers follow, first some legal identifiers:
float _number;
float a;
int this_is_a_very_detailed_name_for_an_identifier;
The following are illegal (it's your job to recognize why):
float :e;
float for;
P a g e | 13
float 9PI;
float .3.14;
float 7g;
Example :
P a g e | 14
2. Keywords
Keywords are standard identifiers that have standard predefined meaning in C.
Keywords are all lowercase, since uppercase and lowercase characters are not equivalent it's
possible to utilize an uppercase keyword as an identifier but it's not a good programming
practice.
Points to remember
1. Keywords can be used only for their intended purpose.
2. Keywords can't be used as programmer defined identifier.
3. The keywords can't be used as names for variables.
The standard keywords are given below:
P a g e | 15
3. Data Types
C offers a standard, minimal set of basic data types. Sometimes these are called
"primitive" types. A lot of complex data structures can be developed from these basic data
types. The C language defines 4 fundamental data types:
character
integer
floating-point and
double floating-point
This data types are declared using the keywords char,int,float and double respectively.
Typical memory requirements of the basic data types are given below
The size and range of these data types may vary among processor types and
compilers. Data type qualifiers modify the behavior of variable type to which they are
applied. Data type qualifiers can be classified into two types.two types.
1. size qualifiers
2. sign qualifiers
Size qualifiers:
Size qualifiers alter the size of the basic data types. There are two size qualifiers that
can be applied to integer: short and long.
The minimum size of short int is 16 bit. The size of int must be greater than or equal to that of
a short int. The size of long int must be greater than or equal to a short int. The minimum size
of a long int is 32 bits.
Sign qualifiers:
The keywords signed and unsigned are the two sign qualifiers that specify whether a
variable can hold both –ve and +ve numbers, or only +ve numbers. These qualifiers can be
applied to the data types int and char only.
Example: unsigned int I;
The following table shows all valid data type combinations supported by C, along
with their minimal ranges and typical memory size.
P a g e | 16
P a g e | 17
4. int
An integer is a whole number (a number without a fractional part). It can
be positive or negative numbers like 1, -2, 3, etc., or zero.
The sizes of the integer variables depend on the hardware and operating system
of the computer. On a typical 16-bit system, the sizes of the integer types are as follows.
TYPE Bytes Possible Values le Values
int
2 or 4
-32,767 to 32,767
unsigned
int
2 or 4
0 to 65,535
signed
int
2 or 4
-32,767 to 32,767
short int
2
-32,767 to 32,767
unsigned short int 2
0 to 65,535
signed short int
2
-32,767 to 32,767
long int
4
-2,147,483,647 to 2,147,483,647
signed long
int
4
-2,147,483,647 to 2,147,483,647
unsigned long
int
4
0 to 4,294,967,295
Example:
P a g e | 18
P a g e | 19
5. char
char is a special integer type designed for storing single characters. The integer
value of a char corresponds to an ASCII character. E.g., a value of 65 corresponds to the
letter A, 66 corresponds to B, 67 to C, and so on.
As in the table below, unsigned char permits values from 0 to 255, and signed
char permits values from -127 (or -128) to 127. The char type is signed by default on some
computers, but unsigned on others the sizes of the char types are as follows.
Type Bytes Minimal range
char 1 -127 to 127
unsigned char 1 0 to 255
signed char 1 -127 to 127
Example:
P a g e | 20
6. Float
Floating point numbers are numbers with a decimal point. The float type can take
large floating point numbers with a small degree of precision (Precision is simply the number
of decimal places to which a number can be calculated with accuracy. If a number can be
calculated to three decimal places, it is said to have three significant digits.)
Memory size : 4 bytes
Minimal range : IE-38 to IE+38 with six digit of precision
Example:
P a g e | 21
7. Double
Double-precision floating point numbers are also numbers with a decimal point.
We know that the float type can take large floating point numbers with a small degree of
precision but the double-precision double type can hold even larger numbers with a higher
degree of precision.
The sizes of the double types are as follows.
Type Bytes Minimal range
doubleprecision 8 IE-38 to IE+38 with 10 digit of precision
long double 8 IE-38 to IE+38 with 10 digit of precision
Example:
P a g e | 22
8. Constants
The term constant means that it does not change during the execution of program.
There are four basic types of constants in C. They are:
1.Integer constants
2.Floating-point constants
3.Character constants
4.String constants
Integer and floating-point constants represent numbers. They are often referred to
as numeric-type constants. The following rule applies to all numeric type constants:
Comma and blank spaces cannot be included within the constants.
Constants can be preceded by a – or + sign, if desired. If either sign does not precede
the constant it is assumed to be positive.
The value of a constant cannot exceed specified minimum and maximum bounds. For
each type of constant, these bound vary from one C compiler to another.
P a g e | 23
9. Integer constants
Integer constants are whole numbers without any fractional part. Thus integer
constants consist of a sequence of digits. Integer constants can be written in three different
number systems: Decimal, Octal and Hexadecimal.
A decimal integer constant consists of any combination of digits taken from the
set 0 through 9. If the decimal constant contains two or more digits, the first digit must be
something other than 0. The following are valid decimal integer constants.
0 1 1234 -786
Example:
The following decimal integer constants are written incorrectly for the reasons stated.
12,001 Illegal character (,).
103.0 Illegal decimal point (.).
10 20 30 Illegal character (blank space).
045 First digit cannot be zero.
Example:
P a g e | 24
An octal integer constant can consist any combination of digits taken from the set
0 through 7. However, the first digit must be 0, in order to identify the constant as an octal
number. The following are valid octal integer constants.
0 01 0125 0555
Example :
The following decimal integer constants are written incorrectly for the reasons stated.
2010 Does not begin with 0.
2008 Illegal digit (8).
05.10 Illegal character (.).
P a g e | 25
A hexadecimal integer constant must begin with either 0x or 0X. It can then be followed by
any combination of digits taken from the set 0 through 9 and A through F (either upper-case
or lower-case). The following are valid hexadecimal integer constants.
0X0 0x1 0XAB125 -0x555
Example:
The following hexadecimal integer constants are written incorrectly for the reasons stated.
0x20.10 Illegal character (.).
02008 Does not begins with 0x or 0X.
0xabcdefg Illegal character (g).
P a g e | 26
10. Floating-point constants
A floating-point constant is a base-10 number that contains either a decimal point
or an exponent or both. A floating-point constant can be written in two forms: Factorial form
or Exponential form. A floating-point constant in a fractional form must have at least one
digit each to the left and right of the decimal point. A floating-point in exponent form
consists of a mantissa and an exponent. The mantissa itself is represented as a decimal integer
constant or a decimal floating-point constant in fractional form. The letter E or e and the
exponent follow the mantissa. The exponent must be a decimal integer. The actual number of
digits in the mantissa and the exponent depends on the computer being used.
The following are valid floating-point constants.</1.0 0.1 2E-4 -0.1555e-4
The following floating-point constants are written incorrectly for the reasons stated.written
incorrectly for the reasons stated.
1 No decimal point or exponent.
2,00.8 Illegal character (,).
2 E+10.20 Exponent must be an integer.
3 E10 Illegal character (space).
Example:
P a g e | 27
11. Character constants
A character constant is a single character, enclosed in single quotation marks.
e.g., ‘A’ ‘B’ ‘1’
Characters are stored internally in computer as coded set of binary digits, which have
positive decimal integer equivalents. The value of a character constant is the numeric value of
the character in the machine’s character set. This means that the value of a character constant
can vary from one machine to the next, depending on the character set being used on the
particular machine. For example, on ASCII machine the value of ‘A’ is 65 and on EBCDIC
machine it is 193.
Example:
P a g e | 28
12. String constants
A string constant consists of zero or more character enclosed in quotation marks.
Several string constants are given below.
“Welcome to C Programming” “ ”
“a+b\n” “Error\a\a\a”
There is a difference between the constant ‘A’ and “A” in C, the first ‘A’ is a
character constant while the second “A” is string constant. The notation ‘A’ is a constant
occupying a single byte containing the ASCII code of the character A. The notation “A” on
the other hand ,is a constant that occupies two bytes one for ASCII code of A and another for
the null character with the value 0,that terminates all the string.
Example:
P a g e | 29
13. Variables
Variables are means for location in memory used by a program to store data. The
size of that block depends upon the range over which the variable is allowed to vary.
For example, on personal computer the size of an integer variable is two bytes, and that of a
long integer is four bytes.
A variable region is temporarily remember a number or string value, such as covered by the
program. To identify the variables, you have a name unique to every single variable. This is
called a variable name. Before using a variable, use variables to what is called a variable
declaration that you have to reveal the names and data types that can be stored in the variable
variable.
The format for declaring a variable in C.
[Storage-class] type data variable name [= initial value];
Storage class and the initial value can be omitted.
The same data type and storage class variable can be declared, separated by commas.
[Storage-class] type data variable name [= initial value] variable [= initial value] variable [=
initial value];
In C the size of a variable type such as an integer need not be the same on all types
of machines. When we declare a variable we inform the compiler of two things, the name of
the variable and the type of the variable. For example, we declare a variable of type character
with the name i by writing:
char i;
On seeing the "char" part of this statement the compiler sets aside one bytes of
memory to hold the value of the character. It also sets up a symbol table. In that table it adds
the symbol i and the relative address in memory where those one byte was set aside. Thus,
later if we write: i = 'x'; we expect that,at run time when this statement is executed, the value
'x' will be placed in that memory location reserved for the storage of the value of i.
Following are the rules for naming the variables:
1. All variables must be declared before they can appear in executable statement.
2. A declaration consists of a data type followed by one or more variable names
separated by commas.
Example: int a,b,c;
3. Variables can be distributed among declarations in any fashion. The above declaration
can be written as
int a;
P a g e | 30
int b,c;
4. Integer type variables can be declared to be short integer for smaller integer quantities
or long integer for larger integer quantities.
Example:
short int a,b,c;
long int a,b,c;
5. An integer variable can also be declared to be un signed by writing unsigned int.
Example: unsigned int;
Example:
P a g e | 31
14. Expressions
An expression is a sequence of operators and operands that specifies computation of
a value. An expression may consist of single entity or some combination of such entities
interconnected by one or more operators. All expression represents a logical connection that's
either true or false. Thus logical type expression actually represents numerical quantities.
In C every expression evaluates to a value i.e., every expression results in some
value of a certain type that can be assigned to a variable. Some examples of expressions are
shown in the table given below.
A+b
3.14*r*r
a*a+2*a*b+b*b
Example:
P a g e | 32
15. Statements
The statements of a C program control the flow of program execution.In C
language several kinds of statements are available. They are
if statement
switch statement
goto statement
for statement
while statement
do-while statement
break statement
continue statement
expression statement
compound statement
return statement
null statement
P a g e | 33
16. Symbolic constant in c Language
A symbolic constant is name that substitute for a sequence of character that
cannot be changed. The character may represent a numeric constant, a character constant, or a
string. When the program is compiled, each occurrence of a symbolic constant is replaced by
its corresponding character sequence. They are usually defined at the beginning of the
program. The symbolic constants may then appear later in the program in place of the
numeric constants, character constants, etc., that the symbolic constants represent.
For example
, a C program consists of the following symbolic constant definitions.
#define PI 3.141593
#define TRUE 1
#define FALSE 0
#define PI 3.141593 defines a symbolic constant PI whose value is 3.141593. When the
program is preprocessed, all occurrences of the symbolic constant PI are replaced with the
replacement text 3.141593.
Note that the preprocessor statements begin with a #symbol, and are not end with a
semicolon. By convention, preprocessor constants are written in UPPERCASE.
Example: 1
#include<stdio.h>
#include<conio.h>
#define TRUE 1
#define PI 3.141593
void main()
{
float a;
float b;
float c;
float d=PI;
clrscr();
if(TRUE)
{
a=100;
b=a*10;
c=b-a;
}
printf("\na=%f\nb=%f\nc=%f\nPI=%f",a,b,c,d);
getch();
}
Example: 2
P a g e | 34
P a g e | 35
17. Operators
An operator in general, is a symbol that operates on a certain data type. C
language is very rich in operators. The commonly used operators include
1. Arithmetic operators
2. Relational operators
3. Logical operators
4. Assignment operators
5. Conditional operators
6. Comma operators
7. Unary operators
8. Bitwise Operators
P a g e | 36
18. Comments
Comments are added to make a program more readable to you but the compiler
must ignore the comments. Everything that is inside /* and */ is considered a comment and
will be ignored by the compiler. You must not include comments within other comments, so
something like this is not allowed: [*].
/* this is a /* comment */ inside a comment, which is wrong! */
Example :
P a g e | 37
Input/Output Function
1. scanf
The usually used input statement is scanf () function.
Syntax of scanf function is
scanf (“format string”, argument list);
The format string must be a text enclosed in double quotes. It contains the
information for interpreting the entire data for connecting it into internal representation in
memory.
Example: integer (%d) , float (%f) , character (%c) or string (%s).
The argument list contains a list of variables each preceded by the address list and
separated by comma. The number of argument is not fixed; however corresponding to each
argument there should be a format specifier. Inside the format string the number of argument
should tally with the number of format specifier.
Example: if i is an integer and j is a floating point number, to input these two
numbers we may use
scanf (“%d%f”, &i, &j);
Program:
P a g e | 38
2. getchar
getchar function will accept a character from the console or from a file, displays
immediately while typing and we need to press Enter key for proceeding.
Syntax of getchar() is
int getchar(void);
It returns the unsigned char that they read.If end-of-file or an error is encountered
getchar() functions return EOF.
For example:
char a;
a= getchar();
The function "getchar()" reads a single character from the standard input device,
the keyboard being assumed because that is the standard input device, and assigns it to the
variable "a".
The following program illustrates the use of getchar function.
P a g e | 39
3. gets
It is used to scan a line of text from a standard input device. The gets() function
will be terminated by a newline character. The newline character won't be included as part of
the string. The string may include white space characters.
Syntax : char *gets(char *s);
gets() function is declared in the header file stdio.h. It takes a single argument. The
argument must be a data item representing a string. On successful completion, gets() shall
return a pointer to string s.
The usage of gets() is illustrated in the following program.
P a g e | 40
4. printf
The usually used output statement is printf (). It is one of the library functions.
Syntax : printf (“format string”, argument list);
Format string may be a collection of escape sequence or/and conversion
specification or/and string constant. The format string directs the printf function to display the
entire text enclosed within the double quotes without any change.
Escape sequence:
Escape sequence is a pair of character. The first letter is a slash followed by a
character. Escape sequence help us to represent within the format string invisible and non-
printed character although there are physically two characters in any escape sequence. It
actually represents only one. The various escape sequences are
Escape sequence Meaning
\n New line
\t Tab
\b Back space
\a Bell
\o Null character
\? To print question mark
\\ To print slash
\' To print single quote
\" To print double quote
Conversion specification:
Conversion specification is also a pair of character. it is preceded by % and
followed by a quote which may be a character. The Conversion specification inscribes the
printf() function that it could print some value at that location in the text. The Conversion
characters supported by C are
Conversion character Meaning
P a g e | 41
%d Data item is displayed as a signed decimal integer.
%i Data item is displayed as a single decimal integer.
%f Data item is displayed as a floating-point value without
an exponent.
%c Data item is displayed as a single character.
%e Data item is displayed as a floating-point value with an
exponent.
%g Data item is displayed as a floating-point value using
either e-type or f-type conversion depending on value.
%o Data item is displayed as an octal integer, without a
leading zero.
%s Data item is displayed as string.
%u Data item is displayed as an unsigned decimal integer.
%x Data item is displayed as a hexadecimal integer,
without a leading 0x.
The following program illustrates the use of puts function.
P a g e | 42
5. putchar
putchar function displays a single character on the screen.
prototype: int putchar(int c);
The following program illustrates the use of putchar function.
P a g e | 43
6. puts
It is used to display a string on a standard output device. The puts() function
automatically inserts a newline character at the end of each string it displays, so each
subsequent string displayed with puts() is on its own line. puts() returns non-negative on
success, or EOF on failure.
The following program illustrates the use of puts function.
P a g e | 44
Control Statement
1. if statements
If statement is a conditional branching statement. In conditional branching
statement a condition is evaluated, if it is evaluate true a group of statement is executed. The
simple format of an if statement is as follows:
if (expression)
statement;
If the expression is evaluated and found to be true, the single statement following
the "if" is executed. If false, the following statement is skipped. Here a compound statement
composed of several statements bounded by braces can replace the single statement.
Here's an example program using simple if statement:
if else statement:
This feature permits the programmer to write a single comparison, and then
execute one of the two statements depending upon whether the test expression is true or false.
The general form of the if-else statement is
if(expression)
statement1
P a g e | 45
else
statement2
Here also expression in parentheses must evaluate to (a boolean) true or false.
Typically you're testing something to see if it's true, and then running a code block(one or
more statements) if it is true, and another block of code if it isn't. The statement1 or
statement2 can be either simple or compound statement.
The following program demonstrates a legal if else statement:
You can set up an if-else statement to test for multiple conditions. The following
example uses two conditions so that if the first test fails, we want to perform a second test
before deciding what to do:
if (x%2==0)
{
printf(“x is an even number”);
}
else
{
if (x>10)
{
printf(“x is an odd number and greater than 10”);
}
else
{
printf(“x is an odd number and less than 10”);
}
}
P a g e | 46
This brings up the other if-else construct, the if, else if, else. This construct is
useful where two or more alternatives are available for selection.
The syntax is
if(condition)
statement 1;
else if (condition)
statement 2;
.....................
.....................
else if(condition)
statement n-1;
else
statemens n ;
The various conditions are evaluated one by one starting from top to bottom, on
reaching a condition evaluating to true the statement group associated with it are executed
and skip other statements. If none of expression is evaluate to true, then the statement or
group of statement associated with the final else is executed.
The following program demonstrates a legal if-elseif-else statement:
P a g e | 47
2. c switch statement
Switch statements simulate the use of multiple if statement.The switch statement is
probably the single most syntactically awkward and error-prone feature of the C language.
Syntax of c switch statement is
switch(expression)
{
case constant1:
statements 1;
break;
case constant2:
statements 2;
break;
…………………..
default:
statements n;
break;
}
When the switch statement is executed, the expression in the switch statement is
evaluated and the control is transferred directly to the group of statements whose case label
value matches the value of the expression. Each group of statement ends with a break
statement. The execution of break statement causes immediate exit from the switch statement.
If break statement is not present, then the execution will falls trough all the statement in the
selected case. If none of the case-label value matches the value of expression, then none of
the group within the switch statement will be selected and the control is transferred directly to
the statement that follows the switch statement c.
The expression that forms the argument of switch is evaluated to either char or
integer. Similarly the constant expression follows the keyword case should be a value int or
char. That is, names of variable can also be used. Switch can test for only equality.
Take a look at the following if-else code, and notice how confusing it can be to
have nested if tests, even just a few levels deep:
int number = 10;
if(number == 1)
{
printf("Given number is 1\n");
}
else if((number == 2)
{
printf("Given number is 2\n");
}
else if((number ==3)
{
printf("Given number is 3\n");
}
P a g e | 48
else if((number ==4)
{
printf("Given number is 4\n");
}
else if((number ==5)
{
printf("Given number is 5\n");
}
else
{
if(number<0)
printf("Given number is negative\n");
else
printf("Given number is greater than 5\n");
}
Now let's see the same functionality represented in a switch construct:
It’s illegal to have more than one case label using the same value. For example, the
following block of code won't compile because it uses two cases with the same.
P a g e | 49
int temp = 100;
switch(temp)
{
case 10 : printf("10");
break;
case 10 : printf("10"); // won't compile!
break;
case 100 :printf("1000");
break;
default : printf("default");
break;
}
Break and Fall-Through in switch Blocks:
When case constants are evaluated from the top to down, and the first case
constant that matches the switch's expression is the execution entry point. In other words,
once a case constant is matched, C will execute the associated code block, and all subsequent
code blocks .
Example:
P a g e | 50
3. goto statement
The goto statement is used to alter the normal sequence of program execution by
transferring control to some other part of the program unconditionally. In its general form, the
goto statement is written as
goto label;
where the label is an identifier that is used to label the target statement to which
the control is transferred. Control may be transferred to anywhere within the current function.
The target statement must be labeled, and a colon must follow the label. Thus the target
statement will appear as
label:statement;
Each labeled statement within the function must have a unique label, i.e., no two statement
can have the same label.
The following program illustrates the use of goto statement.
P a g e | 51
4. For loop
For loop in C is the most general looping construct. The loop header contains three
parts: an initialization, a continuation condition, and step.
Syntax:
for (initialization, condition, step)
{
Statement 1;
Statement 2;
…………...
Statement n;
}
For statement contain three parts separated by two semicolons. The first part is
known as initialization. The variable called loop control variable or index variable is
initialized in this part.
The second part is known as the condition. The condition should be a value one. The
condition check can be a compound expression made up of relational expression connected
by logical AND, OR.
The third part is known as step. It should be an arithmetic expression. The
initialization need not be contained to a single variable. If more than one variable is used for
initialization they are separated by commas. The step can also applied to more than one
variable separated by commas.
When for statement is encountered at first index variable is get initialized. This
process is done only once during the execution of for statement. When condition is evaluated,
if it is true the body of the loop will be executed. If more than one statement has to be
executed it should end with a pair of braces. The condition of for loop is executed each time
at the beginning of the loop. After executing the body of the loop the step is executed, again
the condition is executed. If the condition become false it exit from the loop and control
transferred to the statement followed by the loop.
The following example executes 10 times by counting 0..9.
for (i = 0; i < 10; i++)
;
The following example illustrates the use of for loop.
P a g e | 52
P a g e | 53
5. while loop
The while statement is also a looping statement. The while loop evaluates the test
expression before every loop, so it can execute zero times if the condition is initially false. It
has the following syntax.
while (expression)
{
Statement 1;
Statement 2;
…………...
Statement n;
}
Here the initialization of a loop control variable is generally done before the loop
separately. The testing of the condition is done in while by evaluating the expression within
the parenthesis. If the evaluation result is true value, the block of statement within calibrates
is executed. If the evaluation result is false value the block of statements within the body of
loop is skipped and the loop execution get terminated with the control passing to the
statement immediately following the while construct. The increment or decrement of the loop
control variable is generally done within the body of the loop.
The following example illustrates the use of while loop.
P a g e | 54
6. do-while loop
This construct is also used for looping. In this case the loop condition is tested at the
end of the body of the loop. Hence the loop is executed al least one. The do-while is an
unpopular area of the language, most programmers’ tries to use the straight while if it is
possible.
Syntax of do while loop is
do
{
Statement 1;
Statement 2;
…………...
Statement n;
}
while(expression);
Here the block of statement following the do is executed without any condition
check. After this expression is evaluated and if it is true the block of statement in the body of
the loop is executed again. Thus the block of statement is repeatedly executed till the
expression is evaluated to false.
do-while construct is not used as often as the while loops or for loops in normal
case of iteration but there are situation where a loop is to be executed at least one, in such
cases this construction is very useful.
The following example illustrates the use of do-while loop.
P a g e | 55
7. break statement
The break statement is a jump instruction and can be used inside a switch construct,
for loop, while loop and do-while loop. The execution of break statement causes immediate
exit from the concern construct and the control is transferred to the statement following the
loop. In the loop construct the execution of break statement terminates loop and further
execution of the program is reserved with the statement following the body of the loop.
The following program illustrates the use of break statement.
P a g e | 56
8. continue statement
continue statement is a jump statement. The continue statement can be used only
inside for loop, while loop and do-while loop. Execution of these statement does not cause an
exit from the loop but it suspend the execution of the loop for that iteration and transfer
control back to the loop for the next iteration.
The following program illustrates the use of continue statement.
P a g e | 57
9. Nested loop
In many cases we may use loop statement inside another looping statement. This
type of looping is called nested loop. In nested loop the inner loop is executed first and then
outer. The nested loop must be used to input or output multi-dimensional array elements.
The following program illustrates the use of Nested loop.
P a g e | 58
Arrays
Array is a data structure, which provides the facility to store a collection of data of
same type under single variable name. Just like the ordinary variable, the array should also be
declared properly. The declaration of array includes the type of array that is the type of value
we are going to store in it, the array name and maximum number of elements.
The type may be any valid type supported by C. Array names, like other variable
names, can contain only letter, digit and underscore characters. Array names cannot begin
with a digit character. I.e., The rule for giving the array name is same as the ordinary
variable. The size should be an individual constant. To refer to a particular location or
element in the array, we specify the name of the array and the index of the particular element
in the array. The index specifies the location of the element in the array. The array index
starts from zero. The maximum index value will be equal to the size of the array minus one.
The array index can be an integer variable for an integer constant.
P a g e | 59
1. One dimensional array in c
programming language : ID array
The declaration form of one-dimensional array is
Data_type array_name [size];
The following declares an array called ‘numbers’ to hold 5 integers and sets the
first and last elements. C arrays are always indexed from 0. So the first integer in ‘numbers’
array is numbers[0] and the last is numbers[4].
int numbers [5];
numbers [0] = 1; // set first element
numbers [4] = 5; // set last element
This array contains 5 elements. Any one of these elements may be referred to by
giving the name of the array followed by the position number of the particular element in
square brackets ([]). The first element in every array is the zeroth element.Thus, the first
element of array ‘numbers’is referred to as numbers[ 0 ], the second element of array
‘numbers’is referred to as numbers[ 1 ], the fifth element of array ‘numbers’is referred to as
numbers[ 4 ], and, in general, the n-th element of array ‘numbers’is referred to as numbers[ n
- 1 ].
Example:
P a g e | 60
It's a very common error to try to refer to non-existent numbers[ 5], element. C
does not do much hand holding. It is invariably up to the programmer to make sure that
programs are free from errors. This is especially true with arrays. C does not complain if you
try to write to elements of an array which do not exist!
For example: If you wrote:
numbers[ 5 ], = 6;
C would happily try to write 6 at the location which would have corresponded to
the sixth element, had it been declared that way. Unfortunately this would probably be
memory taken up by some other variable or perhaps even by the operating system. The result
would be either:
The value in the incorrect memory location would be corrupted with unpredictable
consequences.
The value would corrupt the memory and crash the program completely!
The second of these tends to be the result on operating systems with proper
memory protection. Writing over the bounds of an array is a common source of error.
Remember that the array limits run from zero to the size of the array minus one.
Out of bounds access
I would be doing well, that really shows the range of valid indices, please check often. 10
When the number of elements, all the indices of 10 or more is illegal. Also, whether any size
of negative indices is also illegal.
These errors are detected at compile time is not. It is an error at run time. However, there is
no guarantee that the error reliably. Sometimes works correctly (seems to be moving.) This is
the "luck ran" instead of "bad luck worked" so, please, as no doubt.
The best way to see these principles is by use of an example, so load the
program and display it on your monitor.
#include <stdio.h>
#include <conio.h>
int main( )
{
char name[7]; /* define a string of characters */
name[0] = 'A';
name[1] = 's';
name[2] = 'h';
name[3] = 'r';
name[4] = 'a';
name[5] = 'f';
name[6] = '\0'; /* Null character - end of text */
name[7] = ‘X’;
clrscr();
printf("My name is %s\n",name);
printf("First letter is %c\n",name[0]);
printf("Fifth letter is %c\n",name[4]);
P a g e | 61
printf("Sixth letter is %c\n",name[5]);
printf("Seventh letter is %c\n",name[6]);
printf("Eight letter is %c\n",name[7]);
getch();
return 0;
}
The elements of an array can also be initialized in the array declaration by
following the declaration with an equal sign and a comma-separated list (enclosed in braces)
of initializers.
The following program initializes an integer array with five values and prints the
array.
#include <stdio.h>
#include <conio.h>
int main()
{
int numbers[]={1,2,3,4,5};
int i;
clrscr();
printf("Array elements are\n");
for(i=0;i<=4;i++)
printf("%d\n",numbers[i]);
getch();
return 0;
}
If there are fewer initializers than elements in the array, the remaining elements
are initialized to zero. For example, the elements of the array n could have been initialized to
zero with the declaration
int n[ 10 ] = { 0 };
which explicitly initializes the first element to zero and initializes the remaining nine
elements to zero because there are fewer initializers than there are elements in the array. It is
important to remember that arrays are not automatically initialized to zero. The programmer
must at least initialize the first element to zero for the remaining elements to be automatically
zeroed. This method of initializing the array elements to 0 is performed at compile time for
static arrays and at run time for automatic arrays.
There are more complex uses of arrays, which I will address later along with pointers.
P a g e | 62
2. Two dimensional array
Two-dimensional array are those type of array, which has finite number of rows
and finite number of columns. The declaration form of 2-dimensional array is
Data_type Array_name [row size][column size];
The type may be any valid type supported by C. The rule for giving the array
name is same as the ordinary variable. The row size and column size should be an individual
constant.
The following declares a two-dimensional 3 by 3 array of integers and sets the
first and last elements to be 10.
int matrix [3][3];
matrix[0][0] = 10;
matrix[2][2] = 10;
The following Figure illustrates a two dimensional array, matrix. The array
contains three rows and tree columns, so it is said to be a 3-by-3 array. In general, an array
with m rows and n columns is called an m-by-n array.
[0] [1] [2]
[0] 10
[1]
[2] 10
Every element in array matrix is identified by an element name of the form
matrix[ i ][ j ]; matrix is the name of the array, and i and j are the subscripts that uniquely
identify each element in matrix . Notice that the names of the elements in the first row all
have a first subscript of 0; the names of the elements in the third column all have a second
subscript of 2.
In the case of Two-dimensional array, during declaration the maximum number of
rows and maximum number of column should be specified for processing all array
elements.
The implementation of the array stores all the elements in a single contiguous
block of memory. The other possible implementation would be a combination of several
distinct one-dimensional arrays. That’s not how C does it. In memory, the array is arranged
with the elements of the rightmost index next to each other. In other words, matrix[1][1]
comes right before matrix[1][2] in memory.
The following array:
P a g e | 63
[0] [1] [2]
[0] 1 2 3
[1] 4 5 6
[2] 7 8 9
would be stored:
1 2 3 4 5 6 7 8 9
Example:
P a g e | 64
3. Three dimensional array in c
programming
The declaration form of Three-dimensional array is
Data_type Array_name [size1][size2][size3];
Example:
P a g e | 65
String
A string in C is actually a character array. As an individual character variable
can store only one character, we need an array of characters to store strings. Thus, in C string
is stored in an array of characters. Each character in a string occupies one location in an
array. The null character ‘\0’ is put after the last character. This is done so that program can
tell when the end of the string has been reached. For example, the string ”I Like C
Programming” is stored as follows.
I L i k e C P r o g r a m m i n g \o
Since the string has 20 characters (including space), it requires an arrayof at least, size 21 to
store it.
Thus, in C, a string is a one-dimensional array of characters terminated a null
character. The terminating null character is important. In fact, a string not terminated by ‘\0’
is not really a string, but merely a collection of characters.
A string may contain any character, including special control characters, such
as \n, \t, \\ etc...
There is an important distinction between a string and a single character in C.
The convention is that single characters are enclosed by single quotes e.g. '*' and have the
type char. Strings, on the hand, are enclosed by double quotes e.g. "name" and have the type
"pointer to char" (char *) or array of char.
Strings can be declared in two main ways; one of these is as an array of
characters, the other is as a pointer to some pre-assigned array. Perhaps the simplest way of
seeing how C stores arrays is to give an extreme example which would probably never be
used in practice.
#include<stdio.h>
int main ()
{
char string[];
string[0] = 'C';
string[1] = 'P';
string[2] = 'r';
string[3] = 'o';
string[4] = 'g';
string[5] = 'r';
string[6] = 'a';
string[7] = 'm';
string[8] = 'm';
string[9] = 'i';
string[10]= 'n';
string[11] = 'g';
printf ("%s", string);
P a g e | 66
return 0;
}
This method of handling strings is perfectly acceptable, if there is time to
waste, but it is so laborious that C provides a special initialization service for strings, which
bypasses the need to assign every single character with a new assignment!.
The other way is use a pointer to some pre-assigned array.
#include<stdio.h>
int main ()
{
char str1[]=”I Like”;
char *str2=”C Programming”;
puts(str1);
puts(str2);
return 0;
}
P a g e | 67
1. strlen()
Syntax:
#include < string.h>
size_t strlen( char *str );
strlen(char *str) returns the length of the null terminated string pointed to by str. The null
terminator is not counted.
This function will return number of characters in the string provided as parameter to this
function. For example if we are providing "The world" as the string it will return 9. That
means it will take the blank spaces in between the words in the string into count. But the null
terminator is not counted. It will aslo take special characters like @,#,$,% etc into count.
consider this example str[30]="www.cprogrammingexpert.com";
It is stored like
str[0] <- 'w'
str[1] <- 'w'
str[2] <- 'w'
str[3] <- '.'
str[4] <- 'c'
str[5] <- 'p'
str[6] <- 'r'
str[7] <- 'o'
str[8] <- 'g'
str[9] <- 'r'
str[10] <-'a'
str[11] <-'m'
str[12] <-'m'
str[13] <-'i'
str[14] <-'n'
str[15] <-'g'
str[16] <- 'e'
str[17] <- 'x'
str[18] <- 'p'
str[19] <- 'e'
str[20] <- 'r'
str[21] <- 't'
str[22] <- '.'
str[23] <- 'c'
str[24] <- 'o'
str[25] <- 'm'
str[26] <- '\0'
str[27] <- 'garbage value'
str[28] <- 'garbage value'
str[29] <- 'garbage value'
Here strlen(str) equals 26. null terminator is not counted.
Example:
P a g e | 68
P a g e | 69
2. string function : strlwr()
Syntax:
char * strlwr(char *str)
strlwr(str) coverts str to all lowercase.
This function will convert all the uppercase characters in the string, which is provided as
parameter, into lowercase. It does not take care whether it is the starting letter or not. It will
convert every uppercase to lowercase.
For example
#include<stdio.h>
#include<conio.h>
int main()
{
char str[30]="www.CProgrammingExpert.com";
clrscr();
printf("\n\nstr : %s\n\n",str);
printf("strlwr(str) : %s\n",strlwr(str));
getch();
return 0;
}
here we declares the string str like this str[30]="www.CProgrammingExpert.com"; The string
str is a character array of size 30.The character is stored like this
str[0] <- 'w'
str[1] <- 'w'
str[2] <- 'w'
str[3] <- '.'
str[4] <- 'C'
str[5] <- 'P'
str[6] <- 'r'
str[7] <- 'o'
str[8] <- 'g'
str[9] <- 'r'
str[10] <-'a'
str[11] <-'m'
str[12] <-'m'
str[13] <-'i'
str[14] <-'n'
str[15] <-'g'
str[16] <- 'E'
str[17] <- 'x'
str[18] <- 'p'
str[19] <- 'e'
str[20] <- 'r'
str[21] <- 't'
str[22] <- '.'
str[23] <- 'c'
str[24] <- 'o'
str[25] <- 'm'
str[26] <- '\0'
P a g e | 70
str[27] <- 'garbage value'
str[28] <- 'garbage value'
str[29] <- 'garbage value'
when we use the function strlwr(str) it will convert all characters stored in the character array
str to lowercase.Then stored like this
str[0] <- 'w'
str[1] <- 'w'
str[2] <- 'w'
str[3] <- '.'
str[4] <- 'c'
str[5] <- 'p'
str[6] <- 'r'
str[7] <- 'o'
str[8] <- 'g'
str[9] <- 'r'
str[10] <-'a'
str[11] <-'m'
str[12] <-'m'
str[13] <-'i'
str[14] <-'n'
str[15] <-'g'
str[16] <- 'e'
str[17] <- 'x'
str[18] <- 'p'
str[19] <- 'e'
str[20] <- 'r'
str[21] <- 't'
str[22] <- '.'
str[23] <- 'c'
str[24] <- 'o'
str[25] <- 'm'
str[26] <- '\0'
str[27] <- 'garbage value'
str[28] <- 'garbage value'
str[29] <- 'garbage value'
so after using the function strlwr(str) the value of string str
is"www.cprogrammingexpert.com"
Example:
P a g e | 71
P a g e | 72
3. string function : strupr()
Syntax:
char * strupr(char *str);
strupr(str) coverts str to all uppercase. It returns a pointer to the original input string str.
This function will convert all the lowercase characters in the string, which is provided as
parameter, into uppercase. It will convert every lowercase to uppercase.
For example
#include<stdio.h>
#include<conio.h>
int main()
{
char str[30]="www.CProgrammingExpert.com";
clrscr();
printf("str : %s\n",str);
printf("strupr(str) : %s\n",strupr(str));
getch();
return 0;
}
here we declares the string str like this str[30]="www.CProgrammingExpert.com"; The string
string str is a character array of size 30.The character is stored like this
str[0] <- 'w'
str[1] <- 'w'
str[2] <- 'w'
str[3] <- '.'
str[4] <- 'C'
str[5] <- 'P'
str[6] <- 'r'
str[7] <- 'o'
str[8] <- 'g'
str[9] <- 'r'
str[10] <-'a'
str[11] <-'m'
str[12] <-'m'
str[13] <-'i'
str[14] <-'n'
str[15] <-'g'
str[16] <- 'E'
str[17] <- 'x'
str[18] <- 'p'
str[19] <- 'e'
str[20] <- 'r'
str[21] <- 't'
str[22] <- '.'
str[23] <- 'c'
str[24] <- 'o'
str[25] <- 'm'
str[26] <- '\0'
str[27] <- 'garbage value'
str[28] <- 'garbage value'
str[29] <- 'garbage value'
P a g e | 73
whe we use the function strupr(str) it will convert all characters stored in the character array str to
uppercase.Then stored like this
str[0] <- 'W'
str[1] <- 'W'
str[2] <- 'W'
str[3] <- '.'
str[4] <- 'C'
str[5] <- 'P'
str[6] <- 'R'
str[7] <- 'O'
str[8] <- 'G'
str[9] <- 'R'
str[10] <-'A'
str[11] <-'M'
str[12] <-'M'
str[13] <-'I'
str[14] <-'N'
str[15] <-'G'
str[16] <- 'E'
str[17] <- 'X'
str[18] <- 'P'
str[19] <- 'E'
str[20] <- 'R'
str[21] <- 'T'
str[22] <- '.'
str[23] <- 'C'
str[24] <- 'O'
str[25] <- 'M'
str[26] <- '\0'
str[27] <- 'garbage value'
str[28] <- 'garbage value'
str[29] <- 'garbage value'
so after using the function strupr(str) the value of string str
is"WWW.CPROGRAMMINGEXPERT.COM"
Example:
P a g e | 74
4. strcat()
Syntax:
#include<string.h>
char *strcat( char *str1, const char *str2 );
strcat(str1,str2) concatenates a copy of the string pointed to by str2 to the the
string pointed to by str1 and terminates str1 with a null. The first character of str2 overwrites
the null terminator originally ending sr1. The str2 is untouched by the operation.In this
function we will pass two arguments str1,str2 as parameters.