Loading...
  1. About the Course
  2. Syllabus
  3. Target Audience
  4. Book the Course

 

    Course Overview

    C++ Training Courses London

      This course is a thorough hands-on prologue to protest arranged programming in C++ training in london for non-C software engineers. Accentuation is set on the components of C++ that backing successful displaying of the issue space and reuse of code. The course comprises of two modules. The principal module presents the center C elements of C++, with disentangled data/yield through iostreams.

      The module starts with straightforward hands-on programming utilizing C++ to do info, calculation and yield. The C++ information sorts are secured, and straightforward if tests and circles are secured. C++ program structure is presented. Pointers, tending to, and clusters are talked about. Structures and unions are secured. In the second module, object-arranged ideas are presented. The C++ class develop is presented and its key components explained regulated, giving full usage of theoretical information sorts. C++ memory administration is examined.

      Capacity and administrator over-burdening and the utilization of references are secured. The extension and access control systems of C++ are portrayed. Legacy is presented. The utilization of virtual capacities to execute polymorphism is examined. Broad programming illustrations and activities are given. The course is present to ANSI standard C++ and is planned so it can be taught in any environment with an ANSI C++ compiler.

      Course Length: 60 Hours

      Evening Classes

    • Tuesday and Thursday
    • 6:30pm - 9:30pm
    • 10 weeks

    • Saturday Classes

    • 10:00am - 5:00pm
    • 10 weeks
Course Content

Overview of the Microsoft .NET Platform

  • Introduction to the .NET Platform
  • Overview of the .NET Framework
  • Benefits of the .NET Framework
  • The .NET Framework Components
  • Languages in the .NET Framework
  • Describing the .NET Platform
  • Listing the main elements of the .NET Platform
  • Explaining the language support in the .NET Framework
  • Describing the .NET Framework and its components

  • Overview of C#

    • Structure of a C# Program
    • Basic Input/Output Operations
    • Recommended Practices
    • Compiling, Running, and Debugging
    • Explaining the structure of a simple C# program
    • Using the Console class of the System namespace to perform basic input/output operations
    • Handling exceptions in a C# program
    • Generating Extensible Markup Language (XML) documentation for a C# application
    • Compiling and executing a C# program
    • Using the Microsoft Visual Studio Debugger to trace program execution

    • Using Value-Type Variables

      • Common Type System
      • Naming Variables
      • Using Built-In Data Types
      • Creating User-Defined Data Types
      • Converting Data Types
      • Describing the types of variables that you can use in C# applications
      • Naming your variables according to standard C# naming conventions
      • Declaring variables by using built-in data types
      • Assigning values to variables
      • Converting existing variables from one data type to another
      • Creating and using your own data types

      • Statements and Exceptions

        • Introduction to Statements
        • Using Selection Statements
        • Using Iteration Statements
        • Using Jump Statements
        • Handling Basic Exceptions
        • Raising Exceptions
        • Describing the different types of control statements
        • Using jump statements
        • Using selection statements
        • Using iteration statements
        • Handling and raising exceptions

        • Methods and Parameters

          • Using Methods
          • Using Parameters
          • Using Overloaded Methods
          • Creating static methods that accept parameters and return values
          • Passing parameters to methods in different ways
          • Declaring and using overloaded methods

          • Arrays

            • Overview of Arrays
            • Creating Arrays
            • Using Arrays
            • Creating, initializing, and using arrays of varying rank
            • Using command-line arguments in a C# program
            • Describing the relationship between an array variable and an array instance
            • Using arrays as parameters for methods
            • Returning arrays from methods

            • Object-Oriented Programming

              • Object Oriented Concept
              • Classes and Objects
              • Using Encapsulation
              • C# and Object Orientation
              • Defining Object-Oriented Systems
              • Defining the terms object and class in the context of object-oriented programming
              • Describing the three core aspects of an object: identity, state, and behavior
              • Describing abstraction and how it helps you to create reusable classes that are easy to maintain
              • Using encapsulation to combine methods and data in a single class and enforce abstraction
              • Explaining the concepts of inheritance and polymorphism
              • Creating and using classes in C#

              • Using Reference-Type Variables

                • Using Reference-Type Variables
                • Using Common Reference Types
                • The Object Hierarchy
                • Namespaces in the .NET Framework
                • Data Conversions
                • Describing the key differences between reference types and value types
                • Using common reference types such as string
                • Explaining how the object type works and becoming familiar with the methods it supplies
                • Describing common namespaces in the .NET Framework
                • Determining whether different types and objects are compatible
                • Explicitly and implicitly converting data types between reference types
                • Performing boxing and unboxing conversions between reference and value data

                • Creating and Destroying Objects

                  • Using Constructors
                  • Initializing Data
                  • Objects and Memory
                  • Resource Managements
                  • Using constructors to initialize objects
                  • Creating overloaded constructors that can accept varying parameters
                  • Describing the lifetime of an object and what happens when it is destroyed
                  • Creating destructors and using Finalizemethods

                  • Inheritance in C#

                    • Deriving Classes
                    • Implementing Methods
                    • Using Sealed Classes
                    • Using Interfaces
                    • Using Abstract Classes
                    • Deriving a new class from a base class and calling members and constructors of the base class from the derived class
                    • Declaring methods as virtual and override or hiding them as required
                    • Sealing a class so that it cannot be derived from
                    • Implementing interfaces by using both the implicit and explicit methods
                    • Describing the use of abstract classes and their implementation of interfaces

                    • Aggregation, Namespaces, and Advanced Scope

                      • Using Internal Classes, Methods, and Data
                      • Using Aggregation
                      • Using Namespaces
                      • Using Modules and Assemblies
                      • Using internal access to allow classes to have privileged access to each other
                      • Using aggregation to implement powerful patterns such as Factories
                      • Using namespaces to organize classes
                      • Creating simple modules and assemblies

                      • Operators and Events

                        • Introduction to Operators
                        • Operator Overloading
                        • Creating and Using Delegates
                        • Defining and Using Events
                        • Defining operators to make a class or struct easier to use
                        • Using delegates to decouple a method call from a method implementation
                        • Adding event specifications to a class to allow subscribing classes to be notified of changes in object state

                        • Properties and Indexers

                          • Using Properties
                          • Using Indexers
                          • Creating properties to encapsulate data within a class
                          • Defining indexers to gain access to classes by using array-like notation

                          • Attributes

                            • Overview of Attributes
                            • Defining Custom Attributes
                            • Retrieving Attribute Values
                            • Using common predefined attributes
                            • Creating simple custom attributes
                            • Querying attribute information at run time

                            • C sharp Security

                              • Code Based Security
                              • Role Based Security

                              • ADO .NET

                                • Database Technology
                                • Data Providers in .NET
                                • Connection to database
                                • Processing data
                                • Stored Procedures
                                • Database Transaction
                                • Database Locking
                                • Case Study

                                • .NET Remoting

                                  • Channels
                                  • Remoting Objects
                                  • Client
                                  • Server

                                  • MVC Essentials

                                    • Introduction to MVC?
                                    • Responsibilities of the Model, View and Controller
                                    • ASP.NET WebForms vs. ASP.NET MVC
                                    • Testability
                                    • Routing essentials
                                    • Creating your first ASP.NET MVC web Site
                                    • Configuration Options
                                    • ASPX vs Razor
                                    • Support for mobile and tablet
                                    • Visual Studio Tooling

                                    • Controllers

                                      • Controllers (and Asynchronous Controllers)
                                      • Action Methods
                                      • Working with Parameters
                                      • How actions are mapped to methods
                                      • Action Result Types & Helper Methods
                                      • Understanding Model Binders

                                      • Views

                                        • Responsibilities of a View and View Engines
                                        • Creating ASPX Views
                                        • Creating Razor Views
                                        • Strongly Typed Views
                                        • Html Helper methods
                                        • Creating your own HtmlHelper extension methods
                                        • Partial Views
                                        • Validation helpers

                                        • MVC Routing

                                          • Introduction and motivation
                                          • Building your routes
                                          • Route Constraints

                                          • MVC Models

                                            • Overview
                                            • Using Linq to Sql
                                            • Using Entity Framework
                                            • Extending Entities and adding business and validation rules