C & C++ Training In Bangalore

C & C++ Training In Marathahalli & Best C & C++ Training In Bangalore

Learn C & C++ from RIA Institute of Technology

RIA Training Bangalore offers the Best  C & C++ Training from beginner level to advanced techniques, taught by experienced working professionals in  C & C++ for more than 5 years. Our  C & C++ Training in Bangalore you’ll learn real-time concepts in expert level in a practical manner.

We at RIA Training Bangalore focus on delivering the  C & C++ Training that best suits you, whether it is regular classes or weekend batch. We understand your need for learning  C & C++ and we work together to deliver the best Training in  C & C++ that help you in building your future. 

Training Bangalore provides end-to-end support and helps you in identifying and learning the best course from our Training Institute.

Who can benefit from  C & C++ Training in Bangalore?

Students and professionals with experience ranging from 0 -15 years can take advantage of  C & C++ Training in RIA Training Bangalore and grow faster in a career. 

To support students we provide week day classes with theory and practical exposure. RIA Training Bangalore Institute is equipped with advanced lab where students can practice  C & C++ course on real-time scenarios.

To know more about  C & C++ Training in Bangalore talk to our experts.

We Cover the following Topics in C & C++ Training

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
  • 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 OO 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 OO 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 OO 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