COURSE FILE

COURSE CODE: C202

OBJECT ORIENTED PROGRAMMING
THROUGH C++
(R2021051)
Academic Year: 2023-2024

By
Mr G. Manidheer Babu
Asst.Professor
Department of CSE
PROGRAM OUTCOMES (POs):

1. Engineering knowledge: Apply the knowledge of mathematics, science, engineering fun

damentals, and an engineering specialization to the solution of complex engineering probl
ems.
2. Problem analysis: Identify, formulate, review research literature, and analyze complex e
ngineering problems reaching substantiated conclusions using first principles of
mathematics, natural sciences, and engineering sciences.
3. Design/development of solutions: Design solutions for complex engineering problems
and design system components or processes that meet the specified needs with appropriat
e consideration for the public health and safety, and the cultural, societal, and
environmental considerations.
4. Conduct investigations of complex problems: Use research-based knowledge and
research methods including design of experiments, analysis and interpretation of data, and
synthesis of the information to provide valid conclusions.
5. Modern tool usage: Create, select, and apply appropriate techniques, resources, and
modern engineering and IT tools including prediction and modeling to complex
engineering activities with an understanding of the limitations.
6. The engineer and society: Apply reasoning informed by the contextual knowledge to
assess societal, health, safety, legal and cultural issues and the consequent responsibilities
relevant to the professional engineering practice.
7. Environment and sustainability: Understand the impact of the professional
engineering solutions in societal and environmental contexts, and demonstrate the knowle
dge of, and need for sustainable development.
8. Ethics: Apply ethical principles and commit to professional ethics and responsibilities
and norms of the engineering practice.
9. Individual and team work: Function effectively as an individual, and as a member or
leader in diverse teams, and in multidisciplinary settings.
10. Communication: Communicate effectively on complex engineering activities with the en
gineering community and with society at large, such as, being able to comprehend and
write effective reports and design documentation, make effective presentations, and give
and receive clear instructions.
11. Project management and finance: Demonstrate knowledge and understanding of the en
gineering and management principles and apply these to one’s own work, as a member
and leader in a team, to manage projects and in multidisciplinary environments.
12. Life-long learning: Recognize the need for, and have the preparation and ability to
engage in independent and life-long learning in the broadest context of technological
change.

HOD
COURSE CONTENTS
 COURSE OBJECTIVES & COURSE OUTCOMES
Course Name: Object Oriented Programming through C++
Course Code:R2021051
Year - Sem:II B. Tech – I Sem Regulation: R20

Course Objectives:
 Describe the procedural and object-oriented paradigm with concepts of streams,
classes, functions, data and objects
 Understand dynamic memory management techniques using pointers, constructors,
destructors Describe the concept of function overloading, operator overloading,
virtual functions and polymorphism
 Classify inheritance with the understanding of early and late binding, usage of
exception handling, generic programming
 Demonstrate the use of various OOPs concepts with the help of programs

Course Outcomes:
 Classify object-oriented programming and conventional programming
 Apply C++ features such as composition of classes and objects and constructors and
destructors
 Build C++ classes using operator overloading and inheritance
 Build C++ classes using pointers, binding polymorphism and virtual functions
 Apply object-oriented techniques using Generic Programming with templates and
exception handling to solve bigger computing problems
 Solve real-world problems using object-oriented techniques

Course Coordinator DAC Chief Coordinator

Course Instructors: DAC Members:
1. 1.
2. 2.
3.
 MAPPING CO WITH PO/PSO AND JUSTIFICATION

CO/PO MAPPING:
Mappin P0 P01
P01 P02 P03 P04 P05 P06 P07 P08 P010 P011 PS01 PSO2
g 9 2
C202.1 3 2 2 2 - - - - - - - 2 2 2
C202.2 3 2 3 2 - - - - - - - 3 2 3
C202.3 3 2 3 2 - - - - - - - 2 3 2
C202.4 3 2 3 3 - - - - - - - 2 2 2
C202.5 3 2 3 2 - - - - - - - 3 3 3
C202.6 3 2 3 3 - - - - -- - - 3 3 2
AVG 3 2 2.8 2.3 - - - - - - - 2.5 2.5 2.3

C1 Classify object-oriented programming and conventional programming(K4)

Apply C++ features such as composition of classes and objects and constructors and
C2
destructors (K3)
C3 Build C++ classes using operator overloading and inheritance (K3)
C4 Build C++ classes using pointers, binding polymorphism and virtual functions(K3)
Apply object-orientedtechniques using Generic Programming with templates and
C5
exception handling to solve bigger computing problems (K3)

C6 Solve real-world problems using object-oriented techniques(K3)

 JUSTIFICATION:
CO Mapping
PO Statement Justification
Level
Understanding and applying OOP concepts
requires a fundamental knowledge of
PO1 3
programming principles, which falls under
engineering knowledge.
Analysing problems to apply the correct OOP
PO2 2
principles
Designing programs using OOP concepts to
PO3 2
create robust and efficient solutions.
Using research-based knowledge in
PO4 2 conventional programming
Classify object-
oriented
programming and Lifelong learning applies to the adaptability
conventional required when transitioning between
programming(L4) programming paradigms, such as from
PO12 2
conventional programming to object-oriented
programming, ensuring engineers can keep up
with evolving software practices.
TO demonstrate the ability to design,
implement, and analyse object-oriented
PSO1 2 systems, utilizing key OOP principles such as
encapsulation, inheritance, and polymorphism
to create reusable and maintainable code.
Applying design patterns and principles of
software engineering to solve complex
PSO2 2
problems, ensuring optimal performance and
scalability in object-oriented applications.
C202.2 PO1 Apply C++ features 3 Demonstrating the concepts of OOP requires a
such as composition fundamental understanding of programming
of classes and objects principles, which falls under engineering
and constructors knowledge.
 PO2 2
Analysing how to effectively use objects,
classes, methods, and constructors in problem-
solving.
Designing robust and efficient object-oriented
PO3 3
programs
Using research-based knowledge in
PO4 2
constructors and destructors
To recognize the importance of continuously
and destructors (L3) learning new and more efficient ways to
PO12 2 structure and manage code, thus adapting to
technological advancements in software
engineering
To design and implement classes in C++ using
composition to create modular and
PSO1 2
maintainable code, effectively managing
relationships between different objects.
To exhibit proficiency in utilizing constructors
and destructors in C++ to ensure proper
PSO2 3 initialization and resource management of class
objects, thereby enhancing program reliability
and performance.
C202.3 Build C++ classes Applying operator overloading operations,
PO1 using operator 3 inheritance, requires a solid foundation in
overloading and programming and engineering principles.
inheritance (K3)
Analysing real-world problems to determine
PO2 3
how to best utilize inheritance.
Designing and implementing solutions that use
PO3 2 these concepts to solve real-world problems
effectively.
Using research-based knowledge to explore
PO4 3 and evaluate different methods of overloading
functions
PO12 2 These techniques foster an adaptable mindset,
essential for engaging in life-long learning as
new programming languages and paradigms
 emerge

PSO1 3 To design and implement classes in C++ that

utilize operator overloading to enhance the
functionality and readability of their code,
enabling intuitive manipulation of objects.
To exhibit proficiency in applying inheritance
in C++ to create robust and reusable class
PSO2 3 hierarchies, ensuring proper use of
polymorphism and encapsulation to build
scalable software solutions.
C202.4 Understanding pointers and binding
PO1 3 Polymorphisms requires fundamental
knowledge of programming concepts
Analysing and handling potential runtime
PO2 2 errors using virtual functions and organizing
code effectively
Designing Java applications that are well-
PO3 3 structured using packages and robust using
exception handling.
Build C++ classes Using research-based knowledge in pointers,
PO4 using pointers, 3
polymorphism and virtual functions
binding
polymorphism and This prepares graduates for engaging in life-
long learningas they advance their careers and
PO12 virtual functions(K3) 2
face new challenges in modern programming
paradigms
To design and implement classes in C++ that
utilize pointers effectively for dynamic
PSO1 2
memory management, enabling the creation
and manipulation of complex data structures.
To exhibit proficiency in implementing binding
polymorphism through virtual functions,
PSO2 2 allowing for flexible and extensible code
architectures that leverage runtime behaviour
for improved software design.
C202.5

PO1 3
Understanding and applying generic
programming concepts requires foundational
engineering knowledge.

PO2 2
Analysing exceptional handling techniques and
Applyobject- templates such as synchronization and
orientedtechniques deadlocks
using Generic
Designing Java applications that are well-
PO3 3 structured using packages and robust using
exception handling
Using research-based knowledge using
PO4 Programming with 3
generic programming in exception handling
templates and
exception handling Adopting these modern programming practices
to solve bigger prepares students for the evolving field of
computing problems software engineering and ensures they remain
PO12 (K3) 2
capable of continuous self-improvement and
life-long learning as new techniques and
technologies emerge.
To design and implement generic classes and
functions in C++ using templates, enhancing
PSO1 3
code reusability and type independence to
address complex computational problems.
To exhibit proficiency in implementing robust
exception handling mechanisms in C++,
PSO2 2 ensuring graceful error management and
stability in software applications under varying
runtime conditions.
C202.6 Understanding and applying generic
PO1 3 programming concepts requires foundational
Solve real-world
engineering knowledge
problems using
object-oriented This leads to better data integrity and security,
PO2 2
techniques(K3) minimizing the risk of unintended interactions
PO3 3
 Designing Java applications that are well-
structured using packages and robust using
exception handling.

Using research-based knowledge in real world

PO4 3
problems using object-oriented techniques

By solving real-world problems throughobject-

oriented techniques, students gain the
PO12 3
ability to model complex systems efficiently
and build scalable solutions.
To analyse and model real-world problems
using object-oriented techniques, effectively
PSO1 3 applying concepts such as encapsulation,
inheritance, and polymorphism to design
robust and scalable software solutions.
To exhibit proficiency in implementing object-
oriented designs in C++ to solve complex real-
PSO2 2 world challenges, ensuring code
maintainability, reusability, and clarity through
proper object-oriented principles.

Course Coordinator Course Instructors:

CLASS TIME TABLE
 LESSON PLAN

Lecture No Topics Covered Teaching Aid Text Book

Unit I: Introduction
Introduction: Types of T1
L1 languages GB&PC
T1
L2 Procedure oriented programming, Features of POP GB&PC
L3 Procedure oriented programming, Features of POP GB&PC T1
T1
L4 Object oriented programming, characteristics of GB&PC
OOP
Object oriented programming, characteristics of T1
L5* FM
OOP
L6 Structure of C and C++ program GB&PC T1
T1
L7-L10 GB&PC
Structure of C and C++ program
Differences between C and C++, T1
L11-L12 GB&PC
Evolution of C++
Object Oriented Technology, disadvantages of OO T1
L13-L14 TPS
Technology
L15* Key concepts of OOP, Advantages of OOP. FM T1
Unit-II Problem Solving
L16-L18 Overview of structures in C and C++ GB&PC T1
Objects, declaring objects T1
GB&PC
L19-L20
Access specifiers and their scope T1
L21 GB&PC

Defining member functions, invoking of member T1

L22-L23 GB&PC
functions inside the class
Defining member functions, invoking of member T1
L24* FM
functions outside the class
Invoking of member functions from out side class T1
L25 GB&PC
 Over loading member function, Nested classes T1
L26-L31 BL
T1
L32 CL
Introduction to constructor and characteristics of
constructor of constructor, default constructor
Application T1
L33 GB
Parameterized constructor T1
L34 PC
Introduction to destructor and characteristics of T1
L35* FM
destructor
Anonymous objects T1
L36 TPS

UNIT-III
T1
L34 The Keyword Operator, Operator Return Type CL

Overloading Binary Operator Overloading with T1

L35-L39 GB&PC
member function Operator
Overloading Binary Operator Overloading with T1
L40* FM
friend function Operator
T1
L41 Overloading Assignment (=) GB&PC

T1
L42 Rules for Overloading Operators TPS

T1
L43 Inheritance, Reusability TPS

T1
L44* Types of Inheritance FM

UNIT IV
T1
L46 Virtual Base Classes GB&PC

L47 Object as a Class Member GB&PC T1

L48* Abstract Classes in C++ FM T1
Advantages of Inheritance, Disadvantages of T1
L49 GB&PC
Inheritance
Pointer, Features of Pointers, Pointer Declaration, T1
L50-L52 TPS
Pointer to Class- Pointer Object
L53 Pointer to Derived Classes and Base Class CL T1

L54 Introduction- polymorphism GB&PC T1

L55* Binding in C++ FM T1
Virtual Functions, Rules for virtual function, T1
GB&PC
L56 Virtual Destructor
UNIT V
Generic Programming with Templates, Need for T2
L57-L64 FM
Templates
T2
L65 Definition of class Templates FM

T2
L66* Normal Function Templates FM
T2
L67 Over Loading of Template Function GB&PC

L68 Bubble Sort Using Function Templates GB&PC T2

L69 Difference Between Templates and Macros GB&PC T2

L70 Linked Lists with Templates FM T2

L71-73 Exception Handling- Principles of Exception FM T2

Handling
L74* STL Programming Model, Containers, Sequence FM T2
Containers,
L75 Associative Containers, Algorithms, Iterators GB&PC T2

Teaching-Learning Methods

GB & PC: Green Board

PPT: Power Point Presentation

CL: Collaborative Learning

TPS: Think-Pair-Share

FM: Flipped Method

PBL: Project Based Learning

Text Books:
1) A First Book of C++Gary Bronson, Cengage Learning.
2) The Complete Reference C++, Herbert Schildt,TMH.
Signature of the Faculty HOD

GAPS WITH IN THE SYLLABUS- Mapping to CO, Po/PSO

SL.N GAP IDENTIFICATION POs

O
1 Lack of practical assignments on real-world PO1, PSO1
applications

2 Insufficient coverage of encapsulation and data PO2, PSO2

hiding.
3 Need for more complex inheritance examples and PO3, PSO3
multiple inheritance

4 Limited exposure to STL and its applications PO4, PSO4

 GAPS BEYOUND THE SYLLABUS -Mapping to PO/PSO

SL.N GAPS BEYOUND THE SYLLABUS PO/PSO

O

1 Limited exposure to current industry tools and PO1, PO2, PO3, PO4, PO5
frameworks (e.g., Qt, Boost)

2 Lack of experience with agile methodologies and PO1, PO2, PO3, PO4, PSO1
collaborative tools (e.g., Jira, Trello).
PSO2, PO3

3 Insufficient focus on cross-platform C++ PO1, PO2, PO3, PO4,

development practices PSO1, PSO2, PSO3

4 Minimal emphasis on soft skills like PO1, PO2, PO3, PO4,

communication, teamwork, and problem-solving. PSO1, PSO2, POS3

5 Limited opportunities for students to engage in real- PO1, PO2, PO3, PO4,
world problem-solving or industry projects.
PSO1, PSO2PSO3, PSO4
 GAPS ADDRESSED BY ANY OTHER TEACHING
AID/METHODOLOGY

1. Visual Aids and Simulations

Gaps Addressed: Difficulty in understanding abstract concepts like inheritance,

polymorphism, and encapsulation.

Methodology: Use visual diagrams and tools (like UML diagrams) to illustrate class
relationships and object interactions. Simulations can help visualize memory allocation and
object lifecycles.

2. Interactive Coding Platforms

Gaps Addressed: Limited hands-on experience and immediate feedback.

Methodology: Utilize interactive coding environments (such as Codecademy, LeetCode, or

Hacker Rank) that allow students to practice coding in C++ and receive instant feedback on
their solutions.

3. Collaborative Learning

Gaps Addressed: Isolation in learning and lack of peer feedback.

Methodology: Implement pair programming or group projects where students collaboratively

develop OOP-based applications. This encourages discussion, problem-solving, and sharing
of ideas.

4. Flipped Classroom Approach

Gaps Addressed: Passive learning and retention issues.

Methodology: Assign video lectures or reading materials on OOP concepts for homework,
then use class time for hands-on coding exercises, discussions, and troubleshooting real-
world problems.
5. Project-Based Learning

Gaps Addressed: Lack of application of theoretical knowledge.

Methodology: Design projects that require students to build applications using OOP
principles. Real-world projects, like a simple game or a library management system, can
motivate students and enhance learning.
LECTURE NOTES
 LIST OF POWER POINT
PRESENTATION/VIDEOS INCLUDING CD
UNIVERSITY QUESTION PAPERS
 INTERNAL QUESTION PAPERS, KEY WITH CO AND BT
Course Name: Object Oriented Programming Course Code: C202
through C++(R2021051)
Year/ Sem:II B. Tech – I Sem Regulation: R20
Admitted Batch: 2022-2026 Academic Year:2023-24
Course Coordinator:

CO DESCRIPTION
CO1 Classify object-oriented programming and conventional programming
CO2 Apply C++ features such as composition of classes and objects and constructors
and destructors
CO3 Build C++ classes using operator overloading and inheritance
CO4 Build C++ classes using pointers, binding polymorphism and virtual functions
CO5 Apply object-orientedtechniques using Generic Programming with templates and
exception handling to solve bigger computing problems
CO6 Solve real-world problems using object-oriented techniques

CO Action Verb Revised Blooms Taxonomy Level

1 Classify Demonstrate (K2)
2 Apply Apply(K3)
3 Build Apply(K3)
4 Build Apply (K3)
5 Apply Apply(K3)
6 Solve Apply(K3)

Table: Questions with their levels along with the COs for the Web technologies
Vignan’s Nirula Institute of Technology and Science for Women
Pedapalakaluru: Guntur
Branch:CSE Time: 1:30 Hrs
II B. Tech I Semester – I MID
Course Name: OOPS C++ Regulation: R20 Course Code: (R2021051)
Date: 05-10-2023 Academic Year:2023-24 Max Marks: 30

Answer All Questions 3X10=30 M

CO Level Q.No. Question Marks

CO1(K2) 1a: K2 a. Briefly write about History and Evaluation (5 M)

1b: K2 1 of C++

b. Explain the characteristics of OOP (5 M)

CO2(K3) 2a: K3 a) Define Constructor, Identify various (5 M)

Constructors in C++ with an example.
2b: K2 2
b) Explain static keyword in C++. (5 M)
CO3(K3) 3a: K3 Explain Binary Operator Overloading in C++ (5 M)
and construct an example of
3b: K2
a) member function
3

b) friend function (5 M)
Justification of Bloom’s taxonomy action verbs in question paper:

Action Revised Blooms

CO Question Question Revised Blooms
Verbs Taxonomy
No. No. Verbs Taxonomy Level
Used Level
1a Explain Demonstrate (K2)
1 Classify
Demonstrate (K2) 1b Explain Demonstrate (K2)
Apply Apply (K3) 2a Identify Apply(K3)
2
2b Explain Demonstrate (K2)
Apply(K3) 3a Construct Apply(K3)
3 Build
3b Explain Demonstrate (K2)

Vignan’s Nirula Institute of Technology and Science for Women

Pedapalakaluru: Guntur
Branch: CSE Time: 1:30 Hrs
II B. Tech I Semester - II MID
Course Name: OOPS C++ Regulation: R20 Course Code: (R2021051)
Date: 29-11-2023 Academic Year:2023-24 Max Marks: 30

Answer All Questions 3X10=30 M

CO Level Q.No. Question Marks

CO4(K3) 4a: K2 4 a) Explain about Abstract classes and virtual (5 M)

4b: K3 base class in C++ programming.

b) Identify the advantages and (5 M)

Dis Advantages of Inheritance in C++.
 CO5(K3) 5a: K2 5 a) Explain in detail how the members of a (5 M)
class can be accessed using pointer to base
5b: K3
class and derived class with example program.

b). Explain the purpose of Virtual Destructors (5 M)

in C++ and Develop a Sample program.

CO6(K3) 6: K3 6 Identify and write short notes on the following (10 M)

features of C++ programming components.
[10]
(i) Algorithm (ii) Iterators
(iii) Maps, multimaps

Justification of Bloom’s taxonomy action verbs in question paper:

Action Revised Blooms

CO Question Question Revised Blooms
Verbs Taxonomy
No. No. Verbs Taxonomy Level
Used Level
Build Apply (K3) 4a Explain Explain (K2)
4
4b Identify Apply(K3)
Apply Apply (K3) 5a Explain Explain (K2)
5
5b Develop Apply(K3)
6 Solve Apply(K3) 6 Identify Apply(K3)
ASSIGNMENT QUESTION PAPERS MAPPED WITH CO&BT

Course Name: OOPS through C++ Course code:R2021051

Year/sem: II BTECH I SEM Regulation: R20
Course Coordinator: Academic Year:2023-2024

CO Unit No Q. No Questions
Assignment 1

1 Briefly write about History and Evaluation of C++

2 Explain the characteristics of OOP
Explain the concept of inheritance in C++. Provide an
CO1 1 3 example.
Assignment 2
Define Constructor, Identify various Constructors in C++
1 with an example.
2 Explain static keyword in C++.
Write a C++ program to demonstrate the use of
CO2 2 3 constructors and destructors
Assignment 3

1 How do you implement friend functions in C++?

2 Write a C++ program to demonstrate single inheritance
CO3 3 3 Explain the concept of function overloading in C++.
Assignment 4
CO4 3 1 How do you implement operator overloading for a user-
 defined class in C++?
mplement a shape class hierarchy using inheritance and
2 polymorphism in C++.
Write a C++ program to simulate a hospital management
3 system using OOPS concepts.

Assignment 5
1 Explain the concept of move semantics in C++.
2 How do you implement smart pointers in C++?
Analyse the differences between shallow and deep
CO5 4 3 copying.
Assignment 6
1 Compare the differences between throw and catch in C++.
2 Identify the characteristics of an abstract class in C++.
Discuss the difference between abstract classes and
CO6 5 3 interfaces in C++
SCHEME OF EVALUATION WITH CO AND BT MAPPING

II B. Tech I Semester – I MID

Course Name: OOPS C++ Regulation: R20 Course Code: (R2021051)
Date: 05-10-2023 Academic Year:2023-24 Max Marks: 30

1) a. Briefly write about History and Evaluation of C++

History of C++ ------------- 2.5M
Evaluation of C++ -------------- 2.5M
b. Explain the characteristics of OOP
Listing out the characteristics of OOP ------5M
2) a. Define Constructor, Identify various Constructors in C++ with an example.
Definition for a Constructor ----1M
Various Constructors -----2M
Example -----2M
b. Explain static keyword in C++
Static key word explanation -----3M
Example -----2M
3) Explain Binary Operator Overloading in C++ and construct an example of
a. member function
Definition ofBinary Operator Overloading ----2.5M
Example of member function -----2.5M
b. friend function
Definition offriend function ----2.5M
Example of friend function -----2.5M
Branch: CSE Time: 1:30 Hrs
II B. Tech I Semester - II MID
Course Name: OOPS C++ Regulation: R20 Course Code: (R2021051)
Date: 29-11-2023 Academic Year:2023-24 Max Marks: 30

1. a) Explain about Abstract classes and virtual base class in C++ programming.
Abstract classes definition -----2.5M
Virtual base class -----2.5M
b) Identify the advantages and disadvantages of Inheritance in C++.
Advantages of Inheritance ----2.5M
Disadvantagesof Inheritance ----2.5M
2. a) Explain in detail how the members of a class can be accessed using pointer to base
class and derived class with example program.
Definition of a pointer --------1M
Writing a program for members of a class accessing using pointer ----- 1.5M
Definition of a derived class----1M
Example program for derived class-----1.5M
b) Explain the purpose of Virtual Destructors in C++ and Develop a Sample program
Purpose of Virtual Destructors --------2.5M
Sample program for Virtual Destructors --------2.5M
3. a) Identify and Write short notes on the following features of C++ programming
components. (i) Algorithm (ii) Iterators (iii) Maps, multimaps
Explaining briefly about Algorithm------2.5M
Explaining briefly aboutIterators -------2.5M
Explaining briefly aboutMaps-------2.5M
Explaining briefly aboutmultimaps-------2.5M
 TUTORIAL TOPICS

1. Introduction to OOP

 Definition of OOP
 Benefits of OOP
 Comparison with procedural programming
 Classes and Objects
 Attributes and Methods
 Access Specifiers: public, private, protected

3. Constructors and Destructors

 Default Constructor
 Parameterized Constructor
 Copy Constructor
 Destructor and its role in resource management

4. Inheritance

 Single Inheritance
 Multiple Inheritance
 Multilevel Inheritance
 Hierarchical Inheritance
 Hybrid Inheritance
 Accessing Base Class Members

5. Polymorphism

 Function Overloading
 Operator Overloading
 Virtual Functions and Dynamic Binding
 Abstract Classes and Interfaces
6.Encapsulation and Data Hiding

 How encapsulation works in C++

 Getters and Setters
 Importance of data hiding

7. Templates

 Function Templates
 Class Templates
 Template Specialization

8. Exception Handling

 Try, Catch, Throw

 Custom Exception Classes

9. Standard Template Library (STL)

 Introduction to STL
 Using Containers (Vectors, Lists, Maps)
 Iterators and Algorithms

10. Design Patterns

 Introduction to Design Patterns

 Common Patterns (Singleton, Factory, Observer, etc.)
 When to use design patterns

11. File I/O in OOP

 Reading from and writing to files

 Serialization of objects

12. Real-World Applications

 Building a simple project (e.g., a banking system, library management system)

  Discussing the application of OOP concepts in the project

RESULT ANALYSIS TO IDENTIFY WEAK STUDENTS AND BRIGHT

STUDENTS
ADVANCED LEARNERS - ENGAGEMENT DOCUMENTATION
RESULT ANALYSIS AT THE END OF THE COURSE
REMEDIAL CLASSES FOR WEAK STUDENTS
COURSE ASSESMENT
CO, PO/PSO ATTAINMENT SHEETS
CO FEEDBACK FORMS, ANALYSIS
STUDENT FEEDBACK ANALYSIS, CORRECTIVE MEASURED PLAN
OBSERVATION FOR NOT ATTAINING CO OR FOR IMPROVEMENT

Lack of Practical Assignments

 Observation: Students struggle to apply theoretical concepts due to insufficient

hands-on coding assignments.
 Improvement: Increase the number of practical assignments that require students to
implement OOP concepts in real-world scenarios.

Limited Exposure to Advanced Topics

Observation: Many students are not familiar with advanced OOP concepts like
templates, polymorphism, and design patterns.

Improvement: Integrate advanced topics into thesyllabus early on and provide

additional resources or workshops to deepen understanding.

Insufficient Emphasis on Soft Skills

 Observation: Students demonstrate weak communication and teamwork skills during

group projects.
 Improvement: Incorporate activities that foster collaboration and communication,
such as team-based coding challenges and presentations.

Inadequate Feedback Mechanisms

 Observation: Students do not receive timely and constructive feedback on their

assignments, leading to repeated mistakes.
 Improvement: Establish a structured feedback system where students can receive
insights on their work promptly.

Poor Understanding of Theory

 Observation: Students struggle to connect theoretical concepts with practical

applications, impacting their ability to solve problems.
  Improvement: Use case studies and real-world examples to illustrate theoretical
concepts and their applications in programming.

PLAN OF ACTION TO IMPROVE CO ATTAINMENT NEXT TIME

1.Assess Current Performance

 Analyse Feedback: Gather feedback from students regarding difficulties they faced.
 Evaluate Assessments: Review past quizzes, assignments, and projects to identify
areas of weakness.

2. Enhance Teaching Methods

 Active Learning: Implement group projects and peer teaching to encourage

collaboration.
 Flipped Classroom: Assign video lectures for home study, followed by in-class
exercises and discussions.
 Guest Lectures: Invite industry professionals to share insights and applications of
OOP in real-world situations.

3. Improve Resources

 Supplementary Materials: Provide additional resources such as online tutorials,

coding platforms, and recommended readings.
 Practice Tools: Utilize platforms like GitHub for version control and collaboration on
projects.

4. Strengthen Practical Application

 Hands-On Projects: Assign projects that require students to apply OOP concepts in
meaningful ways (e.g., building applications, games).
 Code Reviews: Conduct peer reviews of code to foster critical thinking and learning.
MARKS OF VARIOUS EXAMINATION (QUESTION WISE)