Order and Covariance

This is a past event

87 people went

Details

This month we welcome Gašper Ažman back, to talk about identity ordering in C++, before and after C++20 (and why it matters) - and Stewart Becker, talking about Covariant Smart Pointers.

As usual, please also register on the SkillsMatter site so they will let you in!

https://skillsmatter.com/meetups/12101-c-plus-plus-london-may

***************

Agenda:

19:00 Intro & News : Phil Nash

19:10 Covariant Smart Pointers : Stewart Becker

C++ allows covariant types to be returned from derived classes' overrides of virtual functions. However, these have to be references or raw pointers. What if we wanted to use a type with a defined conversion, such as smart pointers? There is a way to solve this, and it's so easy that even I can implement it.

19:30 Break

19:50 Points of Order : Gašper Ažman

With C++20, orderings are finally getting a first-class post in the language. What are orderings, though? What are the basic best practices around them? What are they useful for? Where do they come from? What kinds are there? What do they represent? How do they play together? What are the representations of orderings? Is the current implementation so broken we'll just throw it out?

This talk will try to answer the above with a principled approach that explains both the mathematics of orderings and how we got where we currently are in the standard. It is the hope of the presenter to poke the audience enough to foster a discussion about missing features in the C++20 proposal, so that defects can hopefully be identified before C++20 ships.

20:xx Socialising

---

Gašper is a co-author of quite a few committee papers on ordering, who has, in addition, worked with Alex Stepanov enough to have argued about ordering with him. This talk tries to illuminate the reasons for default ordering to be included in Regular in Elements of Programming, and the way the idea evolved to its current manifestation. This talk endeavors to be your definitive talk about the background of operator⇔.