Course outline

Basic notions:

  • What is a computer, computer command, an application and a programming language? The evolution of these notions.
  • Computer program execution detailed analysis: describing roles of operating system, drivers, CPU, memory, bus, keyboard, mouse, and other components
  • The differences between high and low-level programming languages (machine code, assembler, C, C++, Java, SQL, HTML).
  • How to start to write a program. Text editor, compiler, linker.
  • IDEs (Integrated Development Environments).

Getting started:

  • Explanation of previous program code line-by-line.
  • The preprocessor - program entry point.
  • Introducing first coding rules. Errors, how to deal with them.
  • Data types (size, range), declaration of variables. Naming rules, code readability, and good coding style.
  • The stack (LIFO queue). Variables visibility and life duration. Global and local variables. Bad coding style - using global variables. Visibility extension operator “::”.
  • Variables and constants, a difference between initialization and assignment.
  • Binary, decimal and hexadecimal formats.


  • "Hello, world!" program.
  • How to receive data from user input and show it. User dialogue.

The first tools:

  • The notions of operator, expression, and instruction. Correct terminology usage importance for successful interview passing.
  • Arithmetic operators, comparison operators, and rules of their usage. Signed and unsigned types. Explicit and implicit type cast. Post- and pre-increment. Priority and associativity. Conditional operators (if, else if), ternary operator, switch (fall through concept).
  • Loops: for, while doing while. Nested loops (i,j,k counters order).
  • Debug: How to trace a program execution, breakpoints, F5, F10, watches.


  • A few questions from the interviews.
  • A simple calculator. Examine the ability to process any user input.
  • How to reduce the number of possible errors. The first design concept of cross-platform application.
  • Shapes drawing: filled, empty, with defined borders thickness, rectangles, triangles, rhombus.
  • How to display text in the middle of the rectangle. Screen positioning
  • Several shapes in a row.
  • Simple animations (moving shapes), getch(), the first tool to obtain the required information.
  • Find and process specific numbers in the range.
  • The first program 'Drawing', which could work eternally; it must show menu, draw any shape by user's choice or terminate.

Arrays, pointers, references, algorithms:

  • Stack-based array, its size, index, size of () operator, array initialization.
  • Pointers, how does iArray[i] expression actually works, what means the pointer type for a compiler. Dynamic memory allocation, heap, new, delete, delete[] operators. All pointers related nuances: uninitialized pointers, hanged (forgotten) pointers, memory leaks (and tools to detect it). Pointer to everything - void *.
  • References, differences between them and pointers.
  • Sort, search and comparison algorithms, their performance. The Profiler. Compile and runtime errors.
  • Dynamic arrays (that can change size at runtime). Multidimensional arrays. -


  • Algorithms: search, search minimum value, maximum value, count items, sum, average.
  • More complicated algorithms: work with multidimensional arrays, histogram creation, matrix rotation. How to look ahead from the current position in the array.
  • Several sorting algorithms with analysis of their performance.
  • First game: tick-tack-toe. Description: User will have the option to choose '0'-s or 'X'-s and set how much rounds to play. The program should determine the winner of the current round and keep the total number of wins, draws, and defeats.
  • The program also should be protected from user's errors (with an explanation of them), have a good usability and interface. Advanced: use colour for text output.


  • Why do we need functions?
  • Passing function arguments by value, by address, and by reference.
  • First look at the application address space, and executable file format, a cost of the function call.
  • Functions overloading, default parameters.
  • Recursion, call stack, stack overflow, integer overflow.
  • Pointers and const modifier: a difference between constant pointer and pointer to constant.
  • A good coding style. Why it is so important.


  • Algorithm performance measurement. How to get reasonable accuracy.
  • Some tasks from the interview (recursion usage).
  • Rewrite Tick_tack-toe, Calculator and Drawing applications using functions.


  • A console application, system buffer and keyboard interrupt.
  • Library functions: strcmp, strlen, strtok_s, strstr.
  • How to format text output (in c and c++), cin.getline.
  • char and wchar_t, zero terminated string. Dynamic array of strings.


  • Create auxiliary functions to protect your app from user's wrong input:
  • prevent entering chars instead of digits;
  • prevent entering more symbols than buffer capacity;
  • be ready for extra-large text input
  • How many times a given word present in a sentence?
  • The user enters any number of sentences, application parses them, creates an array of words from those sentences, counts a number of words, finds the longest and the shortest, sorts words by length and alphabetically.
  • Create "scrolling text string" app with the option to suspend the cycle and update the content.
  • Advanced: Implement word-wrap algorithm.

Bitwise operations:

  • Operators &, |, ^, ~, !, <<, >>. -


  • Store in one integer variable four numbers from different ranges (0-5, 0-100, 10-60, 100- 40000).
  • Show binary representation of integer value
  • What is the biggest number can be stored in 1 byte?
  • Raise 2 to the power of 200.
  • List all logical drives of PC.
  • Encrypt and decrypt entered text.

Structures, enumerations, unions, bit fields:

  • What are user-defined types. Differences between С and С++. First acquaintance with object-oriented programming.
  • Universal storage for every data type.
  • enum as a compact declaration of related constants.


  • How to use unions to send and receive data any type.
  • Develop app "Students" to store and process personal data. The "Student" structure (data store) have to have following fields: name, surname, age, 5 marks (array), average mark. Implement simple operations with an array of objects: search, sort, add, delete, edit. Create an algorithm for automatic initialization of the array of structures (including names). You will enter array size from the keyboard. Advanced task: sort and show data using pointers to structures, not objects itself.

Preprocessor directives:

  • How and where must be defined critical restrictions, constants.
  • How to include compilation units from the same or different places, preventing from including a file several times.
  • Memory classes: extern, static, register, auto.
  • Static variables in functions and files.
  • Conditional compilation. Cross platform development.
  • Using # and ## operators in debugging.
  • Macros: how to write a macro, pro, and contra, and how to write convenient unit tests.


  • Create several *.h and *.cpp files and link them correctly.
  • Write a macro for performance evaluation of any statement.


  • The role of the operating system, drivers, and application in IO operations references accounting, file operation modes.
  • What types of file-related errors should be checked in a production application.
  • Read, write and positioning operations. File size and format. Buffered output.
  • Differences between text and binary file opening modes. Which one should be used.


  • How to explore drives content and directories.
  • How to copy a big file.
  • Write to file encrypted data of any format. Read it, decrypt and show.
  • Create an app like a reminder (diary, organizer). Description: The user enters some information and sets the time to remind about it. Once the user launches this app, it checks the current date and time, looks through all records stored in a file. If there is something to remind at this time it displays a reminder message.

Course project:

  • A simple file manager that can search and display the contents of every file (as is, without recognition of file format), and edit certain files. The student should develop his own file format for data storage and processing - a big array of structures 'Student' (see description above in practice section of the Structures).
  • Advanced complexity: Add field 'experience' to 'Student' structure (an array of characters in heap) and its length. Not all students have the experience, it should complicate file format.
  • The program must have a user-friendly interface and operate in two modes:
  • Create a file and find it in the file system.
  • open, read, add or delete a record, edit it, sort the data, based on their various criteria specified by the user.
  • Working in any mode, the user should be able to see the context menu. The app must be protected from any user errors and not have any kind of memory leaks (heap memory, descriptors).

C++ advanced

Course duration: 120 hours Function pointers:

  • Usage of the function pointers as search and comparison criteria, which can be passed as arguments to search or sort algorithms. Predicates.
  • Adapting your functionality to existing interface, for example: sort any arrays using the qsort_s function. Callback functions, typedef.
  • How to extend the functionality of your program without recompiling it. Cost of extra QA work.


  • Sort 'students' (see base course practice) by several criteria received at runtime.
  • Rewrite 'Calculator' app using an array of function pointers.

Template functions:

  • Type deducing, typecast and function arguments, template function overloading.
  • Non-type parameters.


  • Develop an app that sorts arrays of ints, chars, and doubles using template functions.

Functions with variable (undefined) number of parameters:

  • The role of the first parameter, format specifiers, VA_LIST.


  • Develop a “mini printf” function.

Classes (base concepts):

  • Philosophy of class design and usage.
  • Constructors, destructors, overloaded constructors, the class interface as a set of rules to work with him...
  • How to trace all calls to class functions in the program.
  • Default class function functionalities and how to disable it.
  • Composition: aggregation and acquaintance, an interaction diagram, UML.
  • Initialization rule. How to work with resources. this, public, private.
  • A preprocessor #ifndef and compiler-dependent #pragma directives. What is a c++ standard; Class A has an object of B class, but class B has a pointer to A - how to resolve this. Friends: How a function or class can become friends to another class. Relations between 'friends'.


  • Develop Array and Line classes.
  • Another tool: class BackUp, that can be used by any client to safely rewrite any file, and safely retrieve a data (a proxy between a client and a file);

Copy constructor and operator overloading:

  • When do you need these tools? Shallow and deep copy.
  • How to copy an object that has another object inside.
  • Explicit constructors.
  • Built-in and user-defined data types. Operator overloading rules.


  • Overloading of +, =, <<, (typecast), *(indirection), new, ++, <, == and [] operators.

Linked list, template classes, introduction to STL:

  • How linked list works. Difference between list and array, comparison of their performances.
  • What are CPU cache levels, cache hit, and cache miss. Why linked lists are rather bad than good.
  • Introduction to STL: containers, iterators.
  • Template classes: *.hpp files, constructors based on other classes objects.
  • Using operators overload in templates. Templates specialization.


  • Develop stl-like List class.

Usage the 'const' modifier in classes:

  • const_cast, mutable, difference between the 'real constant' and read-only field.
  • const member functions.


  • Develop a class with const members;

Static class members:

  • Private constructor, how to count all objects of a class. What is a pattern? Singleton pattern. How it should be designed not to be an anti-pattern.
  • Static member functions.
  • Introduction to smart pointers, overload of -> operator.
  • Pointers to class members.


  • Count the number of all objects in the class.
  • Develop a simple SmartPtr class.

Inheritance and polymorphism:

  • Protected class members, private and protected inheritance.
  • Initialization of the child object.
  • Work from the pointer to the base class. New UML symbols.
  • Virtual functions, destructor, abstract base class, interface, vptr, vtbl
  • Static and dynamic binding, static_cast, dynamic_cast, typeid, RTTI.
  • Difference between inheritance of the functionality (and data) and interface inheritance.
  • When a virtual destructor is a bad solution. ABI - Application Binary Interface.


  • Create class hierarchy, check member's visibility from class and from the object.
  • Patterns: Bridge, Abstract Factory, Adapter, Visitor, Decorator.
  • Some questions from interviews.

Dynamic data structures. STL, BOOST:

  • STL containers: vector, list, set, map, deque, stack, unordered_set. Nuances of work with them. std::shared_ptr, make_shared(), std::unique_ptr.
  • Algorithms, functors, function adapters: find, copy, find_if, remove, equal_to, bind2nd and so on.
  • Namespaces. Big O notation.
  • BOOST: how to compile its libraries and include them in a project. shared_ptr, weak_ptr, make_shared, bind, and so on.


  • Work with all main containers and algorithms.

Exceptions handling:

  • The architecture of a program with exception handling.
  • Rethrowing exceptions, catch (...), stack rewinding sequence and rules. The lifetime of the thrown exception object. dynamic_cast<>.


  • Pattern 'Chain of Responsibility'.
  • A partial description of the diploma project 'Online store’ (without threads, libraries, and networking).

C++ 11:

  • Lambdas, auto, rvalue, movable constructors and assignment operator. std::move(), decltype, uniform initializer list, nullptr.


  • Check the conditions under which the performance of move constructor will be better than copy constructor does.

Multiple inheritances:

  • Another implementation of the Adapter pattern.
  • Virtual inheritance, differences between compilers. The parts of the object.
  • Why C# and Java allow multiple inheritances from interfaces only.
  • The basics of the COM technology: IUnknown, QueryInterface, the component registration, GetClassObject, regsvr32, CLSID.


  • Check pitfalls of the typecasting from void *.

Dynamic and static libraries:

  • How to export functions and classes from the library. How to include them in a project.
  • Explicit and implicit linking, debug.
  • Design of a cross-platform application.


  • Use libraries in your 'Online store' project.
  • The notion of a version control systems. Git.

GUI applications using Win32 API. Qt GUI.:

  • What is the difference between console app and window app. Infinite loop, messages, window procedure, differences between SendMessage and PostMessage functions? Resource file *.rc.
  • How to create a custom window and define a custom message.
  • How to work with controls: BUTTONs (radio, check, group box), COMBOBOX, EDIT, etc. (including Qt).
  • InitCommonControls Function.
  • Events and slots in Qt. How to subclass a window (replace a window procedure) (incl. Qt), shifting the viewport in the window. Creating the user control, OWNERDRAW style.
  • Compatible HDC.


  • Create three versions (each one extends the previous version) of a 'VectorDraw' app, that draws simple shapes and stores them into a picture using vector graphics principles. Develop a file format and program architecture (using polymorphism) to achieve backward compatibility.

Processes and threads:

  • Users and OS address spaces. Kernel's objects.
  • When should you use threads and what number of them can speed up your program. Thread's context.
  • Threads, volatile and compiler optimization.
  • Threads (and processes) synchronization using Win32 API. Mutexes, events, semaphores, waitable timers. WaitForSingleObjects and others. The family of atomic Interlocked- functions. In what order mutexes must be unlocked?
  • TLS (thread local storage). Re-enterable and thread-safe code.
  • Processes: priority, preemptive multitasking, how child process inherits handles.
  • IPC (interprocess communications), memory mapping, pipes, shared sections in the library.
  • Functions for virtual memory, a snapshot of processes, threads, libraries.
  • Threads synchronization using c++11 and boost. std::thread (difference from boost::thread), mutex, lock_guad, condition_variable, unique_lock, boost::chrono.


  • Application description: A console application wants to speed up some work. You should create and initialize in the ‘main’ and int array, divide it to parts depending on a number of CPU's kernels. Start the same number of threads and give them their parts of data. Meanwhile the ‘main’ continues to do its job and wait for threads. Show the data in the ‘main’.
  • How to synchronize the following queue: One input thread sends ordered sequence of data structures to three worker threads. They do the same job but the time to process, any object can be different. Worker threads process objects and give them to one output thread to reassemble data sequence in a previous order. GUI thread shows data.
  • How to create a custom message queue. WAIT_TIMEOUT.
  • How to use a window to post a message to a thread.
  • How to use TLS.
  • How to use atomic functions.
  • How to redirect output from console application to another process - the same thing as IDE does when it launches a compiler.
  • C++11: usage of thread, mutex, condition_variable, lock_guard, unique_lock classes.
  • What libraries are used in the application and where they are?
  • The interiors of DllMain. How to block it, how to use it.

Network applications:

  • Protocols (IP, TCP, UDP, HTTP), sockets, blocking and nonblocking calls using the winsock2 library. select, WSAAsyncSelect, WSAEventSelect.
  • TCP connection states and errors handling.


  • Simple echo server.
  • Networking version of Tick-tack-toe.
  • Mini Git.

Diploma project 'Online store':

Client-server application: one server, one client to purchase products, several clients to buy them. At first server able to sell only two product categories. The application should have the ability to add plug-ins - libraries with classes to work with some other product categories. The app must recognize its very first launch to set start-up capital to begin its work (purchasing products).

The server starts its work by parsing current directory to list plug-ins (libraries). When it discovers a new library, it has to be able to work with new product category without recompilation. The app has to support cross-platform architecture: every platform dependent routine (resources, hardware) should be separated from logic.

The app has to be protected from user’s and network errors

Program taught in:

See 3 more programmes offered by Infopulse University Ukraine »

This course is Online
Start Date
720 USD
24 sessions, 2.5 hours, 2 times a week
By locations
By date
Start Date
End Date
Application deadline
Application deadline
End Date