C and C++
Introduction to C programming.
- Understanding the difference between procedural and object oriented programming.
- Understanding the motive behind writing computer programs by closely watching their execution cycle.
- Understanding what variables are and how do we use them.
Demystifying a C program
- Understanding what each letter in a C program means.
- Understanding pre-processor (#include, #define etc) directives and header files.
- Writing and using a header file
Working with conditions, switch and loops
- Understanding conditional statements.
- Understanding switch statements.
- Understanding loops.
Introduction to pointers
- Defining a pointer. What it is and what is it's importance.
- Using pointers for predefined data types.
- Using pointers to understand the flow of a C program.
Introduction to functions
- Understanding what a function is and how it is used.
- Understanding the flow in which functions are called.
- Writing useful functions by passing arguments and getting back the result.
Passing arguments by reference and value.
- Understanding the concept behind passing arguments to a function by value.
- Understanding the concept behind passing arguments to a function by reference.
- Understanding the pro and cons of passing arguments by value and by reference.
Revising pointers - Creating pointers to functions.
- Creating pointers to functions.
- Executing a function using a function pointer.
Creating user defined data types - Structures
- Understanding what structures are and how to create and use them.
- Writing some real world code using Structures.
- Creating pointers to a structure and using them.
- Creating nested structures and also pointers to these nested structures.
Introduction to OOPs ( Object Oriented Philosophy )
- Understand what we mean by a class, object, overloading, overriding, data hiding and encapsulation.
- Each of the concepts in OOPs will be discussed and understood by taking real world examples, not bookish stuff.
- Writing real world programs using Class and Objects
Public, private and protected visibility types.
- Why do we have visibility types. How to use them.
- Can pointers help me access the hidden types ? We'll find out !
Revisiting pointers - Creating pointers to classes.
- Creating pointer to a class and using them to access class variables.
- Using pointers to understand how a class looks like inside the RAM
Inheritance - Public, private and protected.
- What is inheritance and what is it's practical significance.
- Understanding public, private and protected inheritance.
- Using pointers to peep into inherited classes.
Virtual functions and abstract classes
- What do we mean by virtual functions.
- How does a virtual function fit into the practical understanding.
- Experimenting with virtual functions using pointers.
- Understanding pure virtual functions and abstract classes.
Revisiting pointers - Pointer to functions inside a class
- Creating pointers to functions inside a class.
- Understanding how to point to functions inside a class and executing them using pointers.
- Understanding overloading and overriding using function pointers.
Introduction to Templates and Standard Template Library
- Understanding data structures - stack, queue, link list, double link list and trees
- Understanding the importance and use of Templates.
- Writing useful code using the Template concept.
- Understanding what Standard Template Library is and using it in our programs.
- Using Iterators for accessing information from a Template.
File handling
- Understanding the serialization concept - binary and xml serialization.
- Understanding what a file is and how it is stored on a disk.
- Creating files and writing / reading information to / from them.
- Storing classes and collection to a file and reading them back.
Facebook
Twitter
RSS Feed