Scribd
Upload
169 views5 pages

C++ Programming Course Syllabus

This document outlines a 72-hour teaching guideline for C++ programming. It covers basic C++ concepts in the first few sessions such as variables, data types, operators, control structures and arrays. Later sessions cover object-oriented concepts like classes, inheritance and polymorphism. More advanced topics like templates, exception handling, file I/O and the Standard Template Library are covered in later sessions. Each session combines a 2-hour lecture with hands-on lab exercises for students to practice and better understand the concepts covered.

Uploaded by

rushikeshjagdale120
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
169 views5 pages

C++ Programming Course Syllabus

This document outlines a 72-hour teaching guideline for C++ programming. It covers basic C++ concepts in the first few sessions such as variables, data types, operators, control structures and arrays. Later sessions cover object-oriented concepts like classes, inheritance and polymorphism. More advanced topics like templates, exception handling, file I/O and the Standard Template Library are covered in later sessions. Each session combines a 2-hour lecture with hands-on lab exercises for students to practice and better understand the concepts covered.

Uploaded by

rushikeshjagdale120
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Teaching Guidelines for

C++ Programming
PG-DAC September 2023

Duration: 72 hours (32 theory hours + 32 lab hours + 8 revision/practice hours )

Objective: To learn object oriented programming using C++

Prerequisites: Knowledge of computer fundamentals

Evaluation: 100 marks


Weightage: CCEE – 40%, Lab exam – 40%, Internals – 20%

Text Book:
 C++ Primer Plus by Stephen Prata /Pearson

References:
 Thinking in C++ by Bruce Eckel
 The C++ Programming Language, Bjarne Stroustrup

(Note: Each Session is of 2 hours)


Sessions 1: Getting Started
Lecture:
 Installation and Setup development environment
 The need of C++
 Features of C++
 C++ versus C
 History of C++
 Writing your first C++ program
Lab:
Write different C++ programs to
 Print Hello World
 Add two numbers/binary numbers/characters
 Calculate compound interest
 Calculate power of a number
 Swap two numbers
 Calculate area of rectangle

Session 2: Beginning with C++


Lecture:
• C++Program structure
 Introduction of advanced C++ concepts and feature of C++ 17
 C++ Tokens
 Initialization
 Static Members
 Constant Members
 Expressions
Operators
• Arithmetic Operator
• Relational Operator
• Logical Operator
• Unary Operator
• Ternary Operator
• Assignment Operator
Lab:
 Write a Student class and use it in your program. Store the data of 10 students and display
the sorted data according to their roll numbers, dates of birth, and total marks.
 Implement all C++ operators
 Declare members and implement in your programs.

Session 3: Conditional and Looping Statements


Lecture:
• If, else if, switch
• for loop
• while loop
• do while loop
 Jump statement (break, continue& return keyword)
 Arrays
 Declaration and initialization of an array
 1-D and 2-D arrays
Lab:
 Implement all control structures through your program
 Implement a program which accepts command line arguments from main function.

Session 4: Functions in C++


Lecture
 Different forms of functions
 Function prototyping
 Call by Reference
 Inline Functions
 Math library functions etc.
Lab:
 Implement functions through your program
 Declare function and call it by reference and note the observations
 Implement Inline functions in your program

Sessions 5 & 6: Memory Management and Pointers


Lecture
 Introduction to memory management in C++
 Pointers in C++
 Arrays using pointers
 Enumeration
 Typedef
 Using New operator
 Class pointer
 this pointer
 Comparison of new over malloc, calloc and realloc, etc.
 Memory freeing using Delete operator
Lab:
 Assignments using pointers, arrays of pointers
 Assignments on passing pointers in functions
 Using pointers, write your own functions for the following:
o String comparison
o String concatenate
o String copy
o String length
Note: Do not include <string.h> in your program and implement Delete operator in your program.

Session 7: OOP Concepts


Lecture
 Discussion on object oriented concepts
 Classes and Objects, Access Specifiers, Overloading, Inheritance, Polymorphism
 Constructors and Destructors
 Namespaces
Lab:
 Write a student class and use it in your program. Store the data of 10 students and display
the sorted data according to their roll numbers, dates of birth, and total marks.

Session 8: Constructor and Destructor


Lecture
 Constructors
 Parameterized constructors
 Multiple constructors in class
 Dynamic initialization of objects
 Copy Constructors
 Destructors
Lab:
 Implement constructor and destructors through your program
 Write a program to implement inner class in C++

Session 9: Inheritance – extending class


Lecture
 Types of inheritance
 Single inheritance
 Multiple inheritance
 Multilevel inheritance
 Hierarchical inheritance
 Hybrid inheritance, etc.
 Virtual base class
 Constructors in derived class
Lab:
 Design a hierarchy of computer printers. Use multiple inheritance in your hierarchy. Also use
friend functions and classes in your program.

Session 10: Polymorphism


Lecture
 Types of Polymorphism
 Overloading functions
 Overloading Operators
 Friend functions
 Constant functions
Lab:
 Write Date and Time classes that allow you to add, subtract, read and print simple dates in
dd/mm/yyyy and time in hh:mm:ss formats. Use function overloading in your program.
 Assignments to overload =, ==, +, ++, --, <<, >> and [ ]operators.

Session 11: Virtual Functions and Abstract Class


Lecture
 Run Time Polymorphism
 Virtual Functions and Pure virtual functions
 dynamic_cast, static_cast,const_cast, reinterpret_cast
 Interfaces
 Abstract class
Lab:
 Implement Abstract classes in your program
 Using virtual and pure virtual functions implement hierarchy of computer printers
 Implement diamond problem with real life example

Session 12: Exception Handling


Lecture
 Exception Handling Introduction
 Exception handling – throwing, catching, re-throwing an exception
 Specifying exceptions etc.
Lab:
 Implement exceptions and do proper management through your program
 Implement Custom exception class

Session 13: Managing Console I/O Operations


Lecture
 Introduction
 C++ streams
 C++ stream classes
 Unformatted I/O operations
 Formatted I/O operations
 Managing output with manipulators
Lab:
 Implement console I/O operations through your program.

Session 14: File Handling in C++


Lecture
 Definition of file
 File handling in C++
 Doing read, write operation in files
Lab:
 Assignments on files doing different operations

Session 15: Templates


Lecture
 Introduction to Templates
 Function Templates
 Class Templates
Lab:
 Assignments on templates

Session 16: STL and RTTI


Lecture
 Introduction to C++ Standard Library
 Introduction to RTTI (Run-Time Type Information) in C++
Lab:
 Assignments on STL Library

Common questions

Powered by AI

The 'new' operator allocates memory and calls the constructor to initialize objects in a single step, providing a more integrated approach to memory allocation in C++. In contrast, 'malloc' only allocates memory and does not call constructors, requiring additional steps for object initialization. 'New' also throws an exception upon failure, providing a more robust error-handling mechanism than 'malloc', which returns a null pointer .

Dynamic initialization of objects allows for the allocation of memory during runtime, enabling developers to initialize objects based on runtime conditions. This feature supports more flexible and efficient applications where memory management needs to be responsive to user input or external data sources. It helps reduce memory wastage and maximizes the efficiency of application operation by tailoring resource use to real-time requirements .

Exception handling in C++ enhances software robustness by providing a systematic way to handle runtime errors. It allows developers to separate error handling code from regular code, leading to cleaner and more manageable programs. By catching exceptional conditions and bouncing back without crashing, exception handling maintains application stability and reliability. It also enables recovery mechanisms, where the program can continue operation or shut down gracefully, preserving data integrity and improving user experience .

Access specifiers, including public, protected, and private, control the visibility and accessibility of class members. Public members are accessible from anywhere in the program, while private members can only be accessed by the class itself and its friends, protecting key parts of an object’s interface from outside interference. Protected members are accessible in the class and its derived classes. These access specifiers implement encapsulation by allowing developers to hide the implementation details and expose only necessary functionality, safeguarding object integrity and promoting maintainability .

Virtual functions enable polymorphism by allowing derived classes to override base class methods. This mechanism is essential for implementing dynamic method binding, where the method to execute is determined at runtime based on the object's type. Virtual functions are crucial for implementing interface classes, which provide a template for other classes to follow, ensuring consistency across different implementations. They enable developers to write code that transparently handles objects of various derived types through base class pointers or references, a necessity for robust API designs and modular programming .

Templates in C++ provide a means to write code that is independent of any particular type, improving code reusability. They allow functions and classes to operate with generic types, reducing redundancy and boilerplate code when similar operations must be performed on different types. This feature also optimizes type safety and decreases errors. For instance, a single template function can operate on integers, floats, and custom objects alike, making it versatile and reducing the total lines of code, which aligns well with the DRY (Don't Repeat Yourself) principle .

Function overloading in C++ allows multiple functions to have the same name with different parameters, enhancing code readability by enabling a uniform naming scheme for functions performing similar tasks. This feature allows developers to intuitively use the same function name for operations that conceptually align but differ in their data types or number of arguments. For instance, a piece of code might use the same function name to calculate the area of various shapes with different formulas, making the code base simpler and more coherent by reducing cognitive load and improving usability .

Polymorphism and inheritance enable developers to write flexible and dynamic code. Inheritance allows the creation of a new class from an existing one, promoting code reuse and hierarchy structuring. Polymorphism enables objects to be treated as instances of their parent class, facilitating dynamic method binding and the ability to work with objects through interfaces. Together, they allow the creation of intuitive APIs and scalable architectures. For example, in designing a GUI framework, base classes define methods for drawing operations, while derived classes implement specifics for different shape objects. This setup simplifies extending the system with new shapes without modifying existing code .

Understanding stack and heap memory allocation is crucial in C++ for optimizing performance and avoiding errors. Stack memory is limited, automatic, and faster but generally used for small, fixed-size data. Heap memory is dynamic and larger, suited for objects requiring a size determined at runtime. Incorrectly balancing these can lead to stack overflow or heap fragmentation. Efficient use ensures resource management aligns with application requirements, preventing leaks and crashes. Awareness of their trade-offs aids in crafting efficient, agile applications .

While multiple inheritance allows a class to derive from more than one base class, it presents challenges like the diamond problem, where ambiguity arises from inheriting from two classes with a common base. Solutions include using virtual inheritance to share base class elements properly, ensuring data members appear only once. C++ offers virtual base classes for this purpose, though careful design and thorough testing are required to avoid complexity and maintain clear, understandable code .

You might also like