Skip to main content

Course Overview

Programming
C++ Programming

About this course

Welcome to Introduction to c++

I want to welcome you to Introduction to C++. My name is Vinay Kumar  and I will be your host for this course. I'm very excited to have you join us and i'm working to make this the best course available to introduce you to the C++ programming language. I hope you have an enriching and engaging learning experience. 
Before you get started with the course material, please read through the brief overview pages in this unit so you can become oriented to the course structure, the schedule, and how things will work in this course. As always, I welcome your feedback so if something is confusing or doesn't work the way you expect, let me now and  i'll do our best to address it. I ask that you use the feedback discussion board in this section to let me know how you're doing.
Before you get started on your course, please take a moment to introduce yourself in the dicussion forum in this module.  This helps fellow learners to know a little but more about you and helps make discussions in the course later, a little bit easier.

Again, welcome and thanks for taking this course from This blog

You, the Self-Paced Learner


By taking this course, you have entered into an exciting world of self-paced, online learning! If online education is new to you, there are some things you should be aware of that may help you be more successful with this style of learning.
Staying on track. Because there isn't a live instructor to guide you through the material, you'll need to work out a system on your own so you can keep up with the schedule. You should plan on logging in a couple of times a day to check the discussion boards and check for new material. You will not get regular email or announcements when things have changed so be sure to check in regularly. Generally new material will be published once or twice a week (for those taking the course live) but your fellow students will be active in the discussion boards and you'll want to participate in the conversation.
Working on problem sets. It will be up to you to complete the problem sets in each of the modules. We will not provide answer keys for the problem sets or assessments so you'll have to work on the problems until you find the answer. While it may be possible to get solutions from other students or on the internet, we encourage you to work out the problems on your own and use your fellow students or internet resources to provide clues to solving the problem sets and assessments. This will enrich your learning experience and help lock in the concepts. If you get stuck, don't give up! There is enough material in the modules to help you solve the problem and your hard work will pay off.
Instructor feedback. Because of the nature of MOOC-style instruction (Massive Open Online Course), instructors aren't able to provide active feedback to individual students. Most MOOCs have thousands of students enrolled at a time and engaging personally with each student is not possible. However, we encourage you to use the discussion boards and seek help and feedback from your fellow students who are enrolled in the course.
Stick with it! We encourage you to take the course from beginning to end to get the full learning experience. Some modules may be very easy for you and others will be harder. But each module should offer something of value. There's nothing like that feeling of accomplishment when you complete something from beginning to end so hang in there and enjoy the course

Course Materials

While there are no specific course materials for these first four modules, you can enhance your learning by using the following recommended study resources:

Module  1 Introducing C++

  • The C++ Language 
  • C++  History 
  • C++ Program Structure 
  • C++ Apps on Different Platforms
  • Compilation Process
  • The Role of the Linker
  • Code Formatting  
  • C++ Statements

Module 2 Data types in C++

Available Data Types

  • Numeric Data 
  • Character Data
  • Other Data Types
  • Choosing Data Types

Variables and Constants 

  • Introducing variables 
  • Introducing Constants 
  • Type Conversion 

Complex Data Types

  • Arrays
  • Strings 
  • Structures
  • Unions  
  • Enumerations

Module  3 Control Statements 

C++ operators 

  • C++ operators 

Decision Statements 

  • Introduction 
  • if Statements
  • switch Statements 
  • The conditional operator 

 Repetition Statements 

  • Introduction 
  • for Loops
  • while Loops 
  • do Loops
    • Nesting Loops 

    Module  4 Function and Objects

    Introducing to Functions

    • Introduction to Function
    • Function Prototypes 
    • Function Parameters 
    • Inline Function
      • Storage classes and Scope

      Introducing Objects 

      • Introduction 
      • Creating Classes 
      • Class Initialization 

      Encapsulation 

      • Introducing Encapsulation 

      Const Objects 

      • Introducing Const objects 

      Module  5 Pointers

      Pointers 

      • Introducing Pointers 
      • The Dereference  operator 
      • Why Pointers 

      Reference Types 

      • Introducing Reference Types 

      Managing Memory in C++

      • Introducing Memory Management  in C++
      • Allocating Memory 
      • Releasing Memory (Deallocation)
      • Dynamic Memory Allocation 

      Module  6  C++ Classes 

      Splitting classes 

      • Introducing to Splitting Class Files 
      • Header Files 
      • Implementation Files 

      Constructors and Destructors 

      • Class Constructors 
      • Class Destructors
      • Dynamic Memory Allocation and Classes
      • Constructors 




      Scope in Classes

      • What is Class scope?
      • Class Scope 
      • Encapsulation 
      • Namespaces 

      Module  7  OOP in C++

      Inheritance 

      • Inheritance Refresher 
      • Types Of Inheritance in C++

      Encapsulation and Protected Access 

      • The Protected Keyword 
      • Friend Functions 
      • Friend Classes 

      Virtual Functions and Abstract Classes 

      • Introducing virtual Functions 
      • Override Virtual Functions 
      • Virtual Destructors 
      • The Principle of Substitutability 
      • Invoking Virtual Functions 
      • Implementing a Virtual Function 
      • Implementing Pure Virtual Functions 

      Module  8 Streams and Files 

      Module Introduction

      Stream I/O

      • Introduction to streams 
      • A closer Look at istream and ostream
      • Inputting and Outputting Strings
      • Extending Streams to Support Custom Classes 
      • Manipulators  

      Processing Files 

      • Introduction to file Streams 
      • File Open Modes 
      • Reading and Writing Text Data 
      • Reading and Writing Formatted Text  Data 
      • Reading and Writing Binary Data 
      • Getting and Setting the Position in a Stream  

      Strings 

      • Introduction to Strings Streams 
      • Setting and Getting the Content of a String Stream
      • Creating a String Stream from an Existing String 
      • Write Only and Read-Only Strings Streams 
      • Working with wide Characters 
      • Additional String Stream Operations 

      Module  9 Exceptions  

      Exceptions Recap 

      • Recap Exceptions
      • Standards Exceptions Class Hierarchy 
      • Uncaught Exceptions 

      Handling Exceptions 

      • Handling Exceptions 
      • Exception Safety 
      Casting Exceptions 
      • Casting Exception 
      • Mutable Keyword 
      • User Defined conversion 
      • Copy Constructors and Assignments  

      Allocation 

      • Handling Allocation Failures 
      • Customising Memory Allocation 
      • Caching 

      Construction and Destruction  

      • controlling Timing 

      Module  10 Template Functions 

      Template Functions 

      • Template Functions 
      • Implementing Generic Algorithms 
      • Overview of Template Classes 

      Template Classes 

      • Specifying Multiple Type Parameters 
      • Standard Container Classes 
      • Defining Non-Type Template Parameters 

      Template Adapters 

      • Defining Template Adapaters 
      • Specifying Default Template Parameters 
      • Specializing Templates 
      • Defining Trait Classes 

      Module  11 Iterators 

      Iterator Introduction 

      • What is an iterator 

      Standards Iterators 

      • Standard Iterators 
      • Creating Generic Algorithms 

      Functions 

      • Function Objects 
      • Creating Multidimensional Containers 

      Defining Classes

      • Defining Classes that use shared representation objects
      • Reference Counted Strings 
      • Defining Smart Pointers for Garbage Collection  

      Module  12  Patterns 

      Function Pointers 

      • Implementing Callbacks using Function Pointers
      • The Command Patterns 
      • Member Function Pointers 

      Interface 

      • Defining Interfaces
      • Multiple Inheritance 

      Base Classes

      • Virtual Base Classes 
      • Runtime Type Information 

      Inheritance 

      • Private and Protected Inheritance 
      • Class Adapter Pattern 
      • Recap of Static Class Members 

      The Singleton Pattern 

      • The Singleton Pattern 
      • Defining Nested Classes 
      • The Handle Body Idiom 

      Namespace 

      • Using Namespace Effectively 
      • Recap of association and Delegation 

      Pattern 

      • Object Adapter Pattern 
      • The Proxy Pattern 
      • The Null object Pattern 

      Smart Pointers 

      • Defining Smart Pointers
      • Lazy Loading 

      Comments

      Post a Comment

      Popular posts from this blog

      Function and Objects

      C++ Programming   Introducing to Functions Functions are a component of a programming language that permit you to break down the behavior of an application into discreet pieces of functionality, hence the name function.  A function is essentially a block of C++ code that you give a name and then call from other locations in your application, when you want the computer to perform the instructions contained in that function. You create a function by defining it.  The function definition may contain a return type, a function name, parameters to accept incoming arguments, and finally a body which contains the code that will execute as part of that function.  Functions may or may not return a value back to the caller and they may or may not accept arguments passed in to the function. When you move into more advanced C++ programming, you can also overload functions.  This refers to the practice of using the same function name to refer to multip...
      Post a Comment
      Read more

      C++ Classes

      C++ Programming  Introduction to Splitting Class Files Class structure  If an aspect of object-oriented programming is encapsulation, then why would we split our classes into separate files?  Why not keep it all in one if we wish to "encapsulate" all there is about the class? Recall that a part of encapsulation is also data hiding.  Think about your car for a bit as we use it in an analogous way.  A car is a complex device that contains many different components.  You are able to operate your car without the need to understand the complexities of the internal combustion engine or the radio electronics.  You don't need that knowledge to be able to effectively operate the car. Likewise, a programmer using your class files does not need to know how you have implemented your methods to achieve the functionality.  In fact, perhaps you have a proprietary algorithm for a spell checker that is really fast and you don't want any...
      Post a Comment
      Read more

      Control Statements

      C++  Programming  # C++ operators  Because you will start to learn about control statements in C++, it's important to understand the C++ operators that exist in the language first, as they play an important role in control statements. You will work with comparison operators to determine if values are equal, greater, or less than each other.  C++ also allows you to use mathematical operators for incrementing values to help control the number of iterations in a loop.  You can also make use of bitwise operators to speed up some operations in your code.  Operator Description + addition - subtraction * multiplication / division % modulo += (y += x) same as y = y + x -= (y -= x) same as y = y - x *= (y *= x) same as y = y * x ++ increment by 1 -- decrement by 1 == equal to != not equal to > greater than < less than >= greater than or equal to <= less than or equal to && logical AND || logical OR ! logical NOT ...
      Post a Comment
      Read more