C

Basic of C Programming in Depth 1
Introduction
C is the middle level procedure oriented structured computer programming language developed by
Dennis Ritchie in the 1972 at AT & T Bell Laboratory of USA. C is the middle level computer programming
language because it supports both of the features of high level and low level computer programming
languages.
The different structured programming languages are like: PASCAL, Ada, Java, C++, C,
Modula -2, etc. where as some unstructured languages are like: FORTRAN, BASIC,
COBOL etc.
History of C Language:
 In the year 1960 the programming language has developed by international comity called ALGOL –
60.
 In the year 1963 the programming language has developed by Cambridge University called CPL
(Combined Programming Language).
 In the year 1967 the programming language has developed by Martin Richard at Cambridge
University called BCPL (Basic Combined Programming Language).
 In the year 1969 the programming language has developed by Ken Thompson at AT & T Bell
laboratory called B.
 In the year 1972 C has developed.
C Compilers and Editors:
There are several C Compilers and editors are available in market such are:
1. Borland C Compiler: earlier used in DOS environment
2. Turbo C Compiler: These days used in DOS environment. It comes with different versions such are:
Turbo C 2.0, Turbo C 3.0, Turbo C 4.5 (used in Windows environment).
3. ANSI C Compiler: used in both DOS and Unix environment.
4. GCC Compiler: GNOME C Compiler only meant for UNIX and LINUX environment.
5. Tiny C Compiler: used in UNIX environment
6. Ciz Win Compiler: Unix flavor windows environment.
7. Visual C / C++ Compiler: only meant for windows environment.
Turbo C 3.0:
This is the Compiler cum editor environment where we can create or develop the C or C++
programs. Turbo means adding extra features.
How to open Turbo C++ IDE (IDE refers to Integrated development environment)
Procedure1:
 Double click over the turbo C++ IDE over the desktop screen.
Procedure2:
 Open DOS prompt
 Change the directory to the root drive. Cd\
 Search for the file TC.EXE
o If found then change the directory to the target(cd TC\BIN ), Type TC press enter
Odisha Education & Development Center, Brahmapur, GM, Odisha. 9437041710, www.oedci.com
o If not found then change the drive (drivename: ) and follow step2
Short cut Commands used in Turbo C++ IDE

Commands Used For
Alt + Enter Restore or Full Screen the Turbo C++ IDE
Alt + Hot key of Menu Open the particular Menu
F2 Save the current working program file
F3 Open the open control window through which we can open different
existing programs
F5 Restore or maximize the program window
Alt + F3 Close the current working file
Alt + F5 Show the previous output or user screen
Alt + F9 Compile the current working program, if error then shows
F9 Compile the current working program, if error free then make .EXE
Ctrl + F9 Compile, make .EXE and execute the program
←→↑↓ Use to move the cursor one character left/right or one line up/down
Home key Move the cursor to the beginning of the current cursor pointing line
End Key Move the cursor to the end of the current cursor pointing line
Ctrl + → Move the cursor to one word right
Ctrl + ← Move the cursor to one word Left
Shift + arrow keys Use to select the content
Ctrl + T Delete the current cursor pointing forwarded word
Ctrl + Y Delete the current cursor pointing line
Ctrl + Ins Copy the selected Content
Shift + Del Cut the selected Content
Shift + Ins Paste the selected Content
Alt + X Close the Turbo C++ IDE
Some require points for C Program

1. Every C Program require a main() block.
2. The main() block in a C program can be appear only at once.
3. The program execution starts with the opening curly bracket { of the main() block and ends with the
closing curly bracket } of the main() block.
4. Every { must have a }.
5. Most of all the statements in a C program must be ended with a semi colon ; .
6. Most of all the statements in the C program are written in lower case characters, how ever the
upper case characters can be accepted as sending output messages or for any symbolical names.
7. The corresponding header files of the used statements must be include at the first column of the
first line of the C program as # include “headerfilename.h”.
8. The variables, which are used inside the C program that must be declared first.
9. C is the free form language(i.e. it has no pre defined format of writing the body statements) and
highly case sensitive. i.e. lokanath, Lokanath, LOKANATH all are different.
10. The comments in a C program can be added as /*Comment line*/.
Skeleton of C Program:
#include <headerfilename.h>
global variable declaration;
main() {
local variable declaration;
statement1;
statement2;
…………………
statementn;
}
Comment:
Comment is a phrase of word given to any subject or object, which specify something about it.
The comments in a C program can be added in two different ways such are:
1. Single line Comment can be preceded by double forwarded slash as // Comment Line
2. Multi line Comment can be enclosed by /* and */ as
/* Comment Line 1
Comment Line 2
“””””””””””””””
Comment Line n */
# include<headerfilename.h>
# is the pre processor sign, which specify that the followed statement must be processed before
executing the main().
Include is the inclusion directive use to include the enclosed header file to the current program
so that the programmer can use the belonging statements or the facilities provided by the particular
header file.
< > angular bracket use to search the enclosed file in the include directory specified in the
option menu of directory option. Instead of < > we can use double quote “ ” because the “ ” will search
for the file in the include directory as well as in the current working directory.
.h is the extension name of the header file.
Variable
Variable is the namely location at memory can capable to contain the value, the value of the
variable is changes or varies through out the program. The variable is otherwise called as identifier
because it identify the value from the memory through a symbolical name. Variable is the reference
name of the value in the memory. The variables are of two types:
1. Local variable: The variables, which are declared inside a block and can be used or accessed
inside that block only is called as local variable. It has the local scope.
2. Global variable: These variables are declared at the global area that is just after the header file
declaration and before the main() block. These variable has the global scope and can use or
accessed inside any block in the program.
Rules for declaring a variable
The variablename can be any name but should follow the following rules:
1. The first character of the variablename must be alphabetic.
2. The variablename should not exceed more than 31 characters.
e.g. student_roll is the variable name having 12 characters this like there should not be
more than 31 characters in variable name.
3. The variablename should not contain any space between it, for the space we can use
underscore sign ( _ ) instead of any other symbol. e.g. student_name
4. The same variablename can’t be declared more than once in a same scope.
5. The variablename should not be any pre defined key word.

Keyword
There are 32 words reserved by C compiler which has their own meaning to the compiler, which
can’t be taken as variablename. E.g. auto, break, case, char, const, continue, default, do, double,
else, enum, extern, float, for, goto, if, int, long, register, return, short, signed, sizeof, static, struct,
switch, typedef, union, unsigned, void, volatile, while.
Variable declaration syntax:

datatype variablename;
if we require to declare more than one variables of the type same then
datatype variablename1, varname2, ……, varnamen;
Data type:
Data type are the key words use to specify the type of the data can be contained by the variable.
There are three different types of data type such are:
1. Integer
2. Character
3. Float
1. Integer: These type variables can capable to contain the whole number values. It is of two types
such are:
a. Signed Integer: These type variables can capable to contain numerical whole number
values. E.g. 23, 452, 98, 60 etc. It is of three types such are:
i. signed short int
ii. signed int
iii. signed long int
b. Unsigned Integer: These type variables can capable to contain alpha numerical whole
number values. E.g. 0x27, A4, etc It is of three types such are:
i. unsigned short int
ii. unsigned int
iii. unsigned long int
Note: These are categorized according to their size and range.
2. Character: These type variables can contain character type value. This is of two types:
c. signed char : alphabetical values e.g. ‘Q’, ‘D’, ‘S’, etc
d. unsigned char: alphanumerical values. E.g. ‘0X27’, ‘0X32’, etc.
3. Float: These type variable can capable to contain the real numbers or floating type or decimal
point values. e.g. 12.765, 78.5213, etc. It is of three types.
e. float
f. double
g. long double
Data types, their size and range.

Sl. No. Type Length Range
1. unsigned char 1 byte 0 to 255
2. Char 1 byte -128 to 127
3. enum 2 byte -32,768 to 32,767
4. unsigned int 2 byte 0 to 65,535
5. Short int 2 byte -32,768 to 32,767
6. Int 2 byte -32,768 to 32,767
7. unsigned long 4 byte 0 to 4,294,967,295

8. Long 4 byte -2,147,483,648 to 2,147,483,647
9. Float 4 byte 3.4 * (10**-38) to 3.4 * (10**+38)
10. double 8 byte 1.7 * (10**-308) to 1.7 * (10**+308)
11. Long double 10 byte 3.4 * (10**-4932) to 1.1 * (10**+4932)
C Tokens
There are certain symbols or keywords used for better communication that are called as Tokens, C also
uses certain Tokens are like:
1. Identifiers
2. Datatype
3. KeyWords
4. Constants
5. Type Specifiers
6. Escape Sequences
7. Operators
1. Identifiers: The
2. Datatype
3. KeyWords
4. Constants: These are the identifiers, whose value will not change throughout the program.
a. Numerical Constants
i. Integer Constants: whole number values e.g. 234, 78, 45 etc
ii. Real Constants: floating type values e.g. pi=3.142 etc
b. Character Constants
i. Single Character Constants: e.g. ‘T’, ‘P’, ‘Z’, etc.
ii. String Constants: “Ashok”, “Berhampur”, “23-Jan-1986”, etc.
5. Type Specifiers: These are otherwise called as format descriptors, because it specify or describes
about the type or the format of the both input and output values. It is used with both I/O
statements. These are preceded by modulus sign. The different format descriptors are:
Type Used For / Meaning

Specifiers
%c Single Character
%d Integer or whole number values
%e Floating point values for scientific notation
%f Float
%g Float
%h Short int
%i Decimal, octal or hexadecimal values
%ld Long double
%o Octal values
%s String values
%[^\n] String including space
%u Unsigned
%x Hexadecimal values
6. Escape Sequences: These are the characters preceded by back slash ( \ ) character, used with
output statements, generally escaped from the compiler to be interpret. These has their own
meaning to the compiler. The different escape sequences are:
\a Beep the speaker once
\b Back space
\n Create a new line
\t Create a horizontal tab
\r Carriage return
\\ Print \
\? Print ?
\’ Print ‘
\” Print “
7. Operators: These are the symbols used with one or more operands to do operation over them.
The different operators are like:
a. Arithmetic Operator: used for math calculations, e.g. +, -, *, / and %(modulus: it
retrieves the reminder).
b. Relational Operators: used with conditional statements, e.g. <, >, <=, >=, == (equals), !=
(not equal to).
c. Assignment Operators: used to assign the right expression result to the left operand,
e.g. =, +=, -=, *=, /=, %=.
e.g. a=5;
a+=6; (i.e. a=a+6;)
print a; 11
d. Increment / decrement Operators: These can be of two types use to increase or
decrease the value of the operand by one.
i. Pre increment / decrement operators:
e.g. a=5;
print ++a; 6
print a;6
ii. Post increment / decrement operators:
e.g. a=5;
print a++;5
print a;6
e. Logical Operators: The logical operators are used in Boolean algebra or in logics or in
discrete mathematics.
e.g. && - logical AND
|| - logical OR
! – logical NOT
f. Bitwise Operators: These operators are used for bit level manipulations.
>> right shift operator. it will remove a Zero (0) from the right side of the binary
equivalent of the given number according to the given number. a=64; b=a>>1;
print b;  32
<< left shift operator . it will add a Zero (0) at the right side of the binary
equivalent of the given number according to the given number. a=64;
b=a<<1; print b; 128
g. Conditional Operators: ? and : are the two different conditional operators used together
for conditional statements, these are otherwise called as ternary operator.
Syntax: (condition)? Statement1: statement2;
e.g. (a>b)?statement1: statement2;

If the condition is true that is a is greater than b then it will execute the
statement1 otherwise it will execute the statement2.
Stdio.h
For the standard input and output operations we need of stdio.h header file. Stdio stands for standard
input and output (I/O). The different statements are belonging to this header file are :
1. printf(): This is the formatted output statement use to send the given message to the standard
output screen.
Syntax: printf(“Output Message”);
if we require to display the value of any variable then
printf(“typespecifier with Output Message”, variablename);
if we require to display more than one variable values then
printf(“typeSpecifier1 ts2 … tsn”,varname1, vnm2, …, vnmn);
The number of type specifiers and variable names must correspondent, i.e. identically same to the
sequence as well as numbers.
Q> WAP to display “Hello World”.
#include ”stdio.h”
main() {
printf(“\nHello World”);
}
Q> WAP to print “Hello World” with double quote.
Q> WAP to print your name as: Ranjan

Kumar
Singh
Q> WAP to assign a value to a variable, print it’s square and cube.
#include ”stdio.h”
}
main() {
int a, b; int a=7, b;
a=7;
b=a*a;
printf(“\nThe Number is : %d”,a);
printf(“\nThe Square is : %d\nThe Cube is : %d”, b, (a*a*a));
}
Q> WAP to assign the radius of a circle, calculate and display it’s area.
Q> WAP to assign two values to two variables, calculate and display it’s multiplication result.
Q> WAP to assign two values to two variables, calculate and display it’s addition, subtraction,
multiplication and division result.
2. scanf(): is the input statement use to input the value to the program variable during run time.
Synatax:
scanf(“typeSpecifier”, &variablename);
if we require to input more than one variable values then
scanf(“ts1 ts2 . . . tsn”, &varname1, &varnm2, . . . , &variablenamen);
e.g.
Q1> WAP to input two numbers, calculate and display the addition result.
#include “stdio.h”
main() {
int a, b, c=0;
printf(“\nEnter Two Numbers : ”);
scanf(“%d%d”,&a,&b);
c=a+b;
printf(“\nThe Addition Result is : %d”, c);
}
Q2> WAP to input the principal amount, rate and time; calculate and display the simple interest.
Hint: SI=(PRT)/100
Q3> WAP to input the radios of a circle, calculate and display the area and perimeter.
Q4> WAP to input the year of birth, calculate and display the age.
Q5> WAP to input the five marks of a student, calculate and display the total and Percentage.
Q6> WAP to input two numbers, calculate and display the addition, subtraction, multiplication and
division result.
conio.h
conio stands for console input and output. The different statements belongs to this header file
are:
1. clrscr(); use to clear the output user screen.
2. getche(); use to wait to get a character during run time.
3. getch(); use to wait to get a character during run time, where as the entered character will not
prompt or shown to the user while entering.
e.g. WAP to input an alphabet print it’s ASCII value.
#include “conio.h”
main() {
char ch;
clrscr();
printf(“\nEnter an Alphabet : ”);
ch=getche(); // scanf(“%c”, &ch);
printf(“\nThe ASCII value is : %d”, ch);
getch();
}
4. textmode(mode); It will set the text mode of the console output.
5. textcolor(color); It will set the text color of the console output.
6. textbackground(color); It will set the text background color of the console output.
The text modes can be C40, C80, BW40, BW80.
Text colors can be 0 to 15 that are 0 BLACK, 1 BLUE, .. , 15 WHITE.
These can be applied to cprintf() statement as like the printf() statement.
e.g. WAP to display the “Hello World”.
main() {
clrscr();
textmode(C40);
textcolor(BLUE);
textbackground(15);
cprintf(“Hello World”);
getch();
}
Type Casting:
Caste or change the type of the value according to the user requirement is called as type casting
or type conversion. The type casting can be of two different types such are:
1. Implicit type casting
2. Explicit type casting
1. Implicit type casting: By using implicit type casting we can change the type of the value
internally that is mostly by using type specifiers.
e.g. int num=65;
printf(“\nThe character value is : %c”,num); i.e. it will print ‘A’
like the same way each every characters has an ASCII value that is from 0 to 255.
65 – 90 A to Z
97 – 122 a to z
e.g. float num=45.8979;
printf(“The Number is : %d”,num); i.e. it will print 45
2. Explicit type casting: can be performed externally as:
e.g. int a=65, b=90;
float c;
c=(float)(a+b)/2;
printf(“The Middle Value is : %f”, c);
Constructs
There are certain keywords use to control the data flow in the program and called as Control Statements
or Decision making and Branching Statements or decision control statements or constructs.
There are two different types of constructs such are :
1. Selection Constructs
2. Iteration Constructs
1. Selection Constructs: These are the decision making statements or the keywords used to
select a block of statements to execute if the condition is true. The different selection constructs
are :
a. If condition: This is the selection construct use to execute a block of statements if
the condition is true.
Syntax: if (condition){
statement 1;
statement 2;
||||||
statement n;
}
e.g. Q> WAP to input a number check for greater than 100 or not.
main() {
int num;
clrscr();
printf(“\nEnter a Number : ”);

scanf(“%d”,&num);
if (num>100){
printf(“\nThe Number is Greater than 100”);
}
If(num<100){
printf(“\nThe Number is Less than 100”);
}
If(num==100){ printf(“\nThe Number is 100”); }
getch();
}
b. If else statement: This is the selection construct use to select a block of statements
to execute if the condition is true otherwise it will execute the else blocked statements.
Syntax: if(condition){
statement 1;
statement 2;
||||||
statement n;
}
else{
statement 1;
statement 2;
||||||
statement n;
}
e.g. Q> WAP to input a number check for even or odd.
main() {
int num;
clrscr();
scanf(“%d”,&num);
if (num%2 == 0){
printf(“\nEven”);
}
else{
printf(“\nOdd”);
}
getch();
}
Q> WAP to input a number check for positive or negative.
Q> WAP to input the year, check for leap year or not.
Q> WAP to input the year of birth of a person, check for eligible for vote or not.
Q> WAP to input the length and area of a rectangle, check whether it is a square or not.
c. Nested if condition: When an if condition is places inside another if condition that
is called nested if condition. It has no pre defined skeletons that is according to the
requirement the programmer can use the nesting.
e.g. Q> WAP to input a digit from 5 to 9 and display it in word.
main() {
int n;
clrscr();
printf(“\nEnter a Number from 5 to 9 :”);
scanf(“%d”,&n);
if((n>=5) && (n<=9)) {
if(n==5)
printf(“\n Five”);
else
if(n==6)
printf(“\n Six”);
else
if(n==7)
printf(“\n Seven”);
else
if(n==8)
printf(“\n Eight”);
else
printf(“\n Nine”);
}
else{
printf(“\n Invalid Number : The Entered Number Must between 5 to 9”);
}
getch();
}
Q> WAP to input three numbers, display the greater one.
main() {
int a, b, c;
clrscr();
printf(“\nEnter three Numbers : ”);
scanf(“%d%d%d”, &a, &b, &c);
if(a>b){
if(a>c)
printf(“\n %d is Greater ”, a);
else
printf(“\n %d id Greater”, c);
}
else{
if(b>c)
printf(“\n %d is Greater”, b);
else
printf(“\n %d is Greater”, c);
}
getch();
}
Q> WAP to input 5 numbers, display the smaller one.

Q> WAP to input an alphabet, check for vowel or consonant.
d. switch case: Instead of nested if condition we can use the switch case statement for
equality checking of more than one check values. It will check the switch variable value
to the case check value for equality, if found equal then it will execute the
corresponding statement and break the block and if non of the check value found equal
then it will execute the default statement.
Syntax:
switch(variablename) {
case checkvalue1: statement1; break;
case checkvalue2: statement2; break;
|||||||||||||||||||||||||||||||||
case checkvaluen: statementn; break;
default: statementdefault;
}
e.g. Q> WAP to input an alphabet, check for vowel or consonant using switch case statement.
main() {
char ch;
clrscr();
printf(“\nEnter an Alphabet : ”);
ch = getche();
switch(ch) {
case ‘a’:printf(“\nVowel”); break;
case ‘e’:printf(“\nVowel”); break;
case ‘i’:printf(“\nVowel”); break;
case ‘o’:printf(“\nVowel”); break;
case ‘u’:printf(“\nVowel”); break;
default: printf(“\nConsonant”);
}
getch();
}
Q> WAP to input a digit from 0 to 9 and Display it in word.
Jumping Statement: goto is the jumping statement use to jump the program control to a specified
label to execute from there.
Syntax: goto labelname;
The labelName can be any name but should follows the rules for declaring a variable name. the label
name can be declared as
labelName:
e.g. Q> WAP to print your name 10 times using goto statement.
main() {
int i=1;
clrscr();
hhLabel:
printf(“\nLokanath”);
if ((++i)<=10)
goto hhLabel;
getch();
}
Iteration Constructs: Iteration means repetition. These are otherwise called as looping statements
or looping constructs, use to execute a block of statements repeatedly again and again till the condition
is true. The different iteration constructs are for loop, while loop and do while loop are used in C
language.
e. For loop: This is the simplest iteration construct used in C language use to execute a
block of statements repeatedly again and again till the condition is true, it has three
different parameters as :
Syntax:
for(initialization; condition; increment/decrement) {
statement 1;
statement 2;
|||||||||||
statement n;
}
Note : The initialization statement will execute once throughout the continuity, where as the condition
and increment / decrement will execute each time of continuity.
e.g. Q> Write a program to print your name 10 times with the serial number.
main() {
int i;
clrscr();
for(i=1; i<=10; i++){
printf(“\n%d. Lokanath”, i);
}
getch();
}
Q> WAP to input a number, print 1 to that number.
Q> WAP to input two numbers, print the range.
Q> WAP to print all the even numbers from 20 to 50.
Q> WAP to input a number, print the jar table of that number.
Q> WAP to print all the even and odd numbers between 1 to 50 as
Even Odd
1
2 3
4 5
6 7
- -
- -
48 49
50
f. Nested for loop: When a for loop is placed inside another for loop that is called as
nested for loop. In this case the inner loop will execute full time by executing the outer
loop once.
Q> WAP to print the jar table from 2 to 5.

main(){
int i, j;
clrscr();
for(i=2; i<=5; i++){
for(j=1; j<=10; j++){
printf(“\n%d * %d = %d”, i, j, (i*j));
}
}
getch();
}
Q>WAP to print
1 2 3 4 5
11111 12345 1 1 1
22222 12345 12 22 23
33333 12345 123 333 456
44444 12345 1234 4444 7 8 9 10
55555 12345 12345 55555
9 10 11
6 7 8
* * * ***** ***** * * * *
*
** ** ** **** **** ****
*** *** *** *** *** ***
**** **** **** ** ** **
***** ***** ***** * * *
12
*****
****
***
**
*
**
***
****
*****
Answer
1>
main (){
int i, j;
clrscr();
for(i=1; i<=5; i++){
for(j=1; j<=5; j++)
printf(“%d ”, i);
printf(“\n”);
}
getch();
}
6>
main (){
int i, j;
clrscr();
for(i=1; i<=5; i++){
for(j=1; j<=i; j++)
printf(“* ”);
printf(“\n”);
}
getch();
}
g. While loop: This is the iteration construct use to execute a block of statements
repeatedly again and again till the condition is true. The basic difference between the
for loop and while loop is : in case of for loop the programmer is well known about the
time of repetition, where as in case of while loop the programmer may unknown about
the time of repetition.
syntax:
while(condition) {
statement1;
statement2;
~~~~~~~~~~
statementn;
}
e.g. Q> WAP to input a number, print from that number to 1.
main(){
int n;
clrscr();
printf(“\nEnter a Number :”);
scanf(“%d”,&n);
while(n>=1){
printf(“\n%d”,n);
n--;
}
getch();
}
Q> WAP to input a number, check for prime or not. (the number is only divisible by 1 and itself)
Q> WAP to input a number, print it’s each digit in one – one line.
Q> WAP to input a number, calculate and display the sum digit value.
Q> WAP to input a number, check for Armstrong or not. (the number is equal to sum of it’s each digit
cube like 153=13 + 53 + 33  1*1*1 + 5*5*5 + 3*3*3  1+125+27  153)
Q> WAP to input a number, check for palindrome or not (the number is equal to it’s reverse like 131,
898, 77, 969, 12321 etc).
Q> WAP to print all the palindrome numbers between 1 to 100.
Q> WAP to print all the Armstrong numbers from 10000 to 1.
h. Do while loop: This is as like the while loop, the difference is In case of while loop
the program controller first check the condition and if true then only will enter into the
loop and execute the block, where as in case of do while loop first it will execute the
block, then check the condition for next execution.
syntax:
do{
statement1;
statement2;
””””””””””
statement;
}while(condition);
e.g. Q> WAP to input two numbers and print the sum, continue the whole process upto user desire.
main(){
int a, b;
char ch;
clrscr();
do{
printf(“\nEnter two Numbers : ”);
scanf(“%d%d”,&a,&b);
printf(“\nThe Addition Result is : %d”, (a+b));
printf(“\nDo U Want to Continue (y/n): ”);
ch=getche();
}while(ch== ‘y’ || ch== ‘Y’);
getch();
}
ctype.h
ctype stands for character type, this header file facilitate different statements like:
1. isdigit (char): Use to check the given character for digit or not.
2. isalpha(char): Use to check the given character for alphabet or not.
3. isupper(char): Use to check the given character for upper case or not.
4. islower(char): Use to check the given character for lower case or not.
5. isspace(char) : Use to check the given character for space or not.
These all statements or pre defined functions are used with conditional operators or tertiary operators
as:
main() {
char ch;
printf(“\nEnter a Character : ”);
getche(ch);
isalpha(ch)? printf(“\n Alphabet :”): printf(“\nNot an Alphabet”);
getch();
}
Q> Write two programs to input a character, check for digit or alphabet or space or non of these, if
alphabet then check for upper case or not using ctype.h and with out using ctype.h.
Answer1: Using ctype.h
#include “ctype.h”
void main() {
char ch;
clrscr();
printf(“Enter a Character : ”);
ch=getche();
isdigit(ch)? printf(“\nDigit”): isspace(ch)? printf(“\nSpace”): isalpha(ch)? isupper(ch)?
printf(“\nAlphabet in UPPER CASE”): printf(“\nAlphabet in lower case”): printf(“\nNot an Alphabet, Not
a Space and Not even a Digit”);
getch();
}
Answer2: Without Using ctype.h
void main() {
char ch;
clrscr();
printf(“Enter a Character : ”);
ch=getche();
((ch>=48) && (ch<=57))? printf(“\nDigit”): (ch==32)? printf(“\nSpace”): (((ch>=65) && (ch<=90))
||((ch>=97) &&(ch<=122)))? ((ch>=97) &&(ch<=122))? printf(“\nAlphabet in UPPER CASE”):
printf(“\nAlphabet in lower case”): printf(“\nNot an Alphabet, Not a Space and Not even a Digit”);
getch();
}
STRING
The combination of multiple characters is called as string. The string is otherwise called as
character array. It is the character type. The string variable must have a size that is the
maximum number of characters can be contained by string variable.
e.g.
char varName[size];
%s and %[^\n] are used for string output and input purpose.
Q> WAP to input your name and display it.
main(){
char name[50];
clrscr();
printf(“\nEnter Your Name : ”);
scanf(“%[^\n]”,&name);
printf(“\nYour Name is : %s”,name);
getch();
}
char name[10]= “WELCOME”;

 name =
0 1 2 3 4 5 6 7 8 9
‘W’ ‘E’ ‘L’ ‘C’ ‘O’ ‘M’ ‘E’ ‘\0’
The string is ended with NULL (‘\0’) character, each and every character of the string has an index value
that starts from 0 (Zero) as:
name[0]= ‘W’;
name[1]= ‘E’;
name[2]= ‘L’;
name[3]= ‘C’;
name[4]= ‘O’;
name[5]= ‘M’;
name[6]= ‘E’;
name[7]= ‘\0’;
printf(“%c”, name[3]);  C
Q> WAP to input your name and print each character in a separate line.
main(){
char name[50];
int i;
clrscr();
printf(“\nEnter Your Name : ”);
for(i=0; name[i]!= ‘\0’; i++);
printf(“\n%c”,name[i]);
printf(“\nThe Length is : %d”, i);
getch();
}
Q> WAP to find out the length of an entered string, length specify the number of characters contained
by the string including space.
Q> WAP to input a string, copy it to another.
Q> WAP to input two strings and concatenate them or merge them into another.
Q> WAP to input a string print it’s reverse.
Q> WAP to input a string check for palindrome or not.
Q> WAP to input a paragraph, calculate and display the number of character including space, number of
characters excluding space, number of words, number of sentence contained by paragraph, change the
character case according to user chosen option, the different character cases are Sentence case, UPPER
CASE, lower case, Title Case, tOGGLE cASE.
Q> WAP to input a paragraph, find a particular character or word and replace it.
string.h
This header file provides different statements to manipulate the string easily inside the program. The
different statements are like: strlen(), strcat(), strlwr(), strupr(), strcpy() etc.
 strlen(string);
It will return the length of the given string that is the number of characters contained by the string
including space.
e.g. WAP to input a string, display the length.
#include “string.h”
main(){
int Ln;
char name[100];
clrscr();
printf(“\nEnter The String : ”);
Ln=strlen(name);
printf(“\nThe Length of the given String is : %d”,Ln);
getch();
}
 strcpy(string1, string2);
Use to copy the string2 to string1
e.g.
main(){
char name[100], name2[100];
clrscr();
printf(“\nEnter The String : ”);

strcpy(name2, name);
printf(“\nThe Copied String is : %s”,name2);
getch();
}
 strcat(string1, string2);
It will concatenate the string2 to string1
e.g.
string1= “Biswajit”;
string2= “Panda”;
strcat(string1, string2);
printf(“\nThe Concatenated String is : %s”, string1);  BiswajitPanda
 strlwr(string);
It will convert the given string to lower case.
 strupr(string)
It will convert the given string to upper case.
e.g.
main(){
char name[100];
clrscr();
printf(“\nEnter a String : ”);
strlwr(name);
printf(“\nThe String in lower case is : %s”,name);
strupr(name);
printf(“\nThe String in UPPER CASE is : %s”,name);
getch();
}
Array:
Array is a type of variable can capable to contain a group of homogeneous data elements. Array
must have a size i.e. the maximum number of elements can be contained by the array. Each and every
elements are refers by a single name with having different index number. The array is of two types.
1. Single Dimensional Array
2. Multi Dimensional Array
1. Single Dimensional Array: This stores the elements in a single row format. It has a single
size. Each and every elements has an index number. it is declared as :
datatype arrayVariableName[size];
e.g. int arr[5]={14, 6, 64, 32, 42};
We can’t initialize more values than the size, and it is better to initialize 0 instead of blank if the number
of elements are less than the size.
e.g. int num[10]={45, 7, 79, 123, 56, 78, 0, 0, 0, 0};
we may or may not initialize the array elements.

int num=[10]={45, 7, 79, 123, 56, 78};
the above
num =
Index 0 1 2 3 4 5 6 7 8 9
Number
Values 45 7 79 123 56 78 ‘\0’
Addresses 1001 1003 1005 1007 1009 1011 1013 1015 1017 1019
The array elements ends with NULL value that is ‘\0’ (slashZero)
the array elements are stored in a consecutive memory location as above according to the size of the
data type. from the very beginning of the array declaration it allocate the given sized memory.
num[0]=45, num[1]=7, num[2]=79, num[3]=123, num[4]=56, num[5]=78, num[6]= ‘\0’.
for input or for output purpose we can use the looping controls to reach to each indexed value as :
Q> WAP to input 10 numbers to an array and display them.
main(){
int num[10], i;
clrscr();
printf(“\nEnter 10 numbers : ”);
for(i=0; i<10; i++)
scanf(“%d”,&num[i]);
printf(“\nThe Array Elements are : ”);
for(i=0; i<10; i++)
printf(“\nnum[%d] = %d”,i,num[i]);
getch();
}
Q> WAP to input 5 numbers to an array, calculate and display the sum value of all the elements.
main(){
intr num[5], i, sum=0;
printf(“\nEnter 5 Numbers to an Array : ”);
for(i=0; i<5; i++)
scanf(“%d”,&num[i]);
printf(“\nThe Array Elements or the entered values are : ”);
for(i=0; i<5; i++){
printf(“\nnum[%d] = %d”, i, num[i]);
sum=sum+num[i];
}
printf(“\nThe Sum Value of all the elements is : %d”, sum);
getch();
}
Q> WAP to input 10 numbers, find and display the greater one and smaller one.
Q> WAP to input 10 numbers to an array, display the 2 nd highest value.
Q> WAP to input 10 numbers, arrange them in ascending and in descending order.
2. Multi dimensional Array:
a. Two Dimensional Array: By using two dimensional array we can store the elements in
row and column manner that is in matrix form we can manipulate the elements. we
need to provide the row number and column number, each row having same number of
columns that is as :
datatype arrvarName[rowNo][colNo];
e.g.>
int num[4][3]= { 3, 5, 7,
5, 8, 9,
2, 5, 8,
1, 7, 9
};
The row and column numbers are the index numbers starts with 0 (zero) the columns are increased
towards right and rows are increased towards down i.e.
- 0 1 2
0 3 5 7
1 5 8 9
2 2 5 8
3 1 7 9
num[0][0]=3; num[0][1]=5; num[0][2]=7;

num[1][0]=5; num[1][1]=8; num[1][2]=9;
num[2][0]=2; num[2][1]=5; num[2][2]=8;
num[3][0]=1; num[3][1]=7; num[3][2]=9;
Q> WAP to input a matrix of 4:3 and display them as in matrix form.
main(){
int num[4][3], i, j, row, col;
clrscr();
printf(“\nEnter a 4:3 Matrix :”);
for(row=0; row<4; row++)
for(col=0; col<3; col++)
scanf(“%d”,&num[row][col]);
printf(“\nThe Elements are like\n”);
for(i=0; i<4; i++){
for(j=0; j<3; j++)
printf(“%d ”,num[i][j]);
printf(“\n”);
}
getch();
}
Q> WAP to input a 3:3 matrix, calculate and display the sum of all the elements and each row sum.
Q> WAP to input a 5:5 matrix, calculate the sum and display as they as following:
Left Diagonal Right Diagonal Left Lower Triangle Right Lower triangle
12345 12345 12345 12345
23436 23436 23436 23436

34967 34967 34967 34967
47678 47678 47678 47678
26789 26789 26789 26789
Left Upper Triangle Right Upper Triangle
12345 12345
23436 23436 00 01 02 03 04
34967 34967 10 11 12 13 14
47678 47678 20 21 22 23 24
26789 26789 30 31 32 33 34
40 41 42 43 44
Left Diagonal and it’s sum

#include “conio.h
main(){
int num[5][5], i, j, sum=0;
clrscr();
printf(“\nEnter a 5:5 Matrix : ”);
for(i=0; i<5; i++)
for(j=0; j<5; j++)
scanf(“%d”, &num[i][j]);
printf(“\nThe Left Lower Diagonal is : \n”);
for(i=0; i<5; i++){
for(j=0; j<5; j++)
if(i==j){
printf(“%d ”, num[i][j]);
sum=sum+num[i][j];
}
else
printf(“ ”);
printf(“\n”);
}
printf(“\nThe Left Diagonal Sum is : %d”, sum);
getch();
}
b. Three Dimensional Array: In three dimensional array we need to provide three different
size, the first size for table number, second one is for row number and third one is the
column number as, each table having same number of rows and columns.
int num[2][3][3]= {
2, 5, 7,
3, 4, 4,
7, 8, 9,
1, 2, 3,
4, 5, 6,
7, 8, 9
};
num =
0 1
2 5 7 1 2 3
3 4 4 4 5 6
7 8 9 7 8 9
num[0][2][1]
num[1][1][0]
Q> WAP to input a number and print it in word as 986  Nine Hundred Eighty Six
Q> WAP to input two 3:3 matrix, perform the matrix addition, subtraction and multiplication.
Pointer:
Pointer is a special type of variable, can be used as an dynamic array as well as pointer can points to
another variable of the type same.
Pointer Used as Dynamic Array:
int *num;
here num is the pointer variable can be used as an array as much as the size we will specify during run
time. Pointer allocates the memory for each element during run time that’s why pointer is otherwise
called as dynamic memory allocator.
e.g.
main(){
int *num, i=0, k;
char ch;
clrscr();
do{
scanf(“%d”,&num[i++]);
printf(“\nDo U Want to Continue : ”);
ch=getche();
}while((ch== ‘y’) || (ch== ‘Y’));
printf(“\nThe Array Elements are like : ”);
for(k=0; k<i; k++)
printf(“\n%d”,num[k]);
getch();
}
Pointer Used as Reference: Pointer variables can be use to refers to the address another variable of the
type same and both of the variable will use the same memory location, any of them is changing the
value means will affect to other.
e.g.
int *ptr, num;
num=150;
print num;  150
print &num;  1002// It will print the address of num.
print *ptr;  one garbage value, print the value part

print ptr;  1128;//print the address part
ptr=&num; // after assigning the address of variable to pointer both share the same memory location.
print &num;  1002
print ptr;  1002
print num;  150
print *ptr;  150
*ptr=290;
print num;  290
print *ptr;  290
Here num and *ptr is the value part and &num and ptr is the address part.
Structure:
Structure is a container type or user defined type can capable to contain non – homogeneous data
items. and all the data items will refers by a same name called as tag name (structure reference name).
the structure is generally declared at global area with the key word struct as :
struct structureName{
data items declaration;
}tagName;
e.g.
struct Student{
int roll;
char name[50];
}std={1001, “Pradyumna”};
all the data items of the structure can be access or manipulate as:
tagName.itemName
e.g.
struct Student{
int roll;
char name[50];
};
main(){
struct Student std;
clrscr();
printf(“\nEnter the Roll Number and Name : ”);
scanf(“%d%s”, &std.roll, &std.name);
printf(“\nThe Roll Number is : %d\nName is : %s”, std.roll, std.name);
getch();
}
Nested Structure:
When a structure id declared inside another structure that is called as nested structure.
e.g.
struct College{
struct Student{
int roll;
char name[50];
}std;
struct Teacher{
char empID[10];
char empName[50];
}t;
}col;
main(){
clrscr();
printf(“\nEnter the Roll Number and Name : ”);
scanf(“%d%s”, &col.std.roll, &col.std.name);
printf(“\nEnter the Teacher ID and Name : ”);
scanf(“%s%s”, &col.t.empID, &col.t.empName);
printf(“\nThe Roll Number is : %d\nName is : %s”, col.std.roll, col.std.name);
printf(“\nThe Teacher ID is : %s\nThe Name is : %s”,col.t.empID, col.t.empName);
getch();
}
Structure Array:
struct student{
int roll;
char name[50];
}std[5];
main(){
int i;
clrscr();
for(i=0; i<5; i++){
printf(“\nEnter a Student Roll Number and Name : ”);
scanf(“%d%s”,&std[i].roll, &std[i].name);
}
printf(“\nAll the Student Details are :\nRoll\tName”);
for(i=0; i<5; i++){
printf(“\n%d\t%s”,std[i].roll, std[i].name);
}
getch();
}
Union:
It is just like the structure, but each member of the union share a same memory that is the
maximum memory taken by the any particular member will be share to all. And for this reason each
member of the union must be processed one after another. union is the keyword use to declare an
union. Basically used for registry manipulations.
union UnionName{
members declaration;
}tagname;
e.g.
Q> WAP to input and display the student roll number and name using union.
union Student{
int roll;
char name[50];
}std;
main(){
clrscr();
printf(“\nEnter the Roll Number : ”);
scanf(“%d”,&std.roll);
printf(“\nThe Roll Number is : %d”,std.roll);
printf(“\nEnter the Name : ”);
scanf(“%[^\n]”,&std.name);
printf(“\nThe Name is : %s”,std.name);
getch();
}
Function
Function is a self contained block of statements to execute when it is called. Each and every function has
three different parts such are:
1. Function Declaration
2. Function Calling
3. Function Definition
1. Function Declaration: Generally a function is declared at global area, which specify the
return type, functionName and parameters type if require.
Syntax:
returnType functionName (parameters type if require);
Return type Specify the type of the value return from the function definition to function calling.
if we are not specifying the return type then by default the function return type is int, every
function should return a value unless the return type is void.
FunctionName can be any name but should follows the rules for declaring a variable.
Parameters are the references which receive the values from the function calling to function
definition.
e.g.
int sum(int, int);
2. Function Calling: A function can be call any where in the program but should be inside any
block, a function can directly call only by it’s name and arguments if require as:
functionName(arguments if require);
e.g.
s=sum(a,b);
printf(“\nThe Sum result is : %d”,sum(a,10));
The values or the references passes through the function calling are called as arguments.
3. Function Definition: A function must and should define outside of the block, It contains
the block of statements to execute when the particular function is called, it is otherwise called
as body of the function. It defines what a function will do when it will call. the functions are
defined as:
returnType functionName(parameters with type if require){
statement 1;
statement 2;
””””””””””
statement n;
}
e.g.
int sum(int x, int y){
return (x+y);
}
return is a keyword use to return the value or the reference from the function definition to function
calling.
e.g.
int sum(int, int);
int sum(int x, int y){

return (x+y);
}
void main(){
int a, b;
clrscr();
scanf(“%d%d”, &a, &b);
printf(“\nThe Addition Result is : %d”, sum(a,b));
getch();
}
Types of Functions
According to function calling the functions are of three types such are:
1. Call by Value Function: Here the values are passes through the function calling.
e.g. sum(a,10); sum(20, 30); sum(a, b);
2. Call by Reference Function: Here the references or the addresses are passes through the
function calling and receives with pointer variable in function definition. by using call by
reference function, it increases the speed of execution and decreases the memory due to
pointer.
e.g.
int sum(int *, int *); // function declaration

int sum(int *x, int *y) { // function definition
return ((*x)+(*y));
}
void main(){
int a, b, c;
clrscr();
scanf(“%d%d”, &a, &b);
c= sum(&a,&b);
printf(“\nThe Addition Result is : %d”,c);
getch();
}
3. Recursion Function: When a function is called by itself, or when a function is called inside
it’s own definition.
e.g.
Q> WAP to input a number, print it’s factorial, by using recursion function.
int factorial(int);
int factorial(int x){
static int r=1;
r=r*x--;
if(x<=1)
return r;
else
factorial(x);
}
void main(){
int n;
clrscr();
printf(“\nEnter a Number :”);
scanf(“%d”,&n);
printf(“\nThe Factorial is : %d”,factorial(n));
getch();
}
static is the keyword use to initialize the value to the variable once through out the continuity.
According to Passing Arguments and Return type the functions are of four types:
1. With Arguments With Return Value: int sum(int, int);
2. With Arguments no Return Value:
void sum(int x, int y){
printf(“\nThe Addition Result is: %s”,(x+y));
}
3. With No Argument with Return Value: ch=getche();
4. With No Argument no Return Value:
void display(){
printf(“\nHello World”);
}
void main(){
display();
}
Q> Write all the previous programs by using appropriate function.
File Management
File is the namely location at memory can capable to contain a group of related data and information. A
file must have a name. The different file operations are like:
1. Creating and Naming and Opening a file
2. Insert or write Data to the file
3. Retrieve or read data from the file
4. Close the file
For file operation in C program we must require a file pointer, can be declared as :
FILE *filePointerName;
The different files can be opened by using fopen() function as:

filePointerName = fopen(“path\\fileName”, “mode”);
The different modes are like
w – Write Mode (it will replace and existing file, remove all the previous data and add new data to the
file otherwise create a new file and can write the data to the file)
r – Read Mode use to open an existing file and read the data from the file.
a – Append Mode use to open an existing file and write the data at the end of the file otherwise create a
new file.
w+ - Write and Read Mode
r+ - Read and Write Mode
a+ - Append and read mode
How to read the data from the file?
#include "stdio.h"
#include "conio.h"
void main(){
FILE *fp;
char ch;
clrscr();
fp=fopen("d:\\biswajit\\student.txt", "r");
while((ch=getc(fp))!=EOF)
putc(ch, stdout);
fclose(fp);
getch();
}
How to Write the data to the file?
#include "stdio.h"
#include "conio.h"
void main(){
FILE *fp;
int roll;
char name[50], ch;
clrscr();
fp=fopen("d:\\biswajit\\student.txt", "a+");
do{
printf("\nEnter the Roll NUmber and Name : ");
scanf("%d%[^\n]",&roll, &name);
fprintf(fp, "\n%d\t%s",roll, name);
printf("\nDo U Want to Continue (y/n) : ");
ch=getche();
}while(ch=='y' || ch=='Y');
fclose(fp);
getch();
}
ftell(), fseek(), etc. are other functions are used in File pointer location get and set.
Macro
Macro are the small powerful # followed statements are used in C or C++ language to have certain
operations made easy and faster. These are otherwise called as pre processors directives. There are
three different pre processor directives are available in C as :
1. File Inclusion Directive
2. Definition directive
3. Conditional Directive
File Inclusion Directive:
# include “FileName” : as earlier we have used for including the header files.
Definition Directive:
# define num 50
# define my int
Now we can use my instead of int inside the same program.
Conditional Directives:
#ifdef, #if, #ifndef, #else, #elif, #endif are the conditional directives.
Introduction
C++ is one of the object oriented computer programming language developed by B.Jarne StrouStrop at
AT & T Bell laboratory of Murray Hill of USA in the year 1980. C++ extracted the Class and Construct
features from C and added the object oriented features of Simula 67. Simula 67 was the pure object
oriented programming language of that period. The C was previously named as C with Classes.
Difference between C and C++

SL.No. C C++
1 C is the procedural language C++ is the object oriented language
2 Emphasis is given to the procedure Emphasis is given to data
3 Data is not so secured Data is highly secured
4 C programs follows top bottom approach C++ follows bottom up approach of program
design
5 Variable declaration only made at first Any where we can declare the variable
6 Functions are the building blocks Objects are the building blocks
7 Functions can’t used inside a structure Functions can used inside a structure
8 A little critical for reusability Easy for reusability
9 C doesn’t support polymorphism and C++ support polymorphism and inheritance
inheritance
10 C is generally used for code development C++ is basically used for application
development
11 C doesn’t have exception handling C++ having exception handling mechanism.
mechanism.
12 The length of a name can be up to 32 The length of a name can be up to 255
characters characters.
13 C doesn’t support new and delete command C++ supports new and delete command
Object Oriented Programming:

Object oriented programming languages uses objects to perform the task that is the whole program is
divided into different sub units are called as objects. All OOP must support three technologies as:
Encapsulation, Polymorphism and Inheritance.
Skeleton of C++ Program

#include “headerFileName.h”
global declaration;
void main() {
statement1;
statement2;
|||||||
statementn;
}
C++ Tokens
1. Identifier
2. Data Type
3. Constants
4. Keywords
5. Escape Sequences
6. Operators
Identifier:
Identifiers are the namely location at memory can capable to contain the values or the references. The
variables or the references or any symbolical names are called as identifiers.
Data Type:
These are the keywords use to specify the type of the data can be contained by the variable. There are 3
different types of data type such are:
1. Fundamental Datatype
2. Derived Datatype
3. User Defined Datatype
1. Fundamental Datatype: There are four different fundamental data types are used in C++
program such are:
a. Integer
b. Character
c. Float
d. Void: This is used as return type that implies that the function block will not return any
value to the function calling.
2. Derived Datatype: These can be created of the fundamental types. The different derived types
are: Array, Pointer, Reference
3. User defined Datatype: These types are defined by the user to contain one or more values of
different types or as the same types. The different user defined datatypes are like:
struct, union, enum, typedef, class
Keywords:
There are certain reserve words reserve by the C++ compilers, which has their own meaning to the
compiler and called as keyword. In general there are 46 different keywords are used in C++ such are :
auto
Break, case, catch, char, class, const, continue, default, delete, do, double, else, enum, extern, float, for,
friend, goto, if, int, long, mutable, new, operator, private, protected, public, register, return, short,
signed, sizeof, static, struct, switch, template, this, throw, typedef, union, unsigned, virtual, void,
volatile, while.
And some other compilers has some other extended keywords.
Operators:
These are the symbols used with one or more operands to do operation over them. C++ includes all the
operators of C and some other different operators are like:
Scope Resolution: Multiplicative: Logical:
Scope resolution: :: Multiplication: * Logical AND: &&
Postfix: Division: / Logical OR: ||
Subscript: [ ] Modulus: % Assignment:
Function call: ( ) Additive: Assignment: =
Cast: () Addition: + Addition Assignment: +=
Member access: . and –> Subtraction: – Subtraction Assignment: –=
Postfix increment: ++ Shift: Multiplication Assignment: *=
Postfix decrement: –– Left shift: << () Division Assignment: /=
Unary: Right shift: >> Modulus Assignment: %=
Indirection: * Relational & Equality: Left shift assignment: <<=
Address-of: & Less than: < Right shift assignment: >>=
Logical Negation: ! Less than or equal to: <= Bitwise AND Assignment: &=
One's Complement: ~ Greater than: > Bitwise exclusive OR Assignment: ^=
Prefix increment: ++ Greater than or equal to: >= Bitwise inclusive OR Assignment: |=
Prefix decrement: -- Equality: == Conditional:
sizeof Not equal: != Conditional: ? :
new Bitwise: Pointer to Member:
delete Bitwise AND: & Pointer-to-member: .* or –>
Comma: , Bitwise exclusive OR: ^ Reference:
throw Bitwise inclusive OR: | Reference: &
For standard input and output operation we can use iostream.h header file in C++. The input and output
statements are like cout and cin.
cout:
This is the output statement use to send the output message to the standard output device as:
cout<< “Output Message with Escape Sequences”;
e.g. cout<< “\nHello World”;
Q> WAP to display Hello World.
#include “iostram.h”
void main() {
clrscr();
cout<< “\nHello World”;
getch();
}
cin:
cin is the input statement use to input the value to the program variable as:
cin>>variableName;
if we want to input more than one variable values then:
cin>>variableName1>>varName2>>…>>varnmn;
Q> WAP to input two numbers and print the addition result.
#include “iostream.h”
void main() {
int a, b;
clrscr();
cout<< “\nEnter Two Numbers : ”;
cin>>a>>b;
cout<< “\nA = ”<<a<< “\nB = ”<<b<< “\nThe Addition Result is : ”<< (a+b);
getch();
}
The constructs, array, string, pointer, structure, union, functions are same to the C.
Encapsulation
The wrapping up of data and methods into a single protected unit called as class and the mechanism is
called as Encapsulation. That is the capsulation or binding together of data and functions into a single
protected unit so that the data can be secured.
Class:
Class is a protected unit, where the data and methods binds together. Or class is a container or a general
form of an object or class is a logical abstraction of an object or a class defines the properties, behavior
or attribute of an object. The class members only can be access outside of the class by it’s object. a class
is consisting of dataMembers, memberFunctions, Constructors and Destructors. Class can be declared or
defined at global area of the program as:
class ClassName;
and can be defined as:
class ClassName {
accessSpecifier:
members declaration; or definition

}objectName;
e.g.
Q> WAP to input two numbers and display the addition result using class.
class Addition{
private:
int x, y;
public:
void setValue(int p, int q){
x=p;
y=q;
}
int getAddition(){
return (x+y);
}
}obj1;
void main() {
int a, b;
clrscr();
cout<< “\nEnter Two Numbers : ”;
cin>>a>>b;
obj1.setValue(a,b);
cout<< “\nThe Addition Result is : ”<< obj1.getAddition();
getch();
}
Object:
Object is an instance of a class can capable to contain separate members of the class in a separate
memory location. Each object will create separate memory of the corresponding class. The object can be
declared with the class as:
class ClassName {
-----
}objectName;
If we require to declare the object any where else then:
ClassName objectName;
If we require to declared more than one object then by putting the coma we can declare as:
ClassName objectName1, objName2, …, objNamen;
And the members of the class can be access outside of the class as objectName.memberName;
Access Specifiers can be of three types such are:
1. private: The private members of the class can access inside the class only. And through the
public member function of the class. If we are not specifying any access specifiers then by
default the access specifier is private.
2. protected: The protected members of the class are same to the private but the friends can
access. That is the friend class.
3. public: The public members of the class can be access outside of the class through the objects,
these members are publicly available to any object of the class.
Object Array:
The object also can be declared as an array, in order to create an array of objects.
class ClassName {
member declaration;
}objectName[size];
Here we can access the members as:
objectName[0].memberName;
Q> WAP to input 5 student details to an object array & display them as:
Roll Name Marks
1001 Ranjan 540
1002 Santosh 390
1003 Pradyumna 553
1004 Goutam 380
1005 Debasis 250
class Student {
private:
int roll;
char name[50];
int marks;
public:
void setDetails(int r, char *nm, int m) {
roll = r;
strcpy(name, nm);
marks = m;
}
int getRoll() { return roll; }
char * getName() { return name; }
int getMarks() { return marks; }
};
void main() {
int r1, m1;
char name1[50];
clrscr();
Student s[5];
for(int i=0; i<5; i++) {
cout<< “\nEnter the Roll Number : ”;
cin>>r1;
cout<< “\nEnter the Name : ”;
gets(name1);
cout<< “\nEnter the Marks : ”;
cin>>m1;
s[i].setDetails(r1, name1, m1);
}
cout<< “\nRoll\tName\t\tMarks”;
for (i=0; i<5; i++) {
cout<<endl<<s[i].getRoll()<< “\t”<< s[i].getName()<< “\t”<<s[i].getMarks();
}
getch();
}
dataMember: The variables, which are declared inside the class are called as data members.
memberFunction: The user defined functions which are used inside the class are called as member
functions. There are three different new functions are additionally used in C++ such are inline function,
virtual function and friend function. virtual function and friend function we will study later.
inline function:
To avoid the function declaration, definition, calling and returning back to the calling part,
passing arguments and extra time we uses macros in C, but there is a drawback to use the macro
because macros are not really functions and for this reason these are not compiled during compilation.
To eradicate this problem inline functions are used in C++. The inline functions are small functions,
which increases the execution speed. The inline function is declared and defined with the keyword inline
as:
inline returntype functionName (parameters with type if require){
statement;
}
Defining member function outside of the class:
If we require to define the member function outside of the class then first we must have to declare the
member function inside the class in order to get the accessibility. And then after only we can define
member function outside of the class by using scope resolution operator as:
Returntype ClassName :: memberFunctionName (parameters if require) {
body statements;
}
e.g.
class Sample {
public:
Sample(){ // default constructor
}
void display();
};
void Sample :: display () {
}
void main(){
Sample s1;
clrscr();
s1.display();
getch();
}
Polymorphism:
Poly means many morph means forms, polymorphism is the mechanism of using multiple forms of a
same object. The different real life examples are like: The same paper can be used for printing the news
paper, books, notes etc. The same person is differently acting in front of his parents, friends, relatives or
even in front of the teacher where as the person is same. That’s the different behavior of a same object
in different instance or in different time called as polymorphism.
The polymorphism includes:
1. Function Overloading
2. Constructor Overloading
3. Operator Overloading
Function Overloading:
When a same function can have multiple use, i.e. When a same function is used differently in different
instance by passing different arguments or types called as function overloading.
e.g.
class FunctionOverLoad {
public:
int sum (int x, int y){
return (x+y);
}
float sum(float x, float y){
return (x+y);
}
};
void main() {
int a, b;
float p, q;
clrscr();
cout<< “\nEnter Two Interger Number : ”;
cin>>a>>b;
FunctionOverLoad f1;
cout<< “\nThe Addition Result is : ”<<f1.sum(a,b);
cout<< “\nEnter Two Float Number : ”;
cin>>p>>q;
cout<< “\nThe Addition Result is : ”<<f1.sum(p,q);
getch();
}
Constructor overloading:
Constructor: Constructor is a public method or public function of the class, the constructor name is same
to the class name, it don’t have any return value not even void, the constructor is automatically
executed when the object of the class is created or during the object creation the constructor is
automatically executed. Basically the constructor is useful to initialize an object properties (i.e. from the
very beginning of the object creation what are the default values to be kept by the particular object).
When two or more constructors are defined for a same class then that is called as constructor
overloading, according to passing arguments during object creation, it will automatically select the
corresponding constructor of the class. The different types of constructors are like:
1. Default Constructor:
This is the simple constructor having no parameters and no body statement. This constructor is defined
to decrease the compiler overhead. If there is no constructor is defined then compiler create a default
constructor during run time while creating the object. This can be defined as:
ConstructorName () {
}
e.g.
class Sample{
public:
Sample(){ // default constructor
}
void display(){
}
};
void main(){
Sample s1;
clrscr();
s1.display();
getch();
}
2. Non Parameterize Constructor:
This is as like the default constructor but having the body statements. Use to initialize the object or use
to execute the enclosed statements while creating a normal non parameterized object. This can be
defined as:
ConstructorName(){
Statement1;
Statment2;
”””””””””
Statementn;
}
e.g.
class Sample{
int num;
public:
Sample(){ // Non Parameterized constructor
num=1001;
cout<< “\nThe Constructor is Executed”;
}
Int getNumber(){
return num;
}
};
void main(){
Sample s1;
clrscr();
cout<< “\nThe Number is : ”s1.getNumber();
getch();
}
3. Parameterized Constructor:
These type constructor having arguments during object declaration and according to the passing
arguments the constructor is defined, or according to the parameters defined in the constructor the
arguments are given during object creation. This can be defined as:
class Sample{
int num;
public:
Sample(int x){ // Parameterized Constructor
num=x;
cout<< “\nThe Constructor has Executed and set the number”;
}
int getNumber(){
return num;
}
};
void main(){
Sample s1(909);
clrscr();
cout<< “\nThe Number is : ”<<s1.getNumber();
getch();
}
4. Copy Constructor:
By using the copy constructor we can copy the properties of one object to another by passing the object
as argument and we need to define the constructor with object as parameter.
class Sample {
int num;
public:
Sample(int x) {
num=x;
}
Sample (Sample &sx) {

this->num = sx.num;
}
int getNumber() {
return num;
}
};
void main() {
Sample s1(909);
Sample s2(s1);
clrscr();
cout<< “\ns1.num = ”<<s1.getNumber()<<endl<< “s2.num = ”<<s2.getNumber();
getch();
}
this is a keyword or a pointer can be used inside a class to retrieve the members of the same object for
which currently the class is working.
5. Constructor Overloading:
The previous example of copy constructor, the class has defined two different types of constructor is
called as constructor overloading as it is given we can define any n number of different types of
constructor inside a same class and according to the passing argument it will execute the corresponding
constructor.
Operator Overloading
When a same operator can have multiple use or we can extend the use of the operator with out
changing it’s original meaning called as operator overloading. There are certain operators can’t be over
load such as:
. (dot) member access operator (e.g. a.b (b is the member of a object))
.* (dot asterisk) pointer member access operator(e.g. a.*b(b is the pointer member of a object))
? and : (ternary operator)
:: (scope resolution)
sizeof
Overloading of Binary Operator:
class Sample{
int num;
public:
Sample(){}
Sample(int x){
num=x;
}
Sample operator + (Sample &s){
Sample temp;
temp.num=num+s.num;
return temp;
}
int getNum(){
return num;
}
};
void main() {
Sample s1(25);
Sample s2(50);
Sample s3;
s3=s1+s2;
cout<< “\ns1.num = ”<<s1.getNum()<< “\ns2.num = ”<<s2.getNum();
cout<< “\ns2.num = ”<<s3.getNum();
getch();
}
Inheritance
The method of inheriting or deriving the properties of one object or class to another called as
inheritance, as in general:
Birds having two legs
Birds are of two types 1. Flying Birds(having wings) and 2. Non Flying Birds (having no wings)
Here Flying Birds or Non Flying Birds both having the same properties as having two legs derived the
property from the super object that is Bird.
In C++ there are five different types of inheritance such as:
1. Single Inheritance
2. Multiple Inheritance
3. Multi Level Inheritance
4. Hierarchical Inheritance
5. Hybrid Inheritance
1. Single Inheritance A
When a single class is derived from another single class, called as single inheritance. Here B
is the child class or derived class inherited from the base class or super class A.
Syntax : B
class ChildClassName : accessSpecifier BaseClassName{
defining the class;
};
According to the accessSpecifier the different properties of the base class will be inherited to the child
class i.e. as:
Inheritance Access Specifier Public Members Private Members Protected Members
Private private private Private
Protected protected private Private
Public public private Protected
2. Multiple Inheritance
When a same class is derived from multiple base class called as Multiple Inheritance.
here B is the child class derived from the base classes A and A1.
A A1
B
3. Multi Level Inheritance

When a base class is derived from another base class that is called as multi level inheritance. Here B is
derived from A and C is derived from B.
A
4. Hierarchical inheritance
When two or more child classes are derived from a same base class called as hierarchical inheritance.
Here B and C are derived from A.
A
B C
5. Hybrid inheritance
When two or more inheritance types are seen called as hybrid inheritance. A
Here B and C are derived from A and D is derived from B and C.
B C
Virtual Function:
When a function is defined or redefined in the child class and declared or defined in the base class (with
the keyword virtual) called as virtual function. This is otherwise called as function overriding i.e.
redefining the properties of the base class. The virtual function can be redefined in each sub classes. If a
class is derived from a base class and a non virtual function is over ridden then the base class function
will be called where as if the base class function is defined as the virtual then each sub class can be
redefined the same and the function will be called from the child class if exist.
e.g.
#include "iostream.h"
#include "string.h"
#include "conio.h"
class College{
private:
char name[100];
public:
College(){
strcpy(name, "WEBLINE Computer Education");
}
virtual char * getName(){
return name;
}
};
class Student : public College{

private:
char name[100];
public:
Student(char *nm){
strcpy(name, nm);
}
char * getName(){
return name;
}
};
void main () {
Student s1("MohanDas KarmChand Gandhi");
College c1;
College *cptr;
clrscr();
cptr=&c1;
cout<<"\nThe Name is : "<<cptr->getName();
cptr=&s1;
cout<<"\nThe Name is : "<<cptr->getName();
getch();
}
As pointing of the pointer the class properties will work. While cptr pointing to c1 then college class will
work and college name will display and when the cptr points to s1 then the student class will work and
display the student name. Exact use of virtual function we have more clarification by using pure virtual
function that is no body statements in virtual function. If there is no body in the virtual function in the
base class then it will be set to 0(Zero), then the class is called as abstract class and the function is called
as pure virtual function.
Abstract Class: When a base class contains one or more pure virtual functions then that is called as
abstract class. And each sub class needs to redefine the body of the virtual function. An abstract class is
not used to create the objects, only use to act as a base class where every base properties are declared
where the child classes will follow the base instructions.
e.g.
#include "string.h"
#include "conio.h"
class College{
public:
char name[100];
College(){
strcpy(name, "WEBLINE Computer Education");
}
virtual char * getName()=0;
};
class Student : public College{

public:
char * getName(){
return name;
}
};
void main () {
Student s1;
clrscr();
cout<<"\nThe Name is : "<<s1.getName();
getch();
}
Friend Function:
Friend function is a special function not belongs to the scope of any class, so can’t be called by
the object of any class, though it is not a member of any class, can access to the protected members of
the class. The Friend function must be declared inside the classes for which the function is going to deal,
it is declared with the keyword friend and defined as the normal functions are defined.
E.g.
#include "conio.h"
class Demo;
class Sample{
protected:
int num;
public:
Sample (int x){
num = x;
}
friend int Multiply (Sample, Demo);
};
class Demo{
protected:
int num;
public:
Demo (int x){
num=x;
}
friend int Multiply (Sample, Demo);
};
int Multiply (Sample ss, Demo dd){
return (ss.num*dd.num);
}
void main () {
clrscr();
Sample s(5);
Demo d(7);
cout<<"\nThe Multiplication Result is : "<<Multiply(s, d);
getch();
}
Library
There are several libraries or header file accelerators are used called as library functions or pre defined
functions in C++ called as library classes are also available for performing many different actions.
The different libraries are like:
ctype : Character type library
string : string manipulation library
math library
time library
stdlib : standard library
These all above libraries can be used in both C and C++
ios : incput and output library
STL : Standard Template library
These are used in C++ only
math.h
the different functions belongs to math.h are as follows:
double cos(angle double);
It will return the cosine of the given angle.
double sin(angle double);
It will return the sine of the given angle.
double tan(angle double);
It will return the tangent of the given angle.
double log(value double);

It will return the natural logarithm of the given value.
double log10(value double);
It will return the 10 base logarithm of the given value.
double sqrt(value double);
It will return the square root of the given value.
double pow(num double, power double);
It will return the power value of the given value raise to the given power.
time.h and dos.h
time_t : this is a pre defined variable type defines the time functions, declared in time.h.
e.g. WAP to display the current time.
#include “dos.h”
void main(){
struct time t;
gettime(&t);
printf("The current time is: %2d:%02d:%02d.%02d\n", t.ti_hour, t.ti_min, t.ti_sec, t.ti_hund);
getch();
}
e.g. WAP to display the current date in full format.
#include "stdio.h"
#include "conio.h"
#include "time.h"
void main() {
time_t t;
time(&t);
printf("Today's date and time: %s\n", ctime(&t));
getch();
}
stdlib.h
div(dividend, divisor)
It will return both quotient and the remainder.
e.g.
#include "stdlib.h"
#include "conio.h"
#include "stdio.h"
div_t x;/*div_t is a structure type used by div. div divides two integers and returns both the
quotient and the remainder as a div_t type.*/
void main() {
x = div(19,5);
printf("19 div 5 = %d and remainder is %d", x.quot, x.rem);
getch();
}
itoa(number, string, radix);

it will convert the given number to string the radix can be 2 to 36 specify the conversion
base. radix =10 implies to put the negative sign if the value is in negative.
e.g.
#include "stdlib.h"
#include "stdio.h"
#include "conio.h"
void main() {
int number = 12345;
char string[25];
itoa(number, string, 10);

printf("integer = %d string = %s", number, string);
getch();
}
max(num1, num2);
It will return the maximum value between two given values.
random(num);
It will return the random number between zero to given num-1.
ios
This is the super base class for input and output library in C++. ios implies input/output stream.
Stream refers to the temporary memory or a packet of temporary data and information. It’s child classes
are like istream and ostream. istream implies input stream and ostream implies output stream.
fstram.h and iostream.h are the header files which defines ifstream and ofstream these both classes are
derived from istream and ostream correspondingly.
cin and cout are the objects defined in iostream.h, are used for standard input and output operation.
The different methods belongs to these objects are like:
cin.get(char):
cout.put(char);
Use to input a single character.
#include "conio.h"
void main () {
char ch;
clrscr();
cout.write("\nEnter a Character : ", 20);
cin.get(ch);
cout<<"\nThe Entered Chater is : ";
cout.put(ch);
getch();
}
cin.getline();
Use to input a string upto the end of the line.
#include "conio.h"
void main () {
char name[50];
clrscr();
cout<<"\nEnter Your Name : ";
cin.getline(name, 50);
cout<<"\nYour Name is : "<<name;
getch();
}
File Input and Output Operation
fstream is the base class, inherits two child classes for file operation
that are ifstream(input file stream) and ofstream(output file stream).
ifstream provides different functions like open(), get(), getline(), read() etc.
ofstream provides different functions like open(), put(), write() etc.
open() is the method use to open a file.
#include "fstream.h"
#include "conio.h"
void main () {
char ch;
ifstream ifs;
ifs.open("e:\\loka\\allinone\\c\\cppfile.cpp");
while(!ifs.eof()){
ch=ifs.get();
cout<<ch;
}
getch();
}
#include "fstream.h"
#include "conio.h"
void main () {
char ch;
ofstream ofs("d:\\rama.txt");
while((ch=getche())!=27)
ofs.put(ch);
getch();
}
Data Structure is the mechanism or the logical way of storing and maintaining the data so that the
different data manipulation operations can be made easier. The different data manipulation operations
are like:
==> Insertion of Data.

==> Updating of Data.
==> Retrieval of the Data.
==> Deletion of Data.
The different data structure are like: linear data structure, non linear data structure
1. Linear Data Structure:

These type data structure techniques stores and manipulate the data in a sequential way. The different
linear data structures are like: Stack, Queue and Linked List
2. Non Linear Data Structure:
These type data structure techniques stores and manipulate the data in a non sequential way. The
different non - linear data structures are like: Tree and Graph.
Stack:
This is a linear data structure can be implemented by using array or by using the structure, though
mostly uses array to implement the stack. In general a stack is a collection of data and follows LIFO (Last
In First Out) technology to perform the different operations.
Q> WAP to implement the stack operations.

/*Stack Operations are like:
Push --> Insertion of Data.
Peep --> Retrieval of data.
Pop --> Deletion of data.
#include "stdio.h"
#include "conio.h"
#define max 50
void push();
void peep();
void pop();
int stack[max];
int first=0, last=0;
void main () {
push();
peep();
pop();
peep();
}
void push(){
char ch;
if(last<max) {
do{
printf("\nEnter a Number : ");
scanf("%d", &stack[last++]);
printf("\nDo U Want to Continue Pushing the Elements to the stack
(y/n) :");
ch=getche();
}while((ch=='y') && (last<max));
}
else
printf("Stack is Over Flow.");
}
void peep(){
int i;
printf("\nThe Stack Elements are like :\n");
for(i=last-1; i>=0; i--)
printf("\n%d", stack[i]);
}
void pop(){
char ch;
do{
last--;
printf("\nDo U Want to Continue Deletion (y/n): ");
ch=getche();
}while(ch=='y');
}
Queue:
By using this technology we can create a list which follows FIFO (First In First Out) technology. The queue
also can be implemented by using array as well as structure.
#include"stdio.h "
#include"conio.h"
#define size 10
int rear=0,front=0,q[size];
int value;
void insert_queue();
void delete_queue();
void display_queue();
void main() {
int k=0;
char ch;
do {
printf("\n1.Insertion\n2.Deletion\n3.Exit");
printf("Enter the Choice :");
ch=getche();
switch(ch) {
case 49:insert_queue();
printf("\nThe Queue After Insertion :");
display_queue();
break;
case 50:delete_queue();
printf("\nThe Queue After Insertion :");
display_queue();
break;
case 51:k=1;
}
}while(k!=1);
}
//
void insert_queue() {
printf("\nInput The Element :");
scanf("%d",&value);
if(rear<size) {
rear++;
q[rear]=value;
if(front==0)
front=1;
}
else
printf("\nQueue is Overflow");
}
//
void delete_queue() {
if(front==0) {
printf("\nQueue is UnderFlow");
return;
}
else {
value=q[front];
printf("The Element has Deleted :%d",value);

}
if(front==rear) {
front=0;
rear=0;
}
else
front++;
}
//
void display_queue() {
int i;
if(front==0)
return;
printf("\nThe Elements are :\n");
for(i=front;i<=rear;i++)
printf("\t%d",q[i]);
}
Linked List:
The linked list is the linear data structure. implemented by using structure pointer. There are two
different types of Linked List such are:
1. Single Linked List
2. Double Linked List
1. Single Linked List:
Each unit of the Linked List called as a node. a node contains data and information as well as a pointer to
the next node. The start node is always points to the first node.
e.g. WAP to implement the single linked list.

#include "stdio.h"
#include "conio.h"
struct student {
int roll;
struct student *next;
};
struct student *start, *node;
void insertList(struct student *);

void displayList(struct student *);
void updateList(struct student *);
void main () {
start=NULL;
node=start;
insertList(node);
node=start->next;
displayList(node);
node=start->next;
updateList(node);
node=start->next;
displayList(node);
getch();
}
void insertList(struct student *node){

char ch;
do{
node->next=(struct student *) malloc(sizeof(struct student *));
node=node->next;
printf("\nEnter the Roll Number : ");
scanf("%d", &node->roll);
node->next=NULL;
printf("\nDo U Want to Continue (y/n): ");
ch=getche();
}while(ch=='y');
}
void displayList(struct student *node){
printf("\nThe Entered Roll Numbers are Like : ");
while(node!=NULL){
printf("\n%d", node->roll);
node=node->next;
}
}
void updateList(struct student *node){

int r, flag=0;
printf("\nEnter the Roll Number U Want to Update : ");
scanf("%d", &r);
for(; node!=NULL; node=node->next){
if(node->roll==r){
printf("\nEnter the new Roll Number : ");
scanf("%d",&node->roll);
flag=1;
}
}
if(flag==0)
printf("\nList Not Found");
}
2. Double Linked List:

# include "stdio.h"
# include "conio.h"
# include "malloc.h"
struct Double {
int info;
struct Double *next;

struct Double *previous;
};
int num ;
struct Double start;
void Doubly_link_list (struct Double *);
void display (struct Double *);
// Function creates a simple doubly linked list
void Doubly_link_list(struct Double *node) {

char ch;
start.next = NULL; // Empty list
start.previous = NULL;
node = &start; // Point to the start of the list
num = 0;
printf("\n Input choice n for break: ");
ch = getchar();
while( ch != 'n') {
node->next = (struct Double *) malloc(sizeof(struct Double));
node->next->previous = node;
node = node->next;
printf("\n Input the values of the node : %d: ", (num+1));
scanf("%d", &node->info);
node->next = NULL;
fflush(stdin);
printf("\n Input choice n for break: ");
ch = getchar();
num ++;
}
printf("\n Total nodes = %d", num);
}
// Display the list
void display (struct Double *node) {

node = start.next;
printf("\nThe Elements are as Follows : ");
do {
printf("\n%d", node->info);
node = node->next;
} while (node->next); // Show value of last node only one time
printf("\nThe Elements are in Reverse as follows : ");
do {
printf("\n%d", node->info);
node = node->previous;
} while (node->previous);
void main() {
struct Double *node = (struct Double *) malloc(sizeof(struct Double));
Doubly_link_list(node);
printf("\n Created doubly linked list is as follows\n");
display(node);
getch();
}
Tree:
By using tree technology we can implement the non linear data structure i.e. in a highrarchically
manner. left and right sub node of the top node.
e.g.
#include"stdio.h"
#include"malloc.h"
struct NODE {
int Info;
struct NODE *Left_Child;
struct NODE *Right_Child;
};
struct NODE *Create_Tree (int , struct NODE *);

void Output(struct NODE *, int );
// Function to create a tree
struct NODE * Create_Tree (int Info, struct NODE *Node) {

if (Node == NULL) {
Node = (struct NODE *) malloc( sizeof(struct NODE ));
Node->Info = Info;
Node->Left_Child = NULL;
Node->Right_Child = NULL;
return (Node);
}
// Test for the left child

if (Node->Info >= Info )
Node->Left_Child = Create_Tree (Info, Node->Left_Child);
else
// Set all the rest of the elements as right child
Node->Right_Child = Create_Tree (Info, Node->Right_Child);

return(Node);
}
// Output function
void Output(struct NODE *T, int Level) {

int i;
if (T) {
Output(T->Right_Child, Level+1);
printf("\n ");
for (i = 0; i < Level; i++)
printf(" ");
printf("%d", T->Info);
printf("\n");
Output(T->Left_Child, Level+1);
}
}
// Function main
void main() {
int Info ;
char choice;
struct NODE *T = (struct NODE *) malloc(sizeof(struct NODE *));
T = NULL;
printf("\n Input choice 'b' to break:");
choice = getchar();
while(choice != 'b') {
printf("\n Input information of the node: ");
scanf("%d", &Info);
T = Create_Tree (Info, T);
printf("\n Tree is ");
Output(T, 1);
printf("\n Input choice 'b' to break:");
choice = getchar();
}
}

C

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

C

Uploaded by

Copyright:

Available Formats

Basic of C Programming in Depth 1

Short cut Commands used in Turbo C++ IDE

Some require points for C Program

5. The variablename should not be any pre defined key word.

Variable declaration syntax:

Data types, their size and range.

7. unsigned long 4 byte 0 to 4,294,967,295

Type Used For / Meaning

e.g. (a>b)?statement1: statement2;

Q> WAP to print your name as: Ranjan

printf(“\nEnter a Number : ”);

Q> WAP to input 5 numbers, display the smaller one.

Q> WAP to print the jar table from 2 to 5.

Q> WAP to input your name and display it.

char name[10]= “WELCOME”;

printf(“\nEnter The String : ”);

we may or may not initialize the array elements.

num[0][0]=3; num[0][1]=5; num[0][2]=7;

23436 23436 23436 23436

Left Diagonal and it’s sum

print *ptr;  one garbage value, print the value part

int sum(int, int);

int sum(int x, int y){

int sum(int *, int *); // function declaration

The different files can be opened by using fopen() function as:

Difference between C and C++

Object Oriented Programming:

Skeleton of C++ Program

members declaration; or definition

Sample (Sample &sx) {

3. Multi Level Inheritance

class Student : public College{

class Student : public College{

double log(value double);

itoa(number, string, radix);

itoa(number, string, 10);

==> Insertion of Data.

1. Linear Data Structure:

Q> WAP to implement the stack operations.

int first=0, last=0;

printf("The Element has Deleted :%d",value);

e.g. WAP to implement the single linked list.

struct student *start, *node;

void insertList(struct student *);

void insertList(struct student *node){

void updateList(struct student *node){

2. Double Linked List:

struct Double *next;

// Function creates a simple doubly linked list

void Doubly_link_list(struct Double *node) {

// Display the list

void display (struct Double *node) {

struct NODE *Create_Tree (int , struct NODE *);

// Function to create a tree

struct NODE * Create_Tree (int Info, struct NODE *Node) {

// Test for the left child

// Set all the rest of the elements as right child

Node->Right_Child = Create_Tree (Info, Node->Right_Child);

void Output(struct NODE *T, int Level) {

You might also like

int sum(int , int ); // function declaration

struct student start, node;

struct NODE Create_Tree (int , struct NODE );