Annexure-II: Student Declaration

To whom so ever it may concern

I, Nitika Bhatia, 12223386, hereby declare that the work done by me on “C and C++
Programming” from June, 2024 to July, 2024, is a record of original work for the partial
fulfillment of the requirements for the award of the degree, Bachelor of Technology.

Nitika Bhatia (12223386)

Dated: August, 2024

1
 ACKNOWLEDGEMENT

Primarily, I would like to express my special thanks of gratitude to the teacher and
instructor of the course C & CPP from Board Infinity who provided me the golden
opportunity to learn a new technology from home.

I would like to also thank my own college Lovely Professional University for offering
such a course which not only improve my programming skill but also taught me other
new technology.

Then I would like to thank my parents and friends who have helped me with their
valuable suggestions and guidance for choosing this course.

Last but not least I would like to thank my all classmates who have helped me a lot.

2
SUMMER TRAINING CERTIFICATE

3
 TABLE OF CONTENTS

S. No. Title Page

1 Cover Page 1
2 Declaration of the student 2
3 Acknowledgement 3
4 Training Certification from organization 4
5 Table of Contents 5
6 Introduction 6

7 Technology Learnt 7

8 Core Concepts 8

9 OOP in C++ 18

10 Reason for choosing 19

11 Learning Outcomes 22

4
 1. INTRODUCTION

C and C++ are foundational programming languages with a significant impact on software
development, widely used for their efficiency and control over system resources.

C: Developed by Dennis Ritchie in the early 1970s at Bell Labs, C is a procedural programming
language known for its simplicity and speed. It provides low-level access to memory and system
operations, making it ideal for system programming, operating systems, and embedded systems.
C’s straightforward syntax and powerful features, such as pointers and manual memory
management, offer precise control over hardware and resource allocation.

C++: Created by Bjarne Stroustrup in the early 1980s as an extension of C, C++ introduces object-
oriented programming (OOP) concepts, adding support for classes, inheritance, and
polymorphism. This allows for more modular, reusable, and maintainable code. C++ builds on C’s
strengths and adds features like function overloading, templates, and the Standard Template
Library (STL), making it suitable for a wide range of applications, from game development to
large-scale systems.

Both languages share a common syntax and many fundamental concepts, but C++ expands on C
with additional programming paradigms, making it a versatile choice for modern software
development. Understanding both C and C++ provides a strong foundation in programming,
offering skills applicable to a wide array of technical and computational challenges.

5
 2. TECHNOLOGY LEARNT

C is a general-purpose, procedural programming language that is fundamental to the development of

many modern software systems. It is particularly important for developers working with system
software, embedded systems, and performance-critical applications.

2.1 Key Features of C:

Low-level access to memory

Simple and efficient syntax
Rich set of operators
Structured programming paradigm
Wide range of applications

2.2 C++ Programming Language

Transition from C to C++:

C++ extends C by introducing object-oriented programming (OOP), making it a powerful language

for developing large-scale software systems where code reuse, modularity, and scalability are
important.

2.3 Key Features of C++:

Object-Oriented Programming (OOP)

Extensive standard library
Support for both procedural and OOP paradigms
Templates for generic programming
Exception handling for robust code

2.4 Tools and Environment Used

IDEs and Compilers:

Code::Blocks, Dev-C++, Visual Studio: Integrated Development Environments (IDEs) used during
the training.

GCC (GNU Compiler Collection): Compiler used for C/C++ programs.

Debugging Tools:

GDB (GNU Debugger): Tool for debugging and troubleshooting C/C++ code.

6
Valgrind: Tool for memory debugging, leak detection, and profiling.

7
 3. CORE CONCEPTS IN C/C++

3.1 Data Types and Variables

Basic Data Types in C/C++:

int, char, float, double: These are the fundamental data types used for representing integers,
characters, floating-point numbers, and double-precision floating-point numbers, respectively.
Derived Data Types: Arrays, pointers, structures, and unions are built from the basic data types
and are used to store collections of values, manage memory, and group related data.

Variables and Storage Classes:

Automatic, External, Static, and Register Variables: These storage classes define the scope,
lifetime, and visibility of variables. Understanding these is crucial for managing memory and data
efficiently within a program.

3.2 Control Structures

Decision Making:
if, else-if, switch-case statements: These constructs allow the program to make decisions based on
conditions, guiding the flow of execution. The if statement checks a condition and executes code
accordingly, while else-if and else provide alternative paths. The switch-case statement is used for
selecting one of many code blocks to execute.

Looping Constructs:
for, while, do-while loops: These loops are used to repeat a block of code as long as a condition is
true. The for loop is ideal for situations where the number of iterations is known. The while loop
repeats as long as a condition remains true, and the do-while loop ensures that the code runs at
least once before the condition is checked.

Break and Continue Statements:

Usage and examples of breaking and continuing loops: The break statement is used to exit a loop
prematurely, while continue skips the current iteration and proceeds with the next one. These
statements provide fine-grained control over loop execution.

3.3 Functions and Scope

Function Definition and Declaration:

Creating modular code with functions: Functions are essential for breaking down complex tasks
into manageable pieces. They can be defined with specific input parameters and return types,
promoting code reuse and organization.
Recursion:
Understanding and implementing recursive functions: Recursion involves a function calling itself
to solve smaller instances of a problem. It is a powerful tool for tasks like tree traversal and
mathematical computations, though it requires careful management to avoid infinite loops.

Scope and Lifetime of Variables:

8
Global vs Local Scope: Understanding where and how long variables exist in memory is key to
avoiding bugs and managing resources. Global variables are accessible throughout the program,
while local variables are limited to the function or block in which they are defined.

3.4 Pointers and Memory Management

Understanding Pointers:
Pointer variables, dereferencing, and pointer arithmetic: Pointers are variables that store memory
addresses, enabling direct access and manipulation of memory. Dereferencing pointers accesses
the value at the pointed-to location, while pointer arithmetic allows traversal of arrays and
complex data structures.

Dynamic Memory Allocation:

malloc, calloc, realloc, free: These functions provide control over memory allocation and
deallocation at runtime, allowing efficient use of memory. Understanding how to manage
dynamically allocated memory is essential for preventing memory leaks and ensuring program
stability.
Memory Leaks: Causes, detection, and prevention: Memory leaks occur when allocated memory is
not freed after use. Tools like Valgrind can help detect leaks, and best practices in memory
management can prevent them.

3.5 Arrays and Strings

Arrays:
One-dimensional and multi-dimensional arrays: Arrays are collections of data items of the same
type. One-dimensional arrays represent a simple list, while multi-dimensional arrays, like matrices,
allow more complex data representation.

Strings:
Handling strings with arrays of characters: In C/C++, strings are typically arrays of characters
terminated by a null character (\0). Understanding string manipulation is fundamental for text
processing and communication between different parts of a program.

Pointer and Array Relationship:

Using pointers to manipulate arrays and strings: Pointers and arrays are closely related, as the
name of an array acts as a pointer to its first element. Pointers provide a flexible way to navigate
and manipulate arrays and strings.

3.6 Structures and Unions

Structures:
Defining and using structures to group related data: Structures allow the grouping of different data
types into a single unit. This is useful for representing complex data entities, like records in a
database.

9
Unions:
Memory-efficient data structures for storing different types of data in the same memory
location: Unions share memory among their members, allowing different data types to be stored in
the same memory space. This is useful for applications like data transmission protocols, where
saving memory is critical.

3.7 File Handling

File Operations:
Opening, reading, writing, and closing files in C/C++: File handling functions enable programs to
read from and write to files, allowing persistent data storage. Understanding how to manage files is
essential for developing applications that need to save or process large amounts of data.

Binary vs Text Files:

Understanding the difference and usage: Text files store data as human-readable characters, while
binary files store data in a format that is directly understood by the machine. Each has its use cases
depending on the requirements for efficiency and human readability.

File Pointers and Error Handling:

Using file pointers to navigate and manage files: File pointers are used to keep track of the current
position in a file, allowing for flexible reading and writing operations. Proper error handling
ensures that file operations are successful and resources are properly managed.

3.8 Preprocessor Directives

Macros and Constants:

Using define for constants and macros: Preprocessor directives like define are used to define
constants and macros, allowing for more readable and maintainable code. Macros can also provide
inline functionality, replacing repetitive code snippets.
Conditional Compilation:
Using ifdef, ifndef for platform-specific code: Conditional compilation directives
like ifdef and ifndef enable code to be compiled conditionally based on whether certain conditions
are met. This is particularly useful for writing platform-independent code or for enabling and
disabling features during development.

10
 4. OBJECT-ORIENTED PROGRAMMING IN C++

4.1 Classes and Objects

Defining Classes:
Syntax and Usage of Classes in C++: A class is a blueprint for creating objects. It encapsulates
data and functions that operate on that data. The syntax for defining a class involves specifying the
class name and the members (variables and functions) within curly braces.

class MyClass {
public:
int myVariable;
void myFunction() { // Function implementation
}
};

Creating Objects:
Instantiating Objects from Classes: Objects are instances of classes. Once a class is defined, you
can create objects of that class type to utilize the encapsulated data and functions.

MyClass obj1; // Creating an object of MyClass

obj1.myVariable = 10;
obj1.myFunction();

Access Specifiers:
Public, Private, and Protected Members: Access specifiers control the visibility of class members.
Public: Members are accessible from outside the class.
Private: Members are accessible only within the class.
Protected: Members are accessible within the class and by derived classes.

class MyClass {
private:
int myPrivateVar;
public:
int myPublicVar;
protected:
int myProtectedVar;
};

11
4.2 Constructors and Destructors

Constructors:
Initialization of Objects: A constructor is a special member function that initializes objects of a
class. It is called automatically when an object is created.

class MyClass {
public:
MyClass() {
// Constructor code
}
};

Destructors:
Clean-Up Code and Resource Deallocation: A destructor is a special member function that cleans
up when an object is destroyed. It is called automatically when an object goes out of scope or is
explicitly deleted.

class MyClass {
public:
~MyClass() {
// Destructor code
}
};

4.3 Inheritance

Types of Inheritance:
Single, Multiple, Multilevel, Hierarchical, and Hybrid Inheritance:
Multiple Inheritance: A derived class inherits from more than one base class.
Multilevel Inheritance: A class is derived from a class that is also a derived class.
Hierarchical Inheritance: Multiple classes are derived from a single base class.
Hybrid Inheritance: A combination of two or more types of inheritance.

Base and Derived Classes:

Reusing Code through Inheritance: Inheritance allows the creation of new classes based on
existing ones, promoting code reuse and extending functionality.

class BaseClass {
public:
int baseVar;

12
 };

class DerivedClass : public BaseClass {

public:
int derivedVar;
};

4.4 Polymorphism

Function Overloading:
Same Function Name with Different Parameters: Function overloading allows multiple functions
with the same name but different parameters to coexist, providing different implementations based
on the arguments passed.

class MyClass {
public:
void func(int x) {
// Function with int parameter
}
void func(double x) {
// Function with double parameter
}
};

Operator Overloading:
Custom Behavior for Operators: Operator overloading allows defining custom behavior for
operators when applied to objects of a class.

class MyClass {
public:
int value;
MyClass operator+(constMyClass&obj) {
MyClass res;
res.value = this->value + obj.value;
return res;
}
};
13
Virtual Functions and Abstract Classes:
Achieving Polymorphism in C++:
Virtual Functions: Allow derived classes to override base class functions, enabling polymorphic
behavior.
Abstract Classes: Classes that cannot be instantiated and are designed to be inherited, often
containing pure virtual functions.

class BaseClass {
public:
virtual void display() {
// Base implementation
}
};

class DerivedClass : public BaseClass {

public:
void display() override {
// Derived implementation
}
};

4.5 Templates
Function Templates:
Generic Functions for Multiple Data Types: Function templates allow writing generic functions
that work with any data type.

template <typename T>

T add(T a, T b) {
return a + b;
}

Class Templates:
Generic Classes for Multiple Data Types: Class templates allow defining classes that can operate
with generic data types.

4.6 Exception Handling

Try, Catch, Throw:
Handling Runtime Errors: Exception handling provides a way to manage runtime errors
using try, catch, and throw blocks.

14
Custom Exception Classes:
Creating User-Defined Exceptions: Custom exception classes can be defined to handle specific
error conditions in a more controlled manner.

15
 5. REASON FOR CHOOSING C/C++

Choosing C or C++ for a project or as a programming language to learn comes with several
compelling reasons:

1. Performance and Efficiency

- Low-Level Access: Both C and C++ offer low-level access to memory and hardware, allowing
for highly optimized and efficient code. This makes them ideal for performance-critical
applications where resource management and execution speed are paramount.
- Minimal Overhead: C and C++ programs often have less runtime overhead compared to
languages with more abstraction, leading to faster execution and reduced memory usage.

2. Control Over System Resources

- Manual Memory Management: C and C++ provide explicit control over memory allocation and
deallocation. This is crucial for system programming, embedded systems, and applications where
precise resource management is necessary.
- Pointer Arithmetic: The ability to perform pointer arithmetic in C and C++ allows for direct
manipulation of memory and hardware, which is beneficial for optimizing performance and
interfacing with low-level system components.

3. Foundation for Learning Other Languages

- Influence on Other Languages: Many modern programming languages, such as C, Java, and
even newer languages like Rust, are influenced by C and C++. Learning these languages provides
a solid foundation for understanding programming concepts and syntax used in other languages.
- Common Syntax: The syntax and concepts learned in C/C++ are applicable to many other
programming languages, making it easier to transition to different languages and paradigms.

4. Wide Range of Applications

- System Programming: C is extensively used in developing operating systems, device drivers,

and other system-level software due to its efficiency and control over hardware.
16
 - Application Development: C++ is widely used in developing applications with complex user
interfaces, games, and performance-intensive software, thanks to its support for object-oriented
programming and extensive libraries.

5. Strong Community and Legacy

- Mature Ecosystem: C and C++ have been around for decades, resulting in a mature ecosystem
with a wealth of libraries, tools, and frameworks available for developers.
- Legacy Code: Many existing systems and legacy codebases are written in C/C++, so
proficiency in these languages is essential for maintaining and upgrading such systems.

6. Educational Value

- Fundamental Concepts: Learning C and C++ provides a deep understanding of fundamental

programming concepts, including data structures, algorithms, and system-level operations. This
knowledge is valuable for both academic purposes and practical applications.
- Problem-Solving Skills: The languages’ emphasis on manual memory management, pointers,
and low-level programming helps develop strong problem-solving skills and a detailed
understanding of how software interacts with hardware.

In summary, choosing C or C++ is often driven by the need for performance, control, and a deep
understanding of programming fundamentals. Their efficiency, extensive application range, and
educational value make them excellent choices for both new and experienced developers.

17
 6. LEARNING OUTCOMES

Learning C and C++ yields several important outcomes that enhance programming skills and open
opportunities in various domains of software development:

1. Enhanced Programming Skills

- Foundational Knowledge: Mastery of C and C++ provides a solid understanding of core

programming concepts such as variables, data types, control structures, functions, and operators.
This foundational knowledge is applicable across many programming languages and paradigms.
- Algorithm and Data Structure Expertise: Proficiency in C/C++ enhances your ability to
implement and optimize algorithms and data structures, including arrays, linked lists, stacks,
queues, trees, and graphs. This is crucial for solving complex computational problems efficiently.

2. In-Depth Understanding of System-Level Programming

- Memory Management: Learning manual memory management techniques in C/C++ (e.g.,

using `malloc`, `free`, `new`, `delete`) provides insights into how memory is allocated and
deallocated, which is essential for writing efficient and error-free code.

- Pointer Manipulation: Mastery of pointers, pointer arithmetic, and dynamic memory allocation
offers a deeper understanding of how data is stored and accessed in memory, allowing for more
optimized and controlled program execution.

3. Advanced Programming Concepts

- Object-Oriented Programming (OOP): In C++, you learn OOP principles such as classes,
inheritance, polymorphism, and encapsulation, which enable you to design modular, reusable, and
maintainable software.
- Generic Programming: C++’s template features allow for generic programming, enabling you
to write functions and classes that work with any data type while maintaining type safety and
efficiency.

4. Performance Optimization Skills

- Code Optimization: Skills in optimizing code for performance and memory usage are
developed, including techniques like loop unrolling, inlining functions, and minimizing memory
access. This is crucial for applications requiring high performance and efficiency.
- Profiling and Debugging: Experience with profiling tools and debugging techniques helps
identify bottlenecks and optimize code, leading to more robust and efficient applications.

5. Practical Application Experience

- Project Development: Hands-on projects and case studies enable you to apply theoretical
knowledge to real-world problems, reinforcing learning and enhancing practical skills. Projects
may include developing system software, games, or complex applications.
- Understanding Legacy Code: Proficiency in C/C++ equips you to work with and maintain
18
existing codebases, which are often written in these languages, especially in older or performance-
critical systems.

6. Career and Industry Opportunities

- Job Readiness: Mastery of C/C++ opens up career opportunities in various fields, including
system programming, embedded systems, game development, and high-performance computing.
These skills are highly sought after in the tech industry.
- Industry Demand: Many industries, including finance, telecommunications, and aerospace,
require expertise in C/C++ due to their performance characteristics and widespread use in critical
systems.

7. Foundation for Further Learning

- Transition to Other Languages: Understanding C/C++ provides a strong foundation for learning
other programming languages and paradigms, including newer languages that build upon similar
concepts.
- Advanced Topics: Mastery of C/C++ prepares you for exploring advanced topics in computer
science, such as compiler design, operating systems, and network programming.

In summary, learning C and C++ equips you with essential programming skills, a deep
understanding of system-level operations, and advanced programming concepts. These outcomes
enhance your ability to develop efficient software, tackle complex problems, and open up diverse
career opportunities in technology.

19
 BIBLIOGRAPHY

 Stroustrup, Bjarne. The C++ Programming Language. Addison-Wesley, 2013.\

 Kernighan, Brian W., and Dennis M. Ritchie. The C Programming Language. Prentice Hall, 1988.

 Google

 Board Infinity Website

 Course of Board Infinity on C/C++

20