C/C++ Training in Coimbatore

C Programming

• Introduction to the C Language
• The C Language and its Advantages
• The Structure of a C Program
• Writing C Programs
• Building an Executable Version of a C Program
• Debugging a C Program
• Examining and Running a C Application Program
• Data Types and Variables
• Data Types
• Operands, Operators, and Arithmetic Expressions
• nput/Output Management
• Input/Output Management
• The getchar() and putchar() Functions and Single-character I/O
• Formatted Input and the scanf() Function
• Control-flow Statements
• The Control-flow Program Statements
• Looping Statements
• The Data-checking Process
• Modular Programming with Functions
• he C Function
• Passing Data to Functions
• Passing an Address to Modify a Value in Memory
• Using Functions in the Checkbook Program
• The C Standard Library Functions
• Arrays, Pointers, and Strings
• Arrays
• Pointers
• Strings
• Using Arrays, Strings, and Pointers in the Checkbook Program

C / C++ C Language

• Introduction to C Programming<
• Introduction to the Course
• Overview to C Programming
• Why use C?
• Uses of C
• A Brief History of C
• C for Personal Computers
• Running C Programs
• The Edit-Compile-Link-Execute Process
• Using Microsoft C
• Unix systems
• Structure of C Programs
• C's Character Set
• The form of a C Program
• The layout of C Programs
• Pre-processor Directives
• Your First Program
• Add Comments to a Program
• Data Types
• Integer Number Variables
• Decimal Number Variables
• Character Variables
• Assignment Statement
• Arithmetic Ordering
• Something To Declare
• More on Initializing Variables
• Input and Output Functions
• On The Run
• Input and Output Functions in More Detail
• The % Format Specifiers
• Formatting Your Output
• Custom Libraries
• Summing It Up
• Conditional Execution
• Program Control
• Logical Expressions
• True and False in C
• Using break and continue Within Loops
• Select Paths with switch
• Structure and Nesting
• Think of a number
• Functions and Prototypes
• Functions - C's Building Blocks
• Functions and Local Variables
• Making The Connections
• Functions and Prototypes
• What is ANSI C?
• The Standard Library Functions
• Throwing The Dice
• Data Types Part II
• Global variables
• Constant Data Types
• Arrays
• Advanced Data Types
• In Dis-array
• Pointers/li>
• Point to Point
• Swap Shop
• Pointers And Arrays
• Strings
• Stringing Along
• As easy as... B or C?
• A Sort Of Bubble Program
• Structures
• Defining A New Type
• Structures and Functions
• Pointers to Structures
• Malloc
• Structures and Linked Lists
• Structures and C++
• Header Files
• File Handling<
• The Stream File
• Text File Functions
• Binary File Functions
• File System Functions
• Command Line Parameters

C++ Programming

Object Oriented Features - Fundamental OOp features, embodied in C++ classes

• Basic OO concepts, example
• Classes: definition, attributes, methods
• Customer class: definition/declaration, implementation
• File organization: header files, implementation files
• Minimum class functions: declaration, implementation

Objects - Two different types of C++ objects and safe ways of handling them

• Definition, UML syntax, comparison with classes
• Creating C++ objects: automatic, dynamic
• Automatic objects: syntax, proper style, common mistakes
• Dynamic objects: syntax, features, common mistakes
• Managing object pointers to keep them safe.

What we've seen so far... - Reviewing the C++ / OO world

• >OO concepts
• C++ Keywords
• C++ features
• C++ class versus the UML analysis model
• C++ class versus the UML design model
• C++ Application Code - Building a basic C++ application
• The required main() function
• The main() function file
• Application files

Lab One - Building the Customer C++ application

• The Customer application in C++
• Project, directories and files
• Running the application

Constructors - A fundamental OOP feature

• Constructor role, syntax
• Example: header file, implementation file
• Constructor with default parameter values
• Constructor header, implementation and usage
• What we just learned

Encapsulating into an object - How a String class can be designed to greatly simplify the Customer class, according to strategies

• We can accomplish more
• Impact of a String object to the Customer class
• The String class: features, design, attributes, methods
• Lab Two - Appreciating the power of encapsulation and specialization
• String class implementation
• Using the String class in the Customer class
• Code review and discussion

Destructors - The art of describing complex object interactions

• Role, syntax, usage
• Code examples with the Customer and Credit classes
• Header and implementation files for destructors

Lab Three - Implementing the String destructor

• Dynamic de-allocation
• Array de-allocation
• Run, test, debug
• Associations - How objects stay in touch with each other
• Self-reference, the this pointer
• Credit and Customer class associations code
• main(): how the association is used
• Association UML syntax and examples
• Reflexive associations for diagraphs, linked lists, hierarchies
• Association roles

Lab Four - Making objects interact with each other in C++

• Applications made of interacting objects
• Simple linked list example
• List and Link class members
• Putting Customer objects in the list
• Write, test, debug and extra credits

Inner Classes - The proper syntax for private objects and true encapsulation

• Principles
• Inline Syntax
• Header / implementation syntax
• Code example
• Lab Five - Inner classes at work
• Link as an inner class of List
• Credit as an inner class of Customer
• Code, test, debug
• Code review
• Solution discussion

What we've learned... - Summarizing the key OO features and techniques, implemented in C++

• Encapsulating string matters in a String class
• C++ application architecture
• Allocation / de-allocation of objects
• Encapsulation / specialization
• Constructors / Destructors
• Associations
• this self reference
• Object design fundamental strategies
• Inner classes

C++ References - A nicer and safer syntax to handle objects

• Concept and formal syntax
• Example with the Person class
• Methods returning a reference to self
• Example
• Brief exercise

Initialization - Starting with a value

• Object initialization
• Declaration, implementation, usage
• Member initialization
• Example with the String and Person classes
• Initializing primitive type members
• Formal syntax

Lab Six - Initializing many objects and members

• Initializing String members in Customer and Credit classes
• Initializing List using either references or pointers
• Write, run, test, debug
• Solution walk through

C++ Operators - A simple and powerful syntax to handle a natural need

• A natural need
• Alternate syntax for methods
• Examples and formal syntax
• Complete case: the Complex class
• Internal and external operators

Lab Seven - Creating your own operators

• String class assignment and append operators
• Write, run, test, debug
• Solution walkthrough

Static Class members as opposed to object members

• Beyond objects: class members
• Examples, allocation, initialization
• Brief exercise

Composition / Aggregation - Objects containing or owning other objects

• Definition and UML syntax
• The real composition concept
• Multiple parts
• Aggregation versus composition
• Inner class notation
• Class type notation
• Examples in C++
• Brief exercise

Constant members (const) - A simple syntax to enforce proper OO design strategies

• Const members
• Const parameters
• Const variables
• Const methods
• Examples
• Brief exercise

Inheritance - Modeling type hierarchies

• Definition and UML syntax
• Instantiation limitations
• Inheritance versus the Is A relationship
• Inherited object examples
• Multiple sub-classes and multiple inheritance

Inheritance C++ syntax - Coding inheritance in C++

• Derivation model and code: simple inheritance
• Multiple inheritance
• Initialization according to constructor needs
• Initialization according to inheritance type
• Example with Contract / Development / Maintenance
• Virtual methods

Lab Eight - Coding a C++ project involving inheritance, associations, aggregation

• The Retail problem domain model
• Associations, compositions
• Inheritance and virtual methods
• show() and getPrice() methods
• Write, test, debug and solution code walkthrough

Interfaces - Generalizing a group of methods that form a functional concept

• The concept of interface and UML notation
• Pure virtual classes and inheritance for interfaces
• C++ examples
• Brief exercise

Exception Handling - Encapsulating and processing exceptions outside the main business logic

• Inner class exception type and value
• try, throw and catch
• Call stack handling
• Throwing objects for better exception handling
• Building self-contained exception classes
• Building exception class hierarchies
• Exceptions with templates
• Exceptions and constructors
• Exception interface specification
• Examples
• Exercise

Object Design - Fundamental principles and basic patterns

• Specialization, self-sufficiency, interface
• Delegation, propagation
• A common object design pattern
• Application to the Deal model
• Multiple and cascading object interactions in C++
• Object sequence and collaboration diagrams
• Examples
• Brief exercise

C++ implementation of associations and association classes - Design and coding of the most common relationships

• Implementation algorithm
• Single or multiple links
• Single or bi-directional traversals
• References or lists of references
• Association classes implementation
• Examples
• Brief exercise

Templates - Beyond classes and models: templates and meta models

• Concept, flexibility and power
• Examples, formal syntax
• Header and implementation parts (both in header file)
• Complex class complete example
• Brief exercise on the Complex class

Lab Nine - Implementing a whole template

• Concept of a parametized List
• Implementing the Link template
• Implementing the List template
• Additional methods
• Write, test, debug and solution code walk through