What you'll learn

Design patterns using Qt 5 and C++
Creational patterns
Structural patterns
Behavioral patterns
IO Patterns
State patterns
State machine framework
Abstract Factory
Builder
Factory Method
Object Pool
Prototype
Magic Static
Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Chain of responsibility
Command
Interpreter
Iterator
Mediator
Memento
Null Object
Strategy
Visitor
Templates
Class construction
Memory managment
Smart pointers
Encapsulation
Qt property system
SOLID - Single-responsibility Principle
SOLID - Open-closed Principle
SOLID - Liskov substitution principle
SOLID - Interface segregation principle
SOLID - Dependency Inversion principle
DRY - Don't repeat yourself
KIS - Keep it simple
RAII - Resource Acquisition Is Initialization
Exception handling
Auto connecting signals and slots
Threading
Thread Pools
Qt Concurrent
Threading in Widgets
Threading in QML
Templates
Qt Template classes
Pointers in templates
QMake tricks
CMake tricks
Creating shared libraries
Using shared libraries
Loading shared libraries dynamically
Creating plugins
Loading plugins
Text Streams
Data Streams
Data Classes
Storing passwords
Controlling processes
Desktop services
QProcess in Widgets
QProcess in QML
Signal connection types
Disconnecting signals
Serializing objects
QML state

Requirements

Qt Core beginners with Qt 5
Qt Core intermediate with Qt 5
Qt Core Advanced with Qt 5
Qt Widgets beginners with Qt 5
QML beginners with Qt 5
Advanced level knowledge and experience with Qt
Advanced level knowledge and experience with C++

Description

This is an advanced course that covers design patterns using Qt 5 and C++. It is strongly advised you do not attempt this course until you have completed all the prerequisites -see my other courses on Udemy if you need a refresher.

In software engineering, a design pattern is a general repeatable solution to a commonly occurring problem in software design - a design pattern is not a finished application but rather a tool the developer can use across any software framework. Design patterns can speed up the development process by providing tested, proven development paradigms. Effective software design requires considering issues that may not become visible until later in the implementation. Reusing design patterns helps to prevent subtle issues that can cause major problems and improves code readability for coders and architects familiar with the patterns.

The goal of this course is to teach the student how to use design patterns in Qt 5 with C++ along with an understanding of issues specific to Qt 5. We will use a wide range of Qt technologies from Widgets, QML, sockets, server, threading, io, streams, processes, and the State Machine Framework. This course will cover traditional design patterns along with looking at common problems and solutions specific for Qt 5.

These videos are filmed live and unedited, the student will see every single step, mistake and correction - the result is the same as if sitting in a classroom watching in real time.

Who this course is for:

Advanced Qt C++ developers

Homepage: https://www.udemy.com/course/qt-5-design-patterns/

Download Part 01

Download Part 02

Download Part 03

Download Part 04

Click Here for More Tutorial