Object Oriented Programming using C++

About C++ Language

C++ is a general-purpose object-oriented programming (OOP) language, developed by Bjarne Stroustrup, and is an extension of the C language. It is therefore possible to code C++ in a "C style" or "object-oriented style." In certain scenarios, it can be coded in either way and is thus an effective example of a hybrid language.

Why this course is required

C++ is known to be a very powerful language. C++ allows you to have a lot of control as to how you use computer resources, so in the right hands its speed and ability to cheaply use resources should be able to surpass other languages. Thanks to C++'s performance, it is often used to develop game engines, games, and desktop apps. Many AAA title video games are built with C++.

Pre-requisites for C++ Programming

Next Course Recommended

Course Contents

  1. Introduction of C++
    • What is C++, its Applications, Advantages etc.
    • Difference between C and C++.
    • Creating C++ source file, Editing, Compiling, Linking, Debugging.
    • Object Oriented Programming(OOP).
    • Applications of OOP, Benefits of OOPS.
  2. C++ Tokens, Expressions, and Control Structure.
    • Tokens
    • C++ keywords
    • Basic Data Types
    • User-defined Data Types
    • Derived Data Types
    • Operators in C++
    • Operator Precedence
    • Reference Variables(Ω)
    • Theta Notation (Q)
  3. Decision Control and Looping Statements
    • Conditional Branching Statements
    • if Statement
    • if–else Statement
    • if–else–if Statement
    • Switch Case
    • while loop
    • for Loop
    • do-while Loop
    • Nested Loops
    • Break and Continue Statements
    • goto Statemen
  4. Functions In C++
    • Different forms of functions
    • Function prototyping
    • Call by Reference
    • Inline Functions
    • function overloading
    • Math library functions
    • Default Arguments in function
  5. Classes And Objects
    • C Structure revision
    • Defining classes, defining member functions
    • Declaration of objects to class
    • Access to member variables from objects
    • Different forms of member functions dependence on access specifiers
    • Array of objects
    • Objects as function arguments
    • Returning objects
    • Pointers to members
    • Local classes
    • Friendly function
  6. Memory Management and pointers
    • Using New operator
    • Comparison of new over malloc, calloc and realloc
    • Memory freeing using Delete operator
    • Dynamic 1-D Array
    • Dynamic 2-D Array
    • Dynamic 3-D Array
  7. Constructor and Destructors
    • Introduction to Constructors and Destructors
    • Default Constructor
    • Parametrized Constructor
    • Dynamic Constructor
    • Copy Constructor
    • Default Argument Constructor
    • Overloading of Constructor
    • Destructor
    • Explicit Constructors
    • Dynamic Initialization and Assignment Operato
    • Private Copy Constructors
    • Usage of Constructors and Destructors for Constant Objects
    • Dynamic initialization of object
  8. Operator Overloading and Type conversion
    • Introduction of Operator Overloading
    • Overloading of Unary Operator
    • Overloading of Binary Operator
    • Operator Overloading using Friend Function
    • Overloading of new and delete operator
    • Overloading of () and [] operator
    • Overloading of +=,-=,*= and /= operator
    • Using Friends to Overload << and >> Operators
    • Overloading Assignment Operator (=)
    • User-defined Conversions
    • Built-in Data Type to Object Conversions
    • Object to Built-in Data Type
    • Conversion of Object Type using Constructors
    • Conversion of Object Type using Conversion Functions
    • Constructor vs Operator Functions for Conversion
  9. Template
    • Function Templates
    • Drawbacks of using Macros
    • Single-argument Function Templates
    • Generic Sorting and Need for Operator Overloading
    • Sorting Employee Objects using Generic Bubble Sort
    • Function Templates with Multiple Arguments
    • Function Templates with Two Generic Arguments
    • Non-generic Parameters in Template Functions
    • Types of Non-generic Arguments
    • Overloading One Generic Function
    • Default Arguments to Function Templates
    • Class Templates
    • Defining Functions of Class Templates outside the Class
    • Classes with Multiple Generic Data Types
    • Static Data Members
    • Friends of Class Template
  10. Exception Handling
    • Need for Exception Handling
    • Components of Exception Handling Mechanism
    • try Block
    • catch Block
    • throw Expression
    • Throwing within and outside Functions
    • Throwing Variables Other than Objects
    • Using Multiple catch
    • Catch All
    • Restricting Exceptions from Functions: Exception Specification
    • Rethrowing Exceptions
    • terminate() and unexpected() Functions
    • uncaught_exception() Function
    • Exception Class
  11. Inheritance
    • Advantages of using Inheritance
    • Defining Derived Classes
    • Derivation using Public Access Modifier
    • Derivation using Private Access Modifier
    • Protected Access Specifier
    • Deriving Multiple Classes from a Single Class
    • Multiple Inheritance
    • Problems in Multiple Inheritance
    • Deriving a Class from an Already Derived Class
    • Virtual Base Class
    • Applications of Constructors and Destructors
    • Exception Handling in Case of Derivation
    • Composite Objects (Container Objects)
  12. Run-Time Polymorphism by Virtual Function
    • Compile Time and Run-time Polymorphism
    • Pointer to Object
    • this Pointer
    • Terminology of a Directed Graph
    • Compatibility of Derived and Base
    • Class Pointers
    • Subobject Concept
    • Base Class and Derived Class Member Functions
    • Virtual Functions
    • Static vs Dynamic Binding
    • Default Arguments to Virtual Functions
    • Advantages of using Virtual Functions
    • Virtual Destructors
    • Use of Virtual Functions
    • Pure Virtual Functions
    • Static Invocation of Virtual Function
  13. Run-Time Type Information And Casting Operators
    • Polymorphic Objects
    • Need for RTTI
    • typeinfo Object and typeid Operator
    • Using typeid for Nonpolymorphic Objects
    • Using typeid for Polymorphic Objects
    • Applying typeid to Class Names and Objects
    • Casting using dynamic_cast
    • Casting using const_cast
    • Casting using static_cast
    • Casting using reinterpret_cast
    • Cross Casting
    • Downcasting
  14. Streams and Formatted INPUT/OUTPUT
    • Predefined and Wide Character Streams
    • C++ Stream Classes Hierarchy
    • Formatted and Unformatted I/O
    • put() and get() Functions for cout
    • getline(), read(), and write() Functions
    • Setting and Clearing Format Flags
    • Using setf() Function with Two Arguments
    • Examining and Clearing Flags
    • Manipulators
    • Differences between Manipulators and ios Functions
  15. Using Files For Input/Output
    • File I/O Programming
    • Text and Binary Streams
    • Opening and Closing Files
    • Reading from and Writing to Text Files
    • Reading from and Writing to Binary Files
    • seekg() and seekp()
    • tellg() and tellp()
  16. Namespaces
    • Name Conflict Problem
    • Ways of using Namespaces
    • Defining a Namespace
    • Defining Variables Inside a Namespace
    • Defining Functions Inside a Namespace
    • Defining Classes Inside a Namespace
    • Declaring Inside and Defining Outside the Namespace
    • Unnamed Namespaces
    • Nested Namespaces
    • Namespace Aliases
    • std Namespace
  17. String Objects
    • Introduction
    • Operations on String Objects
    • Creating Strings
    • Substring Operations
    • Operations Involving Multiple Strings
    • String Characteristics
  18. Standard Template Library
    • Generic Programming
    • Generic Algorithmss
    • Iterators
    • Containers
    • Generic Algorithms
    • find() Algorithm
    • copy() Algorithm
    • sort() Algorithm