C++:

ABSTRACT

The C++ programming language was created by Bjarne Stroustrup and

his team at Bell Laboratories (AT&T, USA) to help implement
simulation projects in an object-oriented and efficient way. The
earliest versions, which were originally referred to as “C with classes,”
date back to 1980. As the name C++ implies, C++ was derived from the
C programming language: ++ is the increment operator in C. In 1998
the ISO (International Organization for Standardization) approved
a standard for C++ (ISO/IEC 14882). C++ is not a purely object-
oriented language but a hybrid that contains the functionality of the C
programming language. This means that you have all the features that
are available in C:
• Universally usable modular programs.
• Efficient, close to the machine programming.
• Portable programs for various platforms.

C:
The C programming language is a computer programming language
that was developed to do system programming for the operating
system UNIX and is an imperative programming language. C was
developed in the early 1970s by Ken Thompson and Dennis Ritchie at
Bell Labs. It is a procedural language, which means that people can
write their programs as a series of step-by-step instructions. C is a
compiled language. Because the ideas behind C are kept close to the
design of the computer, the compiler (program builder) can generate
machine code/native code for the computer. Programs built in machine
code are very fast. This makes C a good language for writing operating
systems. Many operating systems, including Linux and UNIX, are
programmed using this language. The language itself has very few
keywords, and most things are done using libraries, which are
collections of code for them to be reused.

C++:

INDEX
S.No Topic Page No.

01. Introduction to c++ 1

02. C++ fundamentals 2-3

03. C++ Programming 4

04. Structure of C++ program 5-7

05. If Else Statement 8-10

06. Iteration Statements 11-19

07. Function 20-23

08. Pointer 24-26

09. Array 27-29

10. Linked List 30-43

C:

INDEX
S.No Topic Page No.

01. Introduction to c 44

02. C fundamentals 44

03. C Programming 45

04. Structure of C program 45-46

05. If Else Statement 47-48

06. Iteration Statements 49-53

07. Function 54-56

08. Array 56-57

09. Pointer 58-59

 10. Student result management project 60-71

11. Conclusion 72

Introduction to C++

C++ is not a purely object-oriented language but a hybrid that contains

the functionality of the C programming language. The features that are
available in C:
• universally usable modular programs
• efficient close to the machine programming
• portable programs for various platforms.
Case Sensitivity:
C++ is case sensitive. In other words, uppercase and
lowercase letters are considered to be different.
C++ supports the concepts of object-oriented programming which are:
• data abstraction, that is, the creation of classes to describe objects
• data encapsulation for controlled access to object data
• inheritance by creating derived classes
• polymorphism i.e. the implementation of instructions that can
have varying effects during program execution.
Objects
Object-oriented programming shifts the focus of attention to the objects,
that is, to the aspects on which the problem is centered .OOP objects
combine data and functions (capacities). A class defines a certain object
type by defining both the properties and the capacities of the objects of
that type.
Advantages of OOP
Object-oriented programming offers several major advantages
to software development:
• reduced susceptibility to errors: an object controls access to its own
data. More specifically, an object can reject erroneous access attempts.
• easy re-use: objects maintain themselves and can therefore be used
as building blocks for other programs.
• low maintenance requirement: an object type can modify its own
internal data representation without requiring changes to the
application.
C++ Fundamentals
The following three steps are required to create and translate a C++ program:
• First, a text editor is used to save the C++ program in a text file. In
other words, the source code is saved to a source file. In larger
projects the programmer will normally use modular programming.
This means that the source code will be stored in several source files
that are edited and translated separately.
• The source file is put through a compiler for translation. If
everything works as planned, an object file made up of machine code
is created. The object file is also referred to as a module.
• Finally, the linker combines the object file with other modules to
form an
executable file.
It is important to use the correct file extension for the source file’s
name. Although the file extension depends on the compiler you use, the
most commonly found file extensions are .cpp and .cc.
Fundamental Types, Constants, and Variables

Variable:

In C++ a variable is a place to store information. A variable is a location

in your computer’s memory in which you can store a value and from
which you can later retrieve that value.

Keywords
Some words are reserved by C++, and you may not use them as variable
names. These are keywords used by the compiler to control your
program. Keywords include if, while, for, and main.
Characters
Character variables (type char) are typically 1 byte, enough to hold 256
values (see Appendix C). A char can be interpreted as a small number
(0–255) or as a member of the ASCII set. ASCII stands for the American
Standard Code for Information Interchange. The ASCII character set
and its ISO (International Standards Organization) equivalent are a
way to encode all the letters, numerals, and punctuation marks.
Constants
Like variables, constants are data storage locations. Unlike variables,
and as the name implies, constants don’t change. You must initialize a
constant when you create it, and you cannot assign a new value later.
C++ has two types of constants: literal and symbolic.
Literal Constants
A literal constant is a value typed directly into your program wherever it
is needed. For example:
int myAge = 39;
myAge is a variable of type int; 39 is a literal constant. You can’t assign
a value to 39, and its value can’t be changed.
Symbolic Constants
A symbolic constant is a constant that is represented by a name, just as a
variable is represented.
Unlike a variable, however, after a constant is initialized, its value can’t
be changed.
C++ Programming

Structure of a c++ program:

Program 1. Simple output

• Header File:

#include <iostream>
Lines beginning with a hash sign (#) are directives for the preprocessor.
They are not regular code lines with expressions but indications for the
compiler's preprocessor. In this case the directive #include <iostream>
tells the preprocessor to include the iostream standard file. This
specific file (iostream) includes the declarations of the basic standard
input-output library in C++, and it is included because its functionality
is going to be used later in the program.
• using namespace std;
All the elements of the standard C++ library are declared within what is
called a namespace, the namespace with the name std. So in order to
access its functionality we declare with this expression that we will be
using these entities.
• Main function:

int main ()
This line corresponds to the beginning of the definition of the main
function. The main function is the point by where all C++ programs start
their execution, independently of its location within the source code.
The word main is followed in the code by a pair of parentheses (()).
That is because it is a function declaration: In C++, what differentiates
a function declaration from other types of expressions are these
parentheses that follow its name.
• Body:
 Right after these parentheses we can find the body of the main function
enclosed in braces ({}). What is contained within these braces is what
the function does when it is executed.
Program 2. Program to add two numbers

1. #include
<iostream> 2.
3. using
namespace std; 4.
5. int main()
6. {
7. int
a, b, c; 8.
• cout << "Enter two integers to add\n";
• cin
>> a >> b; 11.
• c = a + b;
• cout <<"Sum of the numbers: " << c
<< endl; 14.
• return 0;
16. }

Output:

If-Else:
Sometimes we need to execute a block of statements only when a
particular condition is met or not met. This is called decision making,
as we are executing a certain code after making a decision in the
program logic. For decision making in C++, we have four types of
control statements (or control structures), which are as follows:
• if statement
• nested if statement
• if-else statement
• if-else-if statement
If statement in C++:

If else statement in C++:

Sometimes you have a condition and you want to execute a block of
code if condition is true and execute another piece of code if the same
condition is false. This can be achieved in C++ using if-else statement.
 Program 3. Check Whether Number is Even or Odd using if else

17. }

Output:

Program 4. Check Whether Number is Prime or not using if else

9
Output:

Itertion Statements:

A loop statement allows us to execute a statement or group of

statements multiple times and following is the general from of a loop
statement in most of the programming languages –

C++ programming language provides the following type of loops to

handle looping requirements. There are three type of loops in C++
programming:
• for loop
• while loop
• do...while loop
For Loop:

How for loop works?

• The initialization statement is executed only once at the beginning.
• Then, the test expression is evaluated.
• If the test expression is false, for loop is terminated. But if the test
 expression is true, codes inside body of for loop is executed and
update expression is updated.
• Again, the test expression is evaluated and this process repeats
until the test expression is false.

Program 5. Table of an integer:

Display Multiplication table up to 10

Output:

While Loop:
How while loop works?
• The while loop evaluates the test expression.
• If the test expression is true, codes inside the body of
while loop is evaluated.
• Then, the test expression is evaluated again. This process goes on
until the test expression is false.
• When the test expression is false, while loop is terminated.

Program 6. Fibonacci series:

13. for (int i = 1; <= n; ++i)

14. { i
15. first two terms.
// Prints
the
16. if(i == 1)
17. {
18. cout << " " << t1;
19. continue;
20. }
21. if(i == 2)
22. {
23. cout << t2 << " ";
24. continue;
25. }
26. nextTerm = t1 + t2;
27. t1 = t2;
28. t2 = nextTerm;
29.
30. cout << nextTerm << " ";
31. }
32. return 0;
33. }

Output:

Do While Loop:
How do...while loop works?
• The codes inside the body of loop is executed at least once. Then,
only the test expression is checked.
• If the test expression is true, the body of loop is executed.
This process continues until the test expression becomes false.
• When the test expression is false, do...while loop is terminated.

Program 7.Armstrong Number :

#includ
e<stdio
.h>
#includ
e<conio
.h>
void
main()
{

int
n,c,d,s=0,num
; clrscr();
printf("\n Enter Any Number :
"); scanf("%d",&n);
n
u
m
=
n
;

d
o
{

d=n%10;

c
=
d
*
d
*
d
;

s
=
s
+
c
;
 n
=
n
/
1
0
;
}while(n!
=0);
if(s==num)
printf("\n %d is Armstrong
Number",num); else
printf("\n %d is Not an Armstrong
Number",num); getch();

Output:

Function:
A function is a group of statements that together perform a task. Every
C++ program has at least one function, which is main(), and all the
most trivial programs can define additional functions.
A function declaration tells the compiler about a function's name, return type,
and parameters. A function definition provides the actual body of the function.
The C++ standard library provides numerous built-in functions that your
program can call. For example, function strcat() to concatenate two
strings,
function memcpy() to copy one memory location to another location
and many more functions.

body. Here are all the parts of a function −

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

Types of function
We have two types of function in C++:

• Build-in functions
Built-in functions are also known as library functions. We need not to
declare and define these functions as they are already written in the C++
libraries such as iostream, cmath etc. We can directly call them when we
need.
• User-defined functions
The functions that we declare and write in our programs are user-
defined functions.

Program 8.Check if the given no is palindrome or not using function:

#include<ios
tream> using
namespace
std;
int

checkNum

ber(int n)

{ int r, rev

= 0;

whi
l
e

(
n

>

0
)

1
0
;
rev =
 rev *
10 + r;
n=n/
10;
}
return rev;
}

int

ai

n(

in

n,

cout << "Enter

Number :";
 cin>>n;

num =
checkNumber
(n); if (num
== n) {
cout << "\n Number is Palindrome :" << n;
} else {
cout << "\n Number is Not Palindrome :" << n;
}

return 0;
}

Output:

Pointers:
Pointers are powerful features of C++ that differentiates it from other
programming languages like Java and Python.
Pointers are used in C++ program to access the memory and
manipulate the address.
Address in C++:
To understand pointers, you should first know how data is stored on the
computer. Each variable you create in your program is assigned a
location in the computer's memory. The value the variable stores is
actually stored in the location assigned. To know where the data is
stored, C++ has an & operator. The & (reference) operator gives you
the address occupied by a variable. If var is a variable
then, &var gives the address of that
variable. Following are the valid pointer
declaration –
int *ip; // pointe to an
r integer
doubl *dp; // pointe to a double
e r
float *fp; // pointe to a float
 r
char *ch // pointe to character
r

Using Pointers in C++:

There are few important operations, which we will do with the pointers
very frequently. (a) We define a pointer variable. (b) Assign the address
of a variable to a pointer. (c) Finally access the value at the address
available in the pointer variable. This is done by using unary operator *
that returns the value of the variable located at the address specified by
its operand.
Program 9. Program to Swap Elements Using Call by Reference:

Output:

Enter value of a, b and c

respectively: 1 2
3

Value before swapping:

=
 2

Value after swapping numbers

in cycle: a=3
b=1

c=2

Array:
C++ provides a data structure, the array, which stores a fixed-size
sequential collection of elements of the same type. An array is used to
store a collection of data, but it is often more useful to think of an array
as a collection of variables of the same type.
Instead of declaring individual variables, such as number0, number1, ...,
and number99, you declare one array variable such as numbers and use
numbers[0], numbers[1], and ..., numbers[99] to represent individual
variables. A specific element in an array is accessed by an index.
Declaring Arrays:
To declare an array in C++, the programmer specifies the type of the
elements and the number of elements required by an array as follows –
type arrayName [ arraySize ];

Arrays in C++:

Arrays are important to C++ and should need lots of more detail. There
are following few important concepts, which should be clear to a C++
programmer –

Sr.N Concept & Description

o
 1 Multi-dimensional arrays
C++ supports multidimensional arrays. The simplest form of the
multidimensional array is the two-dimensional array.

2 Pointer to an array
You can generate a pointer to the first element of an array by simply
specifying the array name, without any index.

3 Passing arrays to functions

You can pass to the function a pointer to an array by specifying the
array's name without an index.

4 Return array from functions

C++ allows a function to return an array.

Program 10. Find Transpose of a Matrix

Output:
 1 0

2 4

9 7

Linked Lists:
29
odes" th
A linked list is a series of connected "n at contains the
"address" of the next node. Each node can store a data point which
may be a number, a string or any other type of data.

Utility of Linked List:

Lists are one of the most popular and efficient data structures, with
implementation in every programming language like C, C++, Python,
Java and C#.
Apart from that, linked lists are a great way to learn how pointers work.
By practicing how to manipulate linked lists, you can prepare yourself
to learn more advanced data structures like graphs and trees.
Types of Linked List -
There are three common types of Linked List.
• Singly Linked List
• Doubly Linked List
• Circular Linked List
Singly Linked List
It is the most common. Each node has data and a pointer to the
next node. Node is represented as:
• struct node {
• int data;
• struct node *next;
4. }

Doubly Linked List 30

We add a pointer to the previous node in a doubly linked list. Thus, we

can go in either direction: forward or backward. A node is represented as
Circular Linked List
A circular linked list is a variation of linked list in which the last
element is linked to the first element. This forms a circular loop. A
circular linked list can be either singly linked or doubly linked.
• for singly linked list, next pointer of last item points to the first item
• In doubly linked list, prev pointer of first item points to last item as well.

31
Program 11. C++ Program To Implement Singly Linked List:

The program output is also shown below.

33. single_llist()
34. {
35. start = NULL;
36. }
37. }; 32
38.
39. /*
40. * Main :contains menu
41. */
42. main()
43. {
• int choice, nodes, element, position,
i;
• single_llist sl;
• start = NULL;
• while (1)
48. {
49.
cout<<endl<<"---------------------------
------"<<endl;
50. cout<<endl<<"Operations on
singly linked list"<<endl;
51.
cout<<endl<<"---------------------------
------"<<endl;
• cout<<"1.Insert Node
at
beginning"<<endl;
• cout<<"2.Insert node at
last"<<endl;
• cout<<"3.Insert node at
position"<<endl;
• cout<<"4.Sort Link List"<<endl;
• cout<<"5.Delete a Particular Node"<<endl;
• cout<<"6.Update Node Value"<<endl;
• cout<<"7.Search Element"<<endl;
• cout<<"8.Display Linked
List"<<endl;
• cout<<"9.Reverse Linked List
"<<endl;
• cout<<"10.Exit "<<endl;
• cout<<"Enter your choice : ";
• cin>>choice;
• switch(choice)
65. {
66. case 1:
• cout<<"Inserting Node at Beginning: "<<endl;
• sl.insert_begin();
• cout<<endl;
• break;
71. case 2: 33
72. c Inserting Node at
Last: "<<endl;

73. sl.insert_last();
74. cout<<endl;
75. break;
76. case 3:
77. cout<<"Inserting Node at give
positio a n
n :"<<endl;
78. sl.insert_pos();
79. cout<<endl;
80. break;
81. case 4:
82. cout<<"Sort Link List: "<<endl;
83. sl.sort();
84. cout<<endl;
85. break;
86. case 5:
87. cout<<"Delete a particular node
:
 "<<endl;
• sl.delete_pos();
• break;
• case 6:
• cout<<"Update Node Value:"<<endl;
• sl.update();
• cout<<endl;
• break;
• case 7:
• cout<<"Search element in Link List: "<<endl;
• sl.search();
• cout<<endl;
• break;
• case 8:

out<<"

• cout<<"Display elements of link

list"<<endl;
• sl.display();
• cout<<endl;
• ;
•
out<<"
•
• casebreak
9: 34
• c Reverse elements of
Link List"<<endl;
• sl.reverse();
• cout<<endl;
• break;
• case 10:
• cout<<"Exiting..."<<endl;
• exit(1);
• break;
• default:
• cout<<"Wrong choice"<<endl;
116. }
117. }
1
1
8
.
} 119.
120. /*
121. * Creating Node
 122. */
123. node *single_llist::create_node(int
value)
124. {
• struct node *temp, *s;
• temp = new(struct node);
• if (temp == NULL)
128. {
• cout<<"Memory not allocated
"<<endl;
• return 0;
131. }
132. else
133. {
• temp->info = value;
• temp->next = NULL;
• return temp;
137. }
1
3
8
.
} 139.
140. /*
141. * Inserting element in beginning
142. */
nsert
143. void single_llist::i
144. {
• int value;
35 _begin()
• cout<<"Enter the value to be inserted:
";
• cin>>value;
• struct node *temp, *p;
• temp = create_node(value);
• if (start == NULL)
151. {
• start = temp;
• start->next = NULL;
154. }
155. else
156. {
• p = start;
• start = temp;
• start->next = p;
160. }
161. cout<<"Element Inserted at
beginning"<<endl;
1
6
2
.
} 163.
164. /*
165. * Inserting Node at last
166. */
167. void single_llist::insert_last()
168. {
• int value;
• cout<<"Enter the value to be inserted:
";
• cin>>value;
• struct node *temp, *s;
• temp = create_node(value);
• s = start;
• while (s->next != NULL)
176. {

177. s = s->next;
178. }
179. temp->next = NULL;
180. s->next = temp;
181. cout<<"Element ted at
last"<<endl; 182. } 36
183.
184. /*
185. * Insertion of node at a given position
186. */
187. void single_llist::insert_pos()
188. {
• int value, pos, counter = 0;
• cout<<"Enter the value to be inserted: ";
• cin>>value;
• struct node *temp, *s, *ptr;
• temp = create_node(value);
• cout<<"Enter the postion at which node to be
inserted: ";

195. cin>>pos;
196. int i;
197. s = start;
198. while (s != NULL)
199. {
 200. s = s->next;
201. counter++;
202. }
203. if (pos == 1)
204. {
205. if (start == NULL)
206. {
207. start = temp;
208. start->next = NULL;
209. }
210. else
211. {
212. ptr = start;
213. start = temp;
214. start->next = ptr;
Inser

215. }
216. }
217. else (pos > 1 && pos <= counter)
if
218. {
219. s = start;
i < p
220. 37
for (i = 1;
221. {
• ptr = s;

os; i++)
• s = s->next;
224. }
• ptr->next = temp;
• temp->next = s;
227. }
228. else
229. {
230. cout<<"Positon out of
range"<<endl;
231. }
2
3
2
.
} 233.
234. /*
235. * Sorting Link List
236. */
237. void single_llist::sort()
238. {
• struct node *ptr, *s;
• int value;
• if (start == NULL)
242. {
• cout<<"The List is empty"<<endl;
• return;
245. }
• ptr = start;
• while (ptr != NULL)
248. {
249. for (s = ptr->next;s !=NULL;s = s-
>next)
250. {
251. if (ptr->info > s->info)
252. {
253. value = ptr->info;

254. ptr->info = s->info;

255. s->info = value;
256. }
257. }
ptr = ptr->n
258.
259. } 38
260.
} 261.
262. /*
263. * Delete element at a given position
264. */
265. void single_llist::delete_pos()
266. {
• int pos, i, counter = 0;
• if (start == NULL)
269. {
• cout<<"List is empty"<<endl;
• return;

272. }
273. cout<<"Enter the position of to be
deleted value
 : 274. ";
cin>>pos;
275. struct node *s, *ptr;
276. s = start;
277. if (pos == 1)
278. {
279. start = s->next;
280. }
281. else
282. {
283. while (s != NULL)
284. {
285. s = s->next;
286. counter++;
287. }
288. if (pos > 0 && pos <=
counter)
289. {
290. s = start;
291. for (i = 1;i < pos;i++)
ext;

292. {
• ptr = s;
• s = s->next;
295. }
296. ptr->next = s->next;
297. } 39
298. else
299. {
300. cout<<"Position out of
range"<<endl;
301. }
• free(s);
• cout<<"Element Deleted"<<endl;
304. }
3
0
5
.
} 306.
307. /*
308. * Update a given Node
309. */
310. void single_llist::update()
311. {
• int value, pos, i;
• if (start == NULL)
314. {
• cout<<"List is empty"<<endl;
• return;
317. }
• cout<<"Enter the node postion to be
updated: ";
• cin>>pos;
• cout<<"Enter the new value: ";
• cin>>value;
• struct node *s, *ptr;
• s = start;
• if (pos == 1)
325. {
326. start->info = value;
327. }
328. else
329. {
330. for (i = 0;i < pos - 1;i++)
331. {
332. if (s == NULL)
333. {
• c
•
• eturn;
• out<<"There are less
than
"<<pos<<" elements"; 40
• r
336. }
337. s = s->next;
338. }
339. s->info = value;
340. }
341. cout<<"Node Updated"<<endl;
3
4
2
.
} 343.
344. /*
345. * Searching an element
346. */
347. void single_llist::search()
348. {
• int value, pos = 0;
• bool flag = false;
• if (start == NULL)
352. {
• cout<<"List is empty"<<endl;
• return;
355. }
• cout<<"Enter the value to be searched:
";
• cin>>value;
• struct node *s;
• s = start;
• while (s != NULL)
361. {
• pos++;
• if (s->info == value)
364. {
• flag = true;
• cout<<"Element "<<value<<" is found at
position "<<pos<<endl;

367. }
368. s = s->next;
369. }
370. if (!flag)
371. cout<<"Element "<<value<<" found i
not n
the list"<<endl;
372. }
373.
374. /*
375. * Reverse Link List
376. */
377. void single_llist::reverse()
378. {
379. struct node *ptr1, *ptr2,
*ptr3;
380. if (start == NULL)
381. {
382. cout<<"List is empty"<<endl;
383. return;
384. }
385. if (start->next == NULL)
386. {
387. return;
388. }
389. ptr1 = start;
390. ptr2 = ptr1->next;
 391. ptr3 = ptr2->next;
392. ptr1->next = NULL;
393. ptr2->next = ptr1;
394. while (ptr3 != NULL)
395. {
396. ptr1 = ptr2;
397. ptr2 = ptr3;
398. ptr3 = ptr3->next;
399. ptr2->next = ptr1;
400. }
401. start = ptr2;
402. }
403.
404. /*
ULL)

Output:
1.Insert Node at
beginning 2.Insert node
at last 3.Insert node at
position 4.Sort Link List
5.Delete a Particular
Node 6.Update Node
Value 7.Search Element
8.Display Linked List
9.Reverse Linked List
10.Exit
Enter your choice : 1
Inserting Node at
Beginning:
Enter the value to be inserted: 100

Element Inserted at beginning

uction t
e progra
Introd
 43 oC
C is a high-level and general-purpos mming language that is
ideal for developing firmware or portable applications. Originally
intended for writing system software, C was developed at Bell Labs by
Dennis Ritchie for the Unix Operating System in the early 1970s.
Ranked among the most widely used languages, C has a compiler for
most computer systems and has influenced many popular languages –
notably C++.

Structure of a C program:

The components of the above structure are:

• Header Files Inclusion: A header file is a file with extension .h
which contains C function declarations and macro definitions to
be shared between several source files.
Syntax to include a header file in C:
#include <(header_file_name).h>

• Main Method Declaration: The next part of a C program is to

declare the main() function. The syntax to declare the main
function is:

• Variable Declaration: The next part of any C program is the

variable declaration. It refers to the variables that are to be used in
the function. Please note that in C program, no variable can be
used without being declared. Also in a C program, the variables
are to be declared before any operation in the function.
Example:
int main()
{
int a;
.
.
• Body: Body of a function in C program, refers to the operations that are
performed in the functions. It can be anything like manipulations,
 searching, sorting, printing, etc.
Example:
int main()
{
int a;

printf("%d", a);
.
.
• Return Statement: The last part in any C program is the return
statement.
The return statement refers to the returning of the values from a
function. This return statement and return value depend upon the
return-type of the function. For example, if the return type is void,
then there will be no return statement.
In any other case, there will be a return statement and the return
value will be of the type of the specified return-type.

Statement
if
ssion insi 46
The if statement evaluates the test expre de the parenthesis ().
• If the test expression is evaluated to true, statements inside the
body of if are executed.
• If the test expression is evaluated to false, statements
inside the body of if are not executed.
The syntax of the if statement in C programming is:

if...else Statement
If the test expression is evaluated to true:
• statements inside the body of if are executed.
• statements inside the body of else are skipped from execution.
 If the test expression is evaluated to false,
• statements inside the body of else are executed
• statements inside the body of if are skipped from execution.
The if statement may have an optional else block. The
syntax of the if..else statement is:

47
Program 1: if...else statement

Output:
Enter an integer: 7
7 is an odd integer.

ITERATION STATEMENTS: 48
C for Loop:
Loops are used in programming to execute a block of code repeatedly until
a specified condition is met.
C programming has three types of loops:
• for loop
• while loop
• do...while loop
For Loop
The syntax of the for loop is:

Program 2: for loop

• # Print numbers from 1 to 10 49
• #include <stdio.h>
3.
• int main() {
• int i;
6.
7. for (i = 1; i < 11; ++i)
8. {
9. printf("%d ", i);
10. }
11. return 0;
12. }

Output

while loop
The syntax of the while loop is:

Program 3: while loop

Output

do...while loop
The do..while loop is similar to the while loop with one important
difference. The body of do...while loop is executed at least once. Only
then, the test expression is evaluated.
The syntax of the do...while loop is:

Program 4: do...while loop

 Functions

ms a sp gram easy
Types of function
Depending on whether a function is defined by the user or already included in
C compilers, there are two types of functions in C programming
There are two types of function in C programming:

• Standard HYPERLINK
"https://www.programiz.com/c-programming/library-function"
HYPERLINK "https://www.programiz.com/c-programming/library-
function" HYPERLINK
"https://www.programiz.com/c-programming/library-function"
HYPERLINK "https://www.programiz.com/c-programming/library-
function" HYPERLINK
"https://www.programiz.com/c-programming/library-function"
HYPERLINK "https://www.programiz.com/c-programming/library-
function"library HYPERLINK "https://www.programiz.com/c-
programming/library-function" HYPERLINK
"https://www.programiz.com/c-programming/library-function"
 HYPERLINK "https://www.programiz.com/c-programming/library-
function" HYPERLINK
"https://www.programiz.com/c-programming/library-function"
HYPERLINK "https://www.programiz.com/c-programming/library-
function" HYPERLINK
"https://www.programiz.com/c-programming/library-function"functions
• User HYPERLINK "https://www.programiz.com/c-programming/c-user-
defined-functions" HYPERLINK "https://www.programiz.com/c-
programming/c-user-defined-functions" HYPERLINK
"https://www.programiz.com/c-programming/c-user-defined-functions"
HYPERLINK "https://www.programiz.com/c-programming/c-user-
defined-functions" HYPERLINK "https://www.programiz.com/c-
programming/c-user-defined-functions" HYPERLINK
"https://www.programiz.com/c-programming/c-user-defined-
functions"defined HYPERLINK "https://www.programiz.com/c-
programming/c-user-defined-functions" HYPERLINK
"https://www.programiz.com/c-programming/c-user-defined-functions"
HYPERLINK "https://www.programiz.com/c-programming/c-user-
defined-functions" functions

• #include<stdio.h> 54

• // function prototype, also called function

declaration 3 void swap(int a, int b);
4
5 int main()
6 {
7 int m = 22, n = 44;
8 // calling swap function by value
9
10
11 }
12
printf(" values before swap m = %d \nand n = %d", m, n);
swap(m, n);

13 void
swap(int a, int
b) 14 {

15
16
17
18
19
20 }

int
tmp;
tmp =
a; a =
b;
b = tmp;
printf(" \nvalues after swap m = %d\n and n = %d", a, b);

values before swap

m = 22 and n = 44
values after swap m
= 44 and n = 22
 Arrays

An array is a collection of a fixed number of values of a single type.

For example: if you want to store 100 integers in sequence, you can
create an array for it.

The size and type of arrays cannot be changed after its

declaration. Arrays are of two types:
• One-dimensional arrays
• Multidimensional HYPERLINK "https://www.programiz.com/c-
programming/c-multi-dimensional-arrays" HYPERLINK
"https://www.programiz.com/c-programming/c-multi-dimensional-
arrays" HYPERLINK "https://www.programiz.com/c-programming/c-
multi-dimensional-arrays" HYPERLINK
"https://www.programiz.com/c-programming/c-multi-dimensional-
arrays" HYPERLINK "https://www.programiz.com/c-programming/c-
multi-dimensional-arrays" HYPERLINK
"https://www.programiz.com/c-programming/c-multi-dimensional-
arrays"arrays HYPERLINK "https://www.programiz.com/c-
programming/c-multi-dimensional-arrays" HYPERLINK
"https://www.programiz.com/c-programming/c-multi-dimensional-
arrays" HYPERLINK "https://www.programiz.com/c-programming/c-
multi-dimensional-arrays" (will be discussed in next chapter)
How to declare arrays?

Program 6: Arrays

Output
 Enter number2: 35
Enter number3: 38
Enter number4: 31
Enter number5: 49
Average = 39

Pointers 57

Pointers are powerful features of C and (C++) programming that

differentiates it from other popular programming languages like Java
and Python. Pointers are used in C program to access the memory and
manipulate the address.
Pointer variables:
In C, you can create a special variable that stores the address (rather
than the value). This variable is called pointer variable or simply a
pointer.

How to create a pointer variable?

data_type* pointer_variable_name;
int* p;
 Program 7: Swap two numbers using call by reference (address)
#include <stdio.h>
void swap(int *a,int *b)
{
int t;
t = *a;
*a = *b;
*b = t;
}
int main()
{
int num1,num2;
printf("Enter value of num1:
"); scanf("%d",&num1);
printf("Enter value of num2:
"); scanf("%d",&num2);

//print values before swapping

printf("Before Swapping: num1=%d, num2=%d\n",num1,num2);
//call function by passing addresses of num1 and num2
swap(&num1,&num2);
//print values after swapping
printf("After Swapping: num1=%d, num2=%d\n",num1,num2);
return 0;
}

Output
Enter value of num1: 10
Enter value of num2: 20
Before Swapping: num1=10, num2=20
After Swapping: num1=20, num2=10
 Student
Project inReport
C++ Card System
Student report card system project in C++ is a simple console
application built without the use of graphics. In this project, users can
perform typical report card related functions like adding a new student
record and displaying, modifying, editing and deleting it. File handling
has been effectively used to perform all these. The key features of
Student Report Card System are:
• Create student report card record
• Read all students report card record
• Read specific student’s report card record
• Display all students’ grade report
• Modify student’s report card record
• Delete student record:

//***************************************************************
IN PRO
*******
// HEADER FILE USED 60 JECT
//****************************

*****************************
#include<conio.h>
#include<stdio.h>
#include<process.h
>
#include<fstream.h
>
#include<iomanip.
h>
//***************************************************************
// CLASS USED IN PROJECT
//
****************************************************************
class student
{
int rollno;
char name[50];
int
p_marks,c_marks,m_marks,e_marks,cs
_marks; float per;
c
h
a
r
g
r
a
d
e
;
i
n
t
s
t
d
;
void calculate()
{
per=(p_marks+c_marks+m_marks+e_marks+cs_m
arks)/5.0; if(per>=60)
grade='A';
else if(per>=50 &&
per<60) grade='B';
else if(per>=33 &&
per<50) grade='C';
else
grade='F';
}
public:
void getdata()
{
cout<<"\nEnter The roll number of
student "; cin>>rollno;
 cout<<"\n\nEnter The Name of
student "; gets(name);
ics out o
mistry ou
cout<<"\nEnter The marks in phys f 100 : ";
cin>>p_marks; 61
cout<<"\nEnter The marks in che t
of 100 : "; cin>>c_marks;
cout<<"\nEnter The marks in maths out of 100 : ";
cin>>m_marks;
cout<<"\nEnter The marks in english out of 100 :
"; cin>>e_marks;
cout<<"\nEnter The marks in computer science out of 100 : ";
cin>>cs_marks;
calculate();
}

void showdata()
{
cout<<"\nRoll number of student :
"<<rollno; cout<<"\nName of
student : "<<name; cout<<"\nMarks
in Physics : "<<p_marks; cout<<"\
nMarks in Chemistry : "<<c_marks;
cout<<"\nMarks in Maths :
"<<m_marks; cout<<"\nMarks in
English : "<<e_marks;
cout<<"\nMarks in Computer
Science :"<<cs_marks; cout<<"\nPercentage of
student is :"<<setprecision(2)<<per; cout<<"\
nGrade of student is :"<<grade;
}

void show_tabular()
{
cout<<rollno<<setw(12)<<name<<setw(10)<<p_marks<<setw(3)<<c_m
arks<<set
w(3)<<m_marks<<setw(3)<<e_marks<<setw(3)<<cs_marks<<setw(6)<
<setprecis ion(3)<<per<<" "<<grade<<endl;
}
int retrollno()
{
return rollno;
}

//class ends here

}; 62
//***************************************************************
// global declaration for stream object, object
//
****************************************************************
f
s
t
r
e
a
m
f
p
;
s
t
u
d
e
n
t
s
t
;
//***************************************************************
// function to write in file
//
****************************************************************
void write_student()
{
fp.open("student.dat",ios::ou
t|ios::app); st.getdata();
fp.write((char*)&st,sizeof(st
udent)); fp.close();
cout<<"\n\nstudent record Has Been Created ";
getch();
}

//***************************************************************
// function to read all records from file
//
****************************************************************

void display_all()
{
 clrscr();
cout<<"\n\n\n\t\tDISPLAY ALL RECORD !!!\n\n";
fp.open("student.dat",ios::in);
while(fp.read((char*)&st,sizeof(student)))
{
st.showdata(); cout<<"\n\
n====================================\n";
getch();
} 63
fp.close();
getch();
}

//***************************************************************
// function to read specific record from file
//
****************************************************************

void display_sp(int n)
{
int flag=0;
fp.open("student.dat",ios::in)
;
while(fp.read((char*)&st,sizeof(student)))
{
if(st.retrollno()==n)
{
clrscr(
);
st.sho
wdata(
);
flag=1;
}
}
fp.close()
;
if(flag==
0)
cout<<"\n\nrecord
not exist"; getch();
}

//***************************************************************
// function to modify record of file
//
****************************************************************
void modify_student()
{
int
no,found=0
; clrscr();
umber o
cout<<"\n\n\tTo Modify "; 64
cout<<"\n\n\tPlease Enter The roll n f student"; cin>>no;
fp.open("student.dat",ios::in|ios::out);
while(fp.read((char*)&st,sizeof(student)) &&
found==0)
{
if(st.retrollno()==no)
{
st.showdata();
cout<<"\nPlease Enter The New Details of student"<<endl;
st.getdata();
int pos=-1*sizeof(st);
fp.seekp(pos,ios::cur);
fp.write((char*)&st,sizeof(stu
dent)); cout<<"\n\n\t Record
Updated"; found=1;
}
}
fp.close();
if(found==
0)
cout<<"\n\n Record Not Found ";
getch();
}

//***************************************************************
// function to delete record of file
//
****************************************************************

void delete_student()
{
i
n
t
n
o
;
c
l
 r
s
c
r
(
)
;
cout<<"\n\n\n\tDelete Record";
cout<<"\n\nPlease Enter The roll number of student You Want To
Delete"; cin>>no;
fp.open("student.dat",ios::in|
ios::out); fstream fp2;
fp2.open("Temp.dat",ios::out
); fp.seekg(0,ios::beg);
nt)))
while(fp.read((char*)&st,sizeof(stude 65
{
if(st.retrollno()!=no)
{
fp2.write((char*)&st,sizeof(student));
}
}
fp2.close();
fp.close();
remove("student
.dat");
rename("Temp.dat","student.
dat"); cout<<"\n\n\tRecord
Deleted .."; getch();
}

//***************************************************************
// function to display all students grade report
//
****************************************************************
void class_result()
{
clrscr();
fp.open("student.dat",io
s::in); if(!fp)
{
cout<<"ERROR!!! FILE COULD NOT BE OPEN\n\n\n Go To
Entry Menu to create File";
cout<<"\n\n\n Program is closing.....";
getch();
exit(0);
}
cout<<"\n\n\t\tALL STUDENTS RESULT \n\n";
 cout<<"==============================================
======\n ";
cout<<"Roll No. Name P C M E CS %age Grade\n";

======
cout<<"====================== ";

66 ========================\n

while(fp.read((char*)&st,sizeof(student)))
{
st.show_tabular();
}
fp.close();
getch();
}

//***************************************************************
// function to display result menu
//
****************************************************************
void result()
{
int ans,rno;
c
h
a
r
c
h
;
c
l
r
s
c
r
(
)
;
cout<<"\n\n\nRESULT MENU";
 cout<<"\n\n\n1. Class Result\n\n2. Student Report Card\n\n3.Back to
Main Menu";
cout<<"\n\n\nEnter Choice
(1/2)? "; cin>>ans;
switch(ans)
{
case 1 :
class_r
esult();
break;
case 2 :
{
do
{
c
l
r
s
c
r
(
)
;
c
h
a
r
a
n
s
;
cout<<"\n\nEnter Roll Number Of Student : ";
cin>>rno; 67
display_sp(rno);
cout<<"\n\nDo you want to See More Result
(y/n)?"; cin>>ans;
}
while(ans=='y'||ans=='Y');

break;
}
case 3:
b
r
e
a
k
;
d
 e
f
a
u
l
t
:
cout<<"\a";
}
}

//***************************************************************
// INTRODUCTION FUNCTION
//
***********************************************************
***** void intro()

{
clrscr();
gotoxy(35,
11);
cout<<"ST
UDENT";
gotoxy(33,14);
cout<<"REPOR
T CARD";
gotoxy(35,17);
cout<<"PROJE
CT";
cout<<"\n\nMADE BY : Code
With C"; cout<<"\n\nCONTACT :
codewithc.com"; getch();

*******
//********************************
// ENTRY / EDIT MENU FUNCTION
68 ************************
//
***********************************************************
***** void entry_menu()
{
c
l
r
s
c
r
(
)
;
c
h
a
r
c
h
2
;
cout<<"\n\n\n\tENTRY MENU"; cout<<"\n\n\
t1.CREATE STUDENT RECORD"; cout<<"\
n\n\t2.DISPLAY ALL STUDENTS
RECORDS"; cout<<"\n\n\t3.SEARCH
STUDENT RECORD "; cout<<"\n\n\
t4.MODIFY STUDENT RECORD"; cout<<"\
n\n\t5.DELETE STUDENT RECORD";
cout<<"\n\n\t6.BACK TO MAIN
MENU"; cout<<"\n\n\tPlease Enter
Your Choice (1-6) "; ch2=getche();
switch(ch2)
{
case '1':
clrscr();
write_stu
dent();
break;
case '2':
display
_all();
break;
case '3':
i
n
t
n
 u
m
;
c
l
r
s
c
r
(
)
;
cout<<"\n\n\tPlease Enter The roll
number "; cin>>num;
display_
sp(num);
break;
case '4':
modify_
student()
; break;
case '5':
delete_st
udent();
break;
case '6':
b
r
e
a
k
;

d
e
f
a
u
l
t
:
cout<<"\a"; 69
entry_menu();
}
}
//***************************************************************
// THE MAIN FUNCTION OF PROGRAM
//
****************************************************************

void main()
{
c
h
a
r
c
h
;
i
n
t
r
o
(
)
;
d
o
{
clrscr();
cout<<"\n\n\n\tMAIN MENU";
cout<<"\n\n\t01. RESULT
MENU"; cout<<"\n\n\t02.
ENTRY/EDIT MENU";
cout<<"\n\n\t03. EXIT";
cout<<"\n\n\tPlease Select Your
Option (1-3) "; ch=getche();
switch(ch)
{
case '1':
clrscr();
r
e
s
u
l
t
(
)
;
b
 r
e
a
k
;
case '2':
entry_
menu(
);
break;
case '3':
e
x
i
t
(
0
)
;
d
e
f
a
u
l
t
:
cout<<"\a";
}
}
while(ch!='3');
} 70

//***************************************************************
// END OF PROJECT
//***************************************************************
CLUSI
CON

71 ON
I can honestly say that my time spent interning with Dreamtech resulted
in one of the best summers of my life. Not only did I gain practical
skills but I also had the opportunity to meet many fantastic people. The
atmosphere at the institution was always welcoming which made me
feel right at home.
This was a great experience to interact with everyone in an informal
setting outside of work.
Overall, my internship at DREAMTECH has been a success. I was able
to gain practical skills, work in a fantastic environment, and make
connections that will last a lifetime. I could not be more thankful.