Centros Comunitarios Inteligentes

C++ Essentials Part 1 (CPPE1)

CPPE1: Module 0 Installing and using your programming environment

• What is an IDE?
• How to choose an IDE.
• Edube Interactive® (EI) – an online alternative to a standalone IDE.

CPPE1: Module 1 Introduction to Computer Programming

• Natural language vs. programming language, elements of a language.
• Machine language, compiler and compilation, linker and linking.
• “Hello world” – your first C++ program.
• Integer, floats, and their literals.
• Declaring variables – types, names, and initializations.
• C++ keywords – what are they for?
• Comments in C++.
• Arithmetic operators, priorities and bindings, building expressions, using shortcuts.
• The char type, fundamentals of ASCII encoding, character literals, escape characters.
• Conditional operators, the bool type and its literals.
• Taking control over the execution flow – the if-else instruction.
• Basic input/output facilities: cin and cout streams, manipulators.
• Basic data type conversions and the static_cast operator.

CPPE1: Module 2 Advanced flow control and data aggregates

• Extending if instruction capabilities with the else clause, nesting conditional instructions.
• More int and float data types: long, short, unsigned, double, and long double.
• Numerical anomalies – why floats can be so untrustworthy.
• Loops – why do we need them and how do they simplify a programmer's life?
• The while, do and for loops – similarities and differences.
• Some simple algorithms and their implementations.
• Controlling the execution flow inside loops – the break and continue instructions.
• Computer logic basics, bitwise and logical operators, dealing with a single bit's state.
• Branching the execution flow: the switch-case-default instruction as an alternative to the if-else cascade.
• Vectors – when do we need them and why can't we live without them?
• Declaring, initializing and using one-dimensional vectors, the indexing operator, basic vector methods.
• The vector template vs. obsolete array declarations.
• Multidimensional arrays – declaring, initializing, and indexing.
• Structures, their concept, role, and sphere of application.
• Declaring, initializing and using structures, building vectors of structures.

CPPE1: Module 3 Extending expressive power: pointers, functions, and memory

• C++ pointers: the concept, role, and purpose.
• Declaring, initializing, and assigning pointers, the nullptr symbol and its role.
• The reference, dereference and sizeof operators.
• Pointers vs. vectors º similarities and differences.
• The arithmetic of pointers, comparing pointers.
• The function – what it is and how functions help the programmer to keep the code clean.
• Declaring, defining, and invoking functions – parameters vs. arguments and results, the void type and its purpose, side effects.
• Passing parameter conventions: by value, by reference, by pointer.
• Default parameters: declaring and using.
• Function prologue and epilogue, function inlining, inline functions, overloaded functions.
• Writing and testing functions of varying complexity.
• The ternary operator and its usage.
• The Bubble sort algorithm and its sample C++ implementation.
• Memory on demand – the new and delete keywords.

CPPE1: Module 4 Accessing different kind of data

• Arrays of pointers: their purpose, declaring, initializing, and using.
• Automatic vs. implicit data type conversions – typecasting, accuracy, precision, and promotion.
• C++ strings – concept and implementation, string literals.
• Declaring and using strings: required includes, initializations, string operators, reading strings from cin.
• Comparing strings using built-in C++ operators and with the help of strings member functions.
• Dealing with strings: extracting sub-strings, determining the string's length and actual size, comparing substrings, finding sub-strings inside strings, controlling the string's size, appending a string/character to a string, inserting a string into a string, etc.
• C++ namespaces: concept, role, and purpose.
• Introducing, using, expanding, and renaming user-defined namespaces.
• Anonymous vs. named namespaces.

C++ Essentials Part 2 (CPPE2)

CPPE2: Module 1 The essentials of Object-Oriented Programming (OOP)

• Basic concepts of OOP: identifying objects in real life, classes, subclasses and superclasses, inheritance, class objects, object attributes and activities.
• Procedural vs. object approach: how the objective approach neutralizes some of procedural threats?
• Implementing a sample integer stack using procedural and object approaches in order to demonstrate the main OOP techniques and tricks.
• Anatomy of the class: class components, behaviors, and traits.

CPPE2: Module 2 Inheritance

• Class hierarchies: classes, subclasses, and superclasses, class diagrams, overriding.
• How inheritance works and how to express interdependencies of classes in C++ code.
• Polymorphism – concept and implementations in C++.
• Class constructors and destructors – defining and using, default as well as implicit and explicit copying constructors.
• Access specifiers vs. inheritance.
• Virtual and non-virtual methods.
• Passing objects as function arguments.
• Static class components and how to access them.
• Objective dynamic typecasting – static_cast vs. dynamic_cast operators.
• The const keyword and how it affects class behavior – const variables, structures, pointers, member function parameters and results, class fields.
• The friend keyword – friend classes and functions in C++.

CPPE2: Module 3 Exceptions

• Introduction to exceptions: concept and rationale, required includes.
• The try-catch instruction, its variants and behavior, handling different classes of exceptions.
• The throw instruction, creating exception objects, the noexcept clause.
• The explicit specifier and how it affects class behavior.
• C++ exception categories and hierarchies, distributing exception handling, branching and ordering catches, the what() function.
• Defining, throwing, catching, and using user-defined exceptions.

CPPE2: Module 4 Operators and enumerated types

• Overloading operators in C++ – concept and limitations.
• Introducing user-defined operators into C++ code: syntax conventions and operator behavior.
• Possible techniques for operator overloading as well as prohibited practices.
• Defining a sample set of operators for the LIFO class.
• An overview of overloadable C++ unary and binary operators.
• Implementing a sample fraction class with a set of dedicated operators.
• C++ enumerated types: the idea and its purpose.
• Declaring user-defined enumerated types and how to deal with them.