Programming Fundamentals using C/C++

1. Introduction to C and C++ (3 Lectures)

History of C and C++,

 Overview of Procedural Programming and Object-Orientation Programming, 

Using main() function,

 Compiling and Executing Simple Programs in C++.

2. 

Data Types,

 Variables, 

Constants, 

Operators and Basic I/O (5 Lectures)

Declaring,

 Defining and Initializing Variables, 

Scope of Variables, 

Using Named Constants,

 Keywords, 

Data Types, 

Casting of Data Types, 

Operators (Arithmetic, Logical and Bitwise),

 Using Comments in programs,

 Character I/O (getc, getchar, putc, putcharetc), 

Formatted and Console I/O (printf(), scanf(), cin, cout), 

Using Basic Header Files (stdio.h, iostream.h, conio.hetc).

3. Expressions, Conditional Statements

 and Iterative Statements (5 Lectures)
Simple Expressions in C++ (including Unary Operator Expressions, Binary Operator Expressions), 

Understanding Operators Precedence in Expressions, 

Conditional Statements (if construct, switch-case construct), 

Understanding syntax and utility of Iterative Statements (while, do-while, and for loops), 

Use of break and continue in Loops,

 Using Nested Statements (Conditional as well as Iterative)

4. Functions and Arrays (10 Lectures)
Utility of functions,

 Call by Value,

 Call by Reference, 

Functions returning value, 

Void functions, Inline Functions,

 Return data type of functions, 

Functions parameters, 

Differentiating between Declaration and Definition of Functions, 

Command Line Arguments/Parameters in Functions, 

Functions with variable number of Arguments.

 Creating and Using One Dimensional Arrays

 ( Declaring and Defining an Array, Initializing an Array, Accessing individual elements in an Array, Manipulating array elements using loops),

 Use Various types of arrays (integer, float and character arrays / Strings) 

Two-dimensional Arrays (Declaring, Defining and Initializing Two Dimensional Array, Working with Rows and Columns),

 Introduction to Multi-dimensional arrays

5. Derived Data Types (Structures and Unions) (3 Lectures)
Understanding utility of structures and unions, 

Declaring, initializing and using simple structures and unions, 

Manipulating individual members of structures and unions, 

Array of Structures, Individual data members as structures, 

Passing and returning structures from functions, 

Structure with union as members,

Union with structures as members.

6. Pointers and References in C++ (7 Lectures)

Understanding a Pointer Variable,

 Simple use of Pointers (Declaring and Dereferencing Pointers to simple variables), 

Pointers to Pointers,

 Pointers to structures, 

Problems with Pointers, 

Passing pointers as function arguments, 

Returning a pointer from a function, 

using arrays as pointers, 

Passing arrays to functions.

 Pointers vs. References, 

Declaring and initializing references, 

Using references as function arguments 

and function return values

7. Memory Allocation in C++ (3 Lectures)

Differentiating between static and dynamic memory allocation, 

use of malloc,

 calloc and free functions, 

use of new and delete operators, 

storage of variables in static and dynamic memory allocation

8. File I/O, Preprocessor Directives (4 Lectures)
Opening and closing a file (use of fstream header file, ifstream, ofstream and fstream classes),

 Reading and writing Text Files, 

Using put(), get(), read() and write() functions, 

Random access in files, 

Understanding the Preprocessor Directives

 (#include, #define, #error, #if, #else, #elif, #endif, #ifdef, #ifndef and #undef), 

Macros

9. Using Classes in C++ (7 Lectures)
Principles of Object-Oriented Programming,

 Defining & Using Classes,

 Class Constructors,

 Constructor Overloading,

 Function overloading in classes,

 Class Variables &Functions,

 Objects as parameters,

 Specifying the Protected and Private Access,

 Copy Constructors, 

Overview of Template classes and their use.

10. Overview of Function Overloading and Operator Overloading (5 Lectures)

Need of Overloading functions and operators, 

Overloading functions by number and type of arguments,

 Looking at an operator as a function call, 

Overloading Operators (including assignment operators, unary operators)

11. Inheritance, Polymorphism and Exception Handling (8 Lectures)

Introduction to Inheritance (Multi-Level Inheritance, Multiple Inheritance), 

Polymorphism (Virtual Functions, Pure Virtual Functions),

 Basics Exceptional Handling (using catch and throw, multiple catch statements),

 Catching all exceptions, 

Restricting exceptions, 

Rethrowing exceptions.