this is event is a special edition with an extreme line up and we will have 4 presenters:
Sinkovics Ábel: Strong Types in C++
Using stronger types has been discussed on multiple forums in the C++ community recently. This talk introduces this topic from a different angle and discusses how to use this technique in existing codebases.
· Porkoláb Zoltán: Traps and pitfalls of C++ migration
The C++ programming language has experienced major changes in the last decade. The C++11 standard introduced a large number of new language and library features, like move semantics, lambda functions, variadic templates, automatic type deduction, a variety of smart pointers, etc. The minor revision of C++14 has refined and many times – as with constexpr or lambdas – significantly extended these elements. Since C++17 we have among others standard file system, any, variant, optional, and even parallel STL. Although these changes made C++ more flexible and safe, we experienced that a number of these new programming elements are misused by the programmers. In this lecture we overview some of the most common programming mistakes connected with C++11/14/17 migration and make suggestions how to fix these problems.
· Czirkos Zoltán and Dobra Gábor: Non-intrusive polymorphism
Inheritance-based polymorphism is intrusive. While this seems fine, because we've been doing this all the time, it isn't. The derived class implements an interface that belongs to the client classes, because the interface describes the functionality that the client needs. However, the implementation code is part of another logical entity, thus the implementation class is intrusive. The requirement of a polymorphic type, by definition, comes from its use. There are no polymorphic types, only a polymorphic use of similar types.
In this presentation we elaborate on a generic type erasure class with behavior configurable at compile time. The polymorphic behavior is shifted to global functions, so anyone might implement them. This provides a non-intrusive interface for runtime polymorphism. Implementation classes are not required to override methods inherited from their base classes, they are not required to be inherited from any base class, they don't depend on their use at all. Proof of concept examples are visitors and an implementation of a class similar to std::function in only 30 code lines.
· Bjarne Stroustrup: C++20
We have a feature freeze for C++20. How will C++20 measure up to C++'s ideals? How do the features offered by C++20 serve the general themes of C++development, such as simplicity, generality, modularity, generic programming, and good use of hardware?
please keep in mind we have a limited number of spots due to this is a shared event with other parties.