Adobe Photoshop CS6

Course: C++

Course Description
C++ is an object oriented programming (OOP) language developed by Bjarne Stroustrup and is an extension of C language. It has imperative, object-oriented and generic programming features. In this course, you will learn the fundamental skills you require to gain expertise over the C++ language.

Class and Lab Hours: 50 (25 Theory, 25 Lab)

Pre-requisites: This course is intended for those with little programming background, though prior programming experience will make it easier, and those with previous experience will still learn C++-specific constructs and concepts.

Course Objectives:
Upon completion of the course, trainees/students will be able to:
  1. Use object-oriented programming techniques
  2. Understand the syntax and semantics of the C++ programming language
  3. Create new classes
  4. Write object-oriented programs in C++
  5. Discovering both initialization and assignment
  6. Initialize the process of data abstraction
  7. Create new data types using inheritance
  8. Understand about polymorphism
  9. Use C++ class libraries
  10. Implement exception handling
  11. Write template functions and classes
Evaluation:There will be one exam that every trainee/student must pass with 75% marks or more score to get a certificate of completion from TIET.

Suggested Learning Approach
In this course, you will study individually or within a group of your peers. As you work on the course deliverables, you are encouraged to share ideas with your peers and instructor, work collaboratively on projects and team assignments, raise critical questions, and provide constructive feedback.

Detailed Course Outline
 Unit Heading   Unit Topics
1. Writing Your First C++ Program
  • Grasping C++ Concepts
  • Installing Code::Blocks
  • Creating Your First C++ Program
  • Executing Your Program
  • Reviewing the Annotated Program
2. Declaring Variables Constantly
  • Declaring Variables
  • Declaring Different Types of Variables
  • Using Floating-Point Variables
  • Declaring and Using Other Variable Types
3. Performing Mathematical Operations
  • Defining Mathematical Operators In C++
  • Using the C++ Mathematical Operators
  • Identifying Expressions
  • Increasing Clarity With Special Mathematical Operators
4. Performing Logical Operations
  • Using Sometimes-Illogical Logical Operators
  • Defining Logical Variables
  • Operating With Bitwise Logical Operators Logically
5. Controlling Program Flow
  • Controlling the Flow Through the Program
  • Executing a Group of Statements Repetitively
  • Avoiding Infinite Loops
6. Creating Functions
  • Writing Functions
  • Passing Data To Functions
  • Naming Functions With Different Arguments
  • Creating Function Prototypes
  • Passing By Value Versus Passing By Reference
  • Providing Default Values For Arguments
7. Storing Sequences in Arrays
  • Considering the Need For Something Like an Array
  • Introducing the Array Data Type
  • Using an Array
  • Using the Most Common Type of Array — The Character String
8. Working With Pointers-I
  • Addressing Variables In Memory
  • Declaring and Using Pointer Variables
  • Recognizing the Inherent Dangers of Pointers
  • Passing Pointers To Functions
  • Allocating Objects Off the Heap
9. Working With Pointers-II
  • Performing Arithmetic Operations On Character Pointers
  • Examining the Relationship Between Pointers and Arrays
  • Increasing Performance of a Program
  • Extending Pointer Operations To Different Pointer Types
  • Explaining the Arguments To Main() In a C++ Program Template
10. Working with C++ Preprocessor
  • Including Source Files
  • Defining Constants and Macros
  • Enumerating Alternatives To Constants
  • Inserting Compile-Time Checks
  • Simplifying Declarations Via Typedef
11. Exploring Object-Oriented Programming
  • Reviewing Object-Oriented Programming
  • Introducing Abstraction and Classification
12. Using Classes
  • Grouping Data Into Classes
  • Declaring and Defining Class Members
  • Adding Active Properties To the Class
  • Accessing Class Member Functions
  • Overloading Member Functions
13. Working with Objects
  • Examining the Arrays
  • Getting a Few Pointers On Object Pointers
  • Strong Typing
  • Navigating Through Lists of Objects
  • Creating and Destroying Objects
  • Declaring Constructors and Destructors
  • Invoking Constructors and Destructors
14. Protecting Members
  • Declaring Members Protected
  • Accessing Protected Members From Within the Class
  • Accessing Protected Members From Outside the Class
15. Working with Constructors
  • Making Argumentative Constructors
  • Overloading the Constructor
  • Creating Objects By Using Constructors
  • Invoking Member Constructors
16. Using the Copy/Move Constructor
  • Introducing the Copy/Move Constructor
  • Making Copies
  • Creating Shallow Copies Versus Deep Copies
  • Avoiding All Copies Having a Move Constructor
17. Working with Static Members
  • Declaring Static Member Data
  • Defining and Using Static Member Functions
18. Inheriting a Class
  • Defining Inheritance
  • Inheriting a Base Class
  • Constructing the Base Class
  • Exploring Meaningful Relationships: the IS_A Versus the HAS_A Relationship
19. Examining Virtual Member Functions
  • Discovering How Polymorphism (A.K.A. Late Binding) Works
  • Overriding Member Functions In a Subclass
  • Checking Out Special Considerations With Polymorphism
20. Factoring Classes
  • Factoring Common Properties Into a Base Class
  • Using Abstract Classes To Hold Factored Information
  • Declaring Abstract Classes
  • Inheriting From an Abstract Class
  • Dividing a Program Into Multiple Modules Using a Project File
21. Using the Assignment Operator
  • Introducing the Assignment Operator
  • Knowing Why and When the Assignment Operator Is Necessary
  • Understanding Similarities Between the Assignment Operator and the Copy Constructor
  • Comparing Copy Semantics With Move Semantics
22. Using Stream I/O
  • Performing Input/Output
  • Rediscovering Stream I/O As an Overloaded Operator
  • Examining the Other Methods of the File Class
  • Using Stream Buffer I/O
23. Handling Errors — Exceptions
  • Introducing an Exceptional Way of Handling Program Errors
  • Finding What’s Wrong With Good Ol’ Error Returns
  • Examining Throwing and Catching Exceptions
  • Packing More Heat Into That Throw
24. Inheriting Multiple Inheritance
  • Introducing Multiple Inheritance
  • Avoiding Ambiguities With Multiple Inheritance
  • Avoiding Ambiguities With Virtual Inheritance
  • Figuring Out the Ordering Rules For Multiple Constructors
  • Getting a Handle On Problems With Multiple Inheritance
25. Tempting C++ Templates
  • Examining How Templates Can Be Applied To Functions
  • Combining Common Functions Into a Single Template Definition
  • Defining a Template Or Class
  • Implementing an Initializer List For a User-Defined Class
26. Standardizing on the Standard Template Library
  • Using the String Class
  • Maintaining Entries In a Standard Template Library List
  • Accessing Container Elements From an Iterator
27. Writing Hacker-Proof Code
  • How To Avoid Becoming a Soldier In Someone’s Botnet Army
  • Getting a Handle On SQL Injection
  • Understanding Buffer Overflow Hacks
  • Defensive Programming Against Buffer Overflows
  • Getting a Little Help From the Operating System
29. Ten Ways to Avoid Adding Bugs to Your Program
  • Enabling All Warnings and Error Messages
  • Using a Clear and Consistent Coding Style
  • Limiting the Visibility
  • Adding Comments To Your Code While You Write It
  • Single-Stepping Every Path At Least Once
  • Avoiding Overloaded Operators
  • Heap Handling
  • Using Exceptions To Handle Errors
  • Declaring Destructors To Be Virtual
  • Avoiding Multiple Inheritance
29. Ten Ways to Protect Your Programs from Hackers
  • Protecting Yourself From User Input
  • Handling Failures In Your Code
  • Maintaining a Program Log
  • Following Good Development Process
  • Practicing Good Version Control
  • Authenticating Users Securely
  • Managing Your Sessions
  • Obfuscating Your Code
  • Signing Your Code
  • Using Encryption Securely
30. Project
  • Project

Every trainee/student will make a portfolio (Binder) that will contain the following in the order listed:
  • Training completion certificate given to student by TIET
  • Course syllabus
  • All assignments (Tutorials and Exercises)
  • Tests/Exams taken by the student
  • Any project done in the class
  • A short summary by the student about how this training session has helped him/her
  • Membership certificate of "Emerging Technologies Club" with student's picture.
  • Class picture with the instructor
  © CADSoft Technologies,Unit No. 256, 2nd Floor, B2, Spaze iTech Park, Sec-49, Sohna Road, Gurgaon, Haryana 122001  
Call us!
Get Social with us!

To Subscribe for monthly Newsletter, please click here