cppocl/training

C++ training material

C++ Unit Test Framework

Moved project here

training's Issues

Lesson 040 - std::deque

C++ provides a standard library, that includes many template classes, including containers.
deque is one of a variety of containers for storing a collection of values.

Add lesson 008 - conditions

Add basic training for conditional statements, if, else, if else and switch.

Add lesson 009 - loops

Add basic training for the loops, for, while and do while.
Also add advisor against using goto.

Lesson 030 - lvalue and rvalue

To understand some of the advanced features of C++, it is important to understand about lvalue and rvalue.

Lesson 023 - classes construction and destruction

classes are created and destroyed in various ways, and this covers the basics of the lifetime management of a class object.

Add lesson 006 - functions

Add basic training for writing functions.

Lesson 017 - typedef

It's possible to define alisases for types, and this explains how and why this is important.

Lesson 015 - constants and pointers

Pointers have already been covered, but its also possible to ensure the pointer addresses can be protected from change, and also it's possible to protect the data the pointer is pointing too from change.

Lesson 016 - function main

Function main has multiple options and needs a details explanation.

Lesson 012 - advanced use of pointers

There has been some training on a pointer, storing an address, pointer to dynamically allocated memory, but there are also more complex uses of pointers, which is covered here.

Lesson 013 - constant data

Variables can be read and modified, but sometimes it's important to have values that always remain constant.
This can be done with constant variables or enumeration.

Lesson 036 - std::map

C++ provides a standard library, that includes many template classes, including containers.
map is one of a variety of containers for storing a collection of values.

Lesson 018 - union

The union construct is similar to the struct but the data shares the same address space.

Add lesson 004 - pointers

Extend the training on the existing data types and structures to teach pointers and memory addresses.

Lesson 021 - auto data

C++ provides the auto keyword to allow the language to select the correct type for you.
This can be helpful in reducing the amount of typing done, or reducing time looking up return types for functions, but there is also the cost of sometimes not knowing what type you are dealing with,

Add Lesson 002 - data types training example

Add C++ primitives and standard integer types examples with some comments.

Lesson 038 - std::multimap

C++ provides a standard library, that includes many template classes, including containers.
multimap is one of a variety of containers for storing a collection of values.

Lesson 025 - class overloaded operators

It's possible to make a class object look and feel similar to a primitive C++ type such as an int.
This can be done by writing your own operators like + or = or ==, etc.

Add lesson 005 - references

Lesson for working with reference variables.

Lesson 010 - arrays

It's possible to have a sequence of values of the same type, and this lesson will provide examples and explanation about the subject.

Add lesson 007 - operators and precedence

Working with operators and operator precedence is crucial to avoid introducing problems and also understanding how the compiler resolves ordering of statements.

Lesson 024 - static member functions

classes can have static member functions, that can be used as helper funtions without changing any of the variables within a class.

Lesson 029 - exceptions

Critical errors can be dealt with by using exception handling.

Add lesson 001 - Hello World

It's the obvious introduction to any language, but hello world is the defacto place to start.

Lesson 035 - std::list

C++ provides a standard library, that includes many template classes, including containers.
list is one of a variety of containers for storing a collection of values.

Lesson 039 - std::multiset

C++ provides a standard library, that includes many template classes, including containers.
multiset is one of a variety of containers for storing a collection of values.

Lesson 031 - function templates

It's possible to write a function with any data types, and this lesson is an introduction into how function templates work.

Lesson 033 - class templates specialised

It's possible to specialise classes for specific data types, and this lesson provides examples of how this is done.

Lesson 014 - constants and references

References have already been covered, but it's also possible to use constant references, which are an important part of writing safe code.

Lesson 022 - classes

One of the most powerful and widely used features of C++ is classes and inheritance, and this lesson will be an introduction into what classes are about.

Add lesson 003 - data structures

Lesson 3 will provide examples of data structures.

Lesson 020 - casting data

Sometimes data stored in variables needs to be converted to other types, and this lesson will provide details on how this is done.

Lesson 026 - class inheritance

classes can inherit functionality from other classes, but it's also important to know when to inherit or when to have something as a property.

Lesson 037 - std::set

C++ provides a standard library, that includes many template classes, including containers.
set is one of a variety of containers for storing a collection of values.

Lesson 032 - class templates

It's possible to write a class with any data types, and this lesson is an introduction into how class templates work.

Lesson 027 - polymorphism

Inherited classes can also be made polymorphic with the use of virtual functions.

Lesson 011 - pointers and dynamic memory.

The first lesson on pointers was a simple example on how to store the address of a local variable and use a pointer to inspect or change the local variable through a pointer.

This lesson extends on the first lesson, by showing more useful ways in using pointers, but also dynamically allocating memory that can be used and the freed later, without the need to have another local variable.

Lesson 034 - std::vector

C++ provides a standard library, that includes many template classes, including containers.
vector is one of a variety of containers for storing a collection of values.

Lesson 019 - signed and unsigned integers

When dealing with mixing signed and unsigned integers, care needs to be taken to understand the rules of how C++ prmotes types, but also how the language deals with the wrapping of values.

Lesson 028 - namespaces

Namespaces allow functions or classes to be separated from other functions or classes with the same name.