Course cost: $300 / month
Course duration: 2 months, 45 astronomical hours
Course start date: September 23, 18 lessons of 2.5 hours (Monday, Tuesday)
Course entry requirements: knowledge of topics covered in C++ Programming Fundamentals course.
*The course is available in the following languages: English, Russian, Ukrainian
Course duration: 2 months, 45 astronomical hours
Course start date: September 23, 18 lessons of 2.5 hours (Monday, Tuesday)
Course entry requirements: knowledge of topics covered in C++ Programming Fundamentals course.
*The course is available in the following languages: English, Russian, Ukrainian
Professional programming using C++
Course program
Function Pointers
GUI - window applications on the example of Win32 API and Qt
- Adaptation of interfaces, callback functions, typedef.
- How, when adding new fields to a structure (or inheriting from it), add the ability to sort these structures by these new fields without recompiling the sorting algorithm. (that is, how not to create extra work for yourself in the future). predictive functions.
- How to use an existing foreign algorithm (interface) to process your own data types.
- Rules for defining type parameters, the possibility of type casting, overloading.
- Why the first parameter is needed, working with different types of parameters.
- The rule for initializing class members, default functionality and their prohibition, constructors, destructors, resources and the principle of working with them, how an object can identify itself among others - this. public, private, the presence in the class of objects of another class or pointers, the lifetime of interacting objects, composition - awareness and aggregation.
- How can a function or a class become a friend of another class.
- Relationships between friend classes, preliminary announcement.
- How to avoid cross-references and repeated type declarations, directives #ifndef, #pragma.
- Is it always needed, shallow and deep copying, how to copy an object inside which there is an object of another class.
- Calling constructors, destructor, overloading.
- Congestion rules. Use in templates. Diagnostics.
- What is a real constant and readonly field. volatile (threads and compiler optimizations).
- Whether it is necessary to change a constant and how to work with constant objects.
- How to prohibit the creation of an object on the stack, counting objects of a given class, what to do if there should be only one object of a certain class in a program.
- Inheritance
- The difference between feature extension and interface inheritance.
- How the child object is initialized.
- Work from under the pointer to the base class. protected class members and private, protected inheritance.
- Virtual functions, destructor, abstract base class, interface, vptr, vtbl, early and late binding, virtual function call mechanics. dynamic_cast, typeid, RTTI. In what cases the virtual destructor will not rescue.
- What is ABI (Application Binary Interface). Data alignment (alignment).
- Design patterns
- Implementation and use of patterns: Bridge, Abstract Factory, Visitor, Observer, Decorator, Chain Of Responsibility, MVC, Singleton, Adapter, Builder.
- hpp files, copy constructor based on other type parameters.
- Specialization of templates.
- Linked lists, trees, queues, stack, writing your own Tree class.
- Creating your own List class that supports the STL interface (iterators, operators, member functions).
- Containers: std::vector, list, deque, map, set. Working with iterators when resizing a vector. std::vector with object pointers. hash, algorithm comparison (Big O Notation).
- Algorithms: find, copy, find_if, remove, equal_to, bind2nd, etc.
- Namespaces.
- Getting to know BOOST (how to compile it and set up a project), boost::bind, the entire smart_ptr library.
- boost::thread(mutex, condition_variable, lock_quad, unique_lock), chrono, filesystem.
- Handling Exceptions
- The architecture of the program that uses exceptions.
- Throwing exceptions, catch(...), catch(BaseExceptionClass &), stack unwinding rules, lifetime of the thrown exception object.
- smart pointers
- std:: and boost:: shared_ptr, weak_ptr, make_shared, auto_ptr, std::unique_ptr.
- Introduction to the QtCreator IDE. lambdas, reference to rvalue and movable constructor (also copy, assignment), auto, noexcept, std::thread, std::lock_guad, std::move()
- Virtual inheritance, differences between compilers.
- COM basics: IUnknown, QueryInterface cast rules, regsvr32 component registration, CLSID.
- Interface and adapter classes.
- Connecting to the project, command line gcc (g++) compiler. .dll, .lib, .so, .a, explicit and implicit binding, export of functions, classes, export of interface (abstract class), debug.
GUI - window applications on the example of Win32 API and Qt
- Perpetual loop, messages, window procedure, Send-PostMessage and their differences.
- Work with controls: BUTTONs (radio, check, groupbox), СOMBOBOX, EDIT, etc. What are events and slots (particularly in Qt) replacing a window procedure, moving the drawing start point, creating your own control, OWNERDRAW.
- Address space, synchronization on the example of Win32, std:: and BOOST.
- List of processes, mutexes, semaphores, events, waiting timers, communication between processes, boost::thread, (comparison with std::thread), TLS, condition_variable, lock_quad, unique_lock.
- Sockets, protocols (TCP, UDP), blocking and non-blocking modes.
- Creating a database, tables, queries - multi-table, nested, aggregation functions, foreign keys, stored procedures.
- Creating a plugin that allows you to add new functionality to an existing program.
- The program supports cross-platform at the source level - all work with resources ("iron") is allocated to separate replaceable blocks specific to a particular platform.
Sign up
Please fill out the form. Our managers will contact you shortly.
