Definition of Language
Need for a Language
Definition and Need for a Programming Language
Generations of Programming Languages
A. Based on Interaction between Computer and its User
B. Based on the Programming and Execution Efficiency
Pros and Cons of Programming Languages – Generation by Generation
Low Level Languages Vs High Level Languages
Language Translators and Comparison
Where does C++ Language Stand?
Basics of Flow Charts and Algorithms
Designing Flow Charts and Algorithms with examples
Concept of Pseudo Code with Examples
History, Features and Applications of C Language
What is ANSI/ISO standard C++?
C++ - Character Set
C++ - Keywords
Statements and Expressions
Rules to be followed while writing C++ Statements & Programs
Skeleton of a C++ Program
Basic Output object: cout and Stream Insertion Operator with Examples

What changes from C to C++: Our Perception?
Programming Methodologies:
A. Structured Programming
B. Object-Oriented Programming
Applicability of the above two methodologies
Bottlenecks of Structured Programming
What is Object-Oriented Programming?
Offerings of Object Oriented Programming
Writing the first C++ program
Using Pre-defined headers and Namespaces in C++ Program
C++ Program – Steps to Compile and Execute
C++ Program – Steps to Debug and fix the errors and warnings
Using Escape Sequences with cout object
Formatting output with cout object using Manipulators
Producing output using cascading
Programming Approach: C vs C++

Concept of Token
The two styles of Commenting the Code
Concept of Variable, Constant and Reference
Rules for naming Variables
Data Types and their Storage Limitations with Examples
Declarations and Definitions of Variables, Dynamic Declarations and NameSpaces
Basic Input object: cin and Stream Extraction Operator using Example Programs
Types of Statements
Concept of Expression
Result of Expressions
Type Modifiers
Coercion
Simple Programs on Data Types
Concept of Operators
Classification of Operators
A. With respect to the Type of Operations Performed
B. With respect to the Number of Operands Required
Masking using Bit-wise Operators
Precedence and Associativity of Operators

Concept of Statement Blocks

Program Control Flow and Programming Constructs
1. Sequential Structure
2. Selection Structure
A. If Family
i) Simple if
ii) if-else
iii) Nested if-else
iv) if-else Ladder
B. Switch/Case Structure
3. Repetition Structure
i) while
ii) do-while
iii) for
Using Break and Continue Keywords with examples
Common Pitfalls and Tips to use Programming Constructs
goto and Labels with examples
Programs using multiple Programming Constructs
Design and Development of Menu Driven Programs
Programs to Improve Logical Thinking
A. Generation and Summation of various number series
B. Generation of various display pattern using alphabets, numbers, and special characters

Function Definition and its Usage
Benefits of using Functions
Blocks and Scope Rules
The Scope Resolution Operator ::
Calling and Called Functions
Function Calling statements
Returning from a Function
Prototyping and its Necessity
Passing Arguments to Functions
Using Constant Arguments
Call by Value
Limitation of Call by value
Call by Reference
A. Passing Pointers
B. Passing Reference Variables
Merits of Call by Reference
Storage Classes with examples
Recursion with examples
Function Overloading
Defining Default Arguments

Structure Definition and its Usage

Basics and Applications of Structures

Difference between Structure Elements and Variables
C Style Vs C++ style Structures
Initialization of a Structure Variable – C Style
Initialization of a Structure Variable – C++ Style
Accessing Structure Elements using DOT Operator
Memory Map of a Structure
Functions as structure Members
Copying of Structure Variables
Arrays of Structures
Functions and Structures
Passing Structure Variables and References to Functions
Returning Structure Variables and References from Functions
Using typedef and #define Statements
Anonymous Structures
Nested Structures
Using Enumerated Data Types

Concept of Class

Class Members and the Scope Resolution ::

Creating and initializing Objects
Memory Map of Objects
Differences between Structure and Class
Implementing Member Functions Inside/Outside of the Class
Invoking Member Functions
Accessors and Mutators
Inline Methods
Visibility Labels: private and public
Passing objects as arguments
Returning objects from member functions
Passing references to member functions
Returning object references from member functions
Constant Objects and Members
Static Members
Array of Objects
Nested Classes
Friend Functions and Classes
Data Abstraction and Encapsulation

Concept of Constructor
Uses of Constructor
Types of constructors:
A. Default Constructors
B. Parameterized Constructors
C. Overloaded Constructors
D. Copy constructors
E. Empty Constructors
Converting Basic data types to Objects using Constructors
Explicit Calls to Constructors and Anonymous Objects
Initialization of Objects using Initialization Section
Using Constants in Initialization Section
Constructors with empty body
Illegal Calls to Constructors
Methods under Private Visibility
Concept and Use of Destructors
Destructors - The Execution Order
Initialization of Nested Class Objects

Array Definition and its Usage
Advantages of using Arrays

Single-Dimensional Arrays

A. Array Declaration
B. Array Initialization
C. Accessing Elements from an Array
D. Array Storage Map
E. Example Programs
Implementation of Linear search
Implementation of Binary search
Implementation of Selection sort
Implementation of Bubble Sort
Implementation of Insertion Sort
Multi-Dimensional Arrays
A. Array Declaration
B. Array Initialization
C. Accessing Elements from an Array
D. Array Storage Map
E. Example Programs
3. Character Based Strings
A. Built-in String Functions and User defined Functions
B. Multi-Dimensional Strings with Program Examples
Passing and returning Arrays to and from Methods

Concept of Operator Overloading
Need to Overload Operators
Syntax of Overloading
The Operator Keyword
Approaches to Overload Operators:
A. Member Functions
B. Non-Member Functions
C. Friend Functions

Merits and Demerits of each Approach
C++ Programming
Course Contents
Notations of Calls to Overloaded Operator Methods in each Approach
Overloading of Unary Operators using above three Approaches
Overloading of Pre/Post Increment/Decrement Operators
Overloading of Binary Operators using above three Approaches
Overloading Subscript Operator for Safe Boundary Checks
Role of Anonymous Objects in Operator Overloading
Role of const Qualifier in Operator Overloading
Role of Friend Functions in Operator Overloading
Automatic Data Conversions using Constructors
Data Conversions Between Objects and Built-in Data Types
Data Conversions Between Objects of Different Classes
Rules to be followed while Overloading Operators
Limitations of Operator Overloading
Using the Keywords: explicit and mutable

Pointer Definition and its Usage
Advantages with Pointers

Types of Pointers and their respective Size
Void Pointers
Pointer Arithmetic
Pointers to Arrays
Pointers to Strings
Pointers as Function Arguments
Character Pointers and Functions
Array of Pointers
Initialization of Pointer Arrays
Passing an Array to a Function
Pointers to Pointers
Pointers Vs Multi-Dimensional Arrays
Pointers to Objects
Accessing Class Members through Pointers
Dynamic Memory Allocation: Built-in and User Defined Data Types
The Operators: new and delete
Constant Pointers and Pointers to Constants

Definition of Inheritance
Merits of Inheritance
Concept of Base and Derived Classes
Using Visibility Labels to Control the Access
Using the keyword: protected
Invoking Base Class Constructors while creating Derived Class Objects
Execution Order of Constructors in the Context of Inheritance
Methods of invoking Base Class Constructors
Overriding Methods
Scope Resolution with Overridden Functions
Types of Inheritance
Relationships
A. A-Kind-Of relationship
B. Is-A relationship
C. Part-Of relationship
D. Has-A relationship
Abstract Classes
Implementation issues and resolution

Definition of Polymorphism
Types of Polymorphism
Static vs Dynamic Binding
Virtual Member Functions
Accessing Member Functions through Pointers
Accessing Virtual Member Functions through Pointers
this pointer
Pointers to Base and Derived Classes
Abstract Classes and Pure Virtual Functions
Virtual Destructors
Virtual Base Classes
Back to Friend Functions
Dynamic Type Information
Types of Casting
Checking the Type of a Class with dynamic_cast
Changing Pointer Types with dynamic_cast
Type Identification: typeid Operator

Introduction to Streams
Advantages of Streams
Built-in Stream Classes and Objects
Class hierarchy of Predefined Streams
Stream opening Modes and Methods

Predefined Macros for stream operations
Text based Stream I/O Operations and Methods
Integer based I/O using Streams
Character based I/O using Streams
String based I/O using Streams
Record based I/O using Streams
Binary based Stream I/O Operations and Methods
Stream Errors and Status Enquiries
Creation of Database using Streams
Formatted Input and Output using Streams and Manipulators
Command Line Arguments
Overloading of Extraction and Insertion Operators
Overloading of cout and cin Objects
Overloading for Files

Definition of Template
Benefits of using Templates
Types of Templates
Function Templates
Class Templates
Templates with Arguments
Templates with Default Arguments
Definition of Exception
Advantages of Exception Handling
The keywords: try, catch and throw
Implementation Methods
Handling Generic Exceptions
Supporting Multiple Exceptions
Data Extraction from Exception Objects
Scope Rules and Issues with Exceptions