I have not touched C++ since before C++11 (!) and have learned my habits from modern java, python and now rust. Using this video as a springboard so I can quickly learn c++ for an interview... It's going to be an intense study, but I think I can try to map the type-safe & memory-safe attributes of rust by adopting these new language features and some type of coding style to recreate ownership principle in C++.
Morgan Stanley still has the best C++ programmers out there, under Stroustrup's leadership. BTW, he could have easily explained transform_reduce as map-reduce
In the heap. The vector is still created in the heap but it contains its elements directly, rather than pointers to the elements, so there is no need to call new for each element.
The problem with variant is that when I make a container of base class instances, usually it is either a) derived classes I do not know of or b) other templatized containers. Of course I am not going to forward specify a discrete set of those templatized containers so this variant semantics is 100% useless in my cases. I still have to deal with copy pointer mistakes and use after free issues and variant wont help
std::variant may have its use, but the argument about replacing normal vtable inheritance is weak. std::unique_ptr + std::make_unique or std::shared_ptr + std::make_shared remove the worry of freeing things. Sure, you make allocations, but unless the object is really trivial, you may have others within the object constructors that offset the saving. If sizeof(A) >> sizeof(B) in std::variant the size will be the one of the biggest object, within a vector (for an implementation which avoid allocations by using std::variant self storage). There is a local vtable generated by the compiler upon std::visit (check with godbolt), and obj->draw(...) is MUCH cleaner than the std::visit dances. There might be cases (very small, trivial objects ... or inlined object method calls within std::visit) where std::variant might be useful, but IMHO the argument of standard vtable based inheritance replacement is weak.
Sorry my mistake, they are being added to the schedule page: conference.accu.org/2018/schedule.html Not all have been uploaded yet, check back in a couple of days and they should all be there
@@Knuckler I feel like I'm taking crazy pills when I listen to C++ modernists sometimes. I mean variant is possibly the biggest single reason that OO was invented. Apparently they don't remember this. Variant is nothing but a glorified case statement. And one of the reasons OO was invented was because of exactly that, that you ended up with a bunch of case statements. And every time you add some new functionality, you have to go to every such case statement and figure out, what do I need to do for each of these cases. Unless it's very simple and unless it's a completely internal detail, it's crazy because you know have client code having to make these decisions. And, on top of that, he turns around and creates a class hierarchy of functors to get around the fact that he didn't create a class hierarchy to begin with, AND makes it all templatized so that it isn't explicitly typed. It's like some sort of bad joke to see if we get it.
This is faster because it saves 1 indirection and lots of memory for the shared pointers (at least 48 bytes per item on 64bit). Also the class hierarchy gets less dependencies which might be nice or irrelevant.
In addition to what Lothar said, also in the variant example the elements are faster to transverse since the elements (Circles and Lines) are next to each other. In the pointer example, the vector only contains the pointers, the objects they point to can be anywhere in memory.
@@llothar68 I think viewing those in terms of stacks and heaps is a very low-level point of view here. Variants is an attempt at providing sum types in C++. Smart pointers is an attempt at providing ownership semantics (similar to Rust's), a crude version of linear types.
@@Evan490BC Sorry i'm too old for this type esoteric bullshit. I stopped when they started to call simple down casting (to void as an extrem) type erasure. Everything in computers is explained much much better when you go to assembler level and then explain it from there. SmartPointers is not ownership, it's reference counting and nothing else. The ownership semantics are just one use case for it. I can put two different reference counters on the same object and provide an invoked when reaching zero that might do something totally different and it would still be legal C++. I think this is the main reason why people today can't program anymore.
Agree. To name a few: std::vector{1} vs std::vector(1); forwarding references; two phase lookup and the iostream library. I still prefer C++ over any other language mainly due to its low overhead.
![C++17 : The Biggest Traps - Nicolai Josuttis [C++ on Sea 2019]](http://i.ytimg.com/vi/mAZyaAo3M70/mqdefault.jpg)
![C++ Templates Revised - Nicolai Josuttis [ACCU 2018]](/img/n.gif)
Every update makes C++ easier & more comfortable. Thanks a lot for your introduction speech!
Getting closer to Python!
Won't the compilation take longer tho?
@@MN-sc9qs Yes, and Fortran is getting closer to LaTeX. What is this even supposed to mean?
I have not touched C++ since before C++11 (!) and have learned my habits from modern java, python and now rust. Using this video as a springboard so I can quickly learn c++ for an interview...
It's going to be an intense study, but I think I can try to map the type-safe & memory-safe attributes of rust by adopting these new language features and some type of coding style to recreate ownership principle in C++.
This was super interesting, thank you Nicolai.
Morgan Stanley still has the best C++ programmers out there, under Stroustrup's leadership. BTW, he could have easily explained transform_reduce as map-reduce
its beauty...
Great job gentleman
I love inline vary abbles.
not that fun in st peterburg right??
aweome, thanks champ :)
Glad you liked it!
beautiful.
awesomeness
wonderful
Wow
What happens if you have a static inline variable in a header, used in 2 libraries or a library and an app?
Your comment has been forwarded to the speaker :)
@@ACCUConf Oh thank you:)
How can I press like 12 times on this video ?
Did this new update to C++ caused any changes to its performance?
no operator new for vector elements.. does it create a variable on the stack or in the heap?
In the heap.
The vector is still created in the heap but it contains its elements directly, rather than pointers to the elements, so there is no need to call new for each element.
The problem with variant is that when I make a container of base class instances, usually it is either a) derived classes I do not know of or b) other templatized containers. Of course I am not going to forward specify a discrete set of those templatized containers so this variant semantics is 100% useless in my cases. I still have to deal with copy pointer mistakes and use after free issues and variant wont help
Well, he does specify that std::variant is supposed to be used with closed sets. Perhaps not the tool you need, but a good tool nonetheless.
Good talk!
why don't you use Lisp? and as mentioned by Andrei Alexandrescu in his talk from MeetingCPP, fix the if constexpr for the sake of humanity;
std::variant may have its use, but the argument about replacing normal vtable inheritance is weak.
std::unique_ptr + std::make_unique or std::shared_ptr + std::make_shared remove the worry of freeing things. Sure, you make allocations, but unless the object is really trivial, you may have others within the object constructors that offset the saving.
If sizeof(A) >> sizeof(B) in std::variant the size will be the one of the biggest object, within a vector (for an implementation which avoid allocations by using std::variant self storage).
There is a local vtable generated by the compiler upon std::visit (check with godbolt), and obj->draw(...) is MUCH cleaner than the std::visit dances.
There might be cases (very small, trivial objects ... or inlined object method calls within std::visit) where std::variant might be useful, but IMHO the argument of standard vtable based inheritance replacement is weak.
public link to slide deck?
All slides have been uploaded to the ACCU conference website under the 'sessions' tab.
conference.accu.org/2018/sessions.html ? i don't see any links to PDFs...
Sorry my mistake, they are being added to the schedule page: conference.accu.org/2018/schedule.html Not all have been uploaded yet, check back in a couple of days and they should all be there
C++ is too damn difficult
no its so easy
@@EDANAiRoNY1 you didn't gawk at the variant example? You must be a c++ expert.
@@Knuckler I feel like I'm taking crazy pills when I listen to C++ modernists sometimes. I mean variant is possibly the biggest single reason that OO was invented. Apparently they don't remember this. Variant is nothing but a glorified case statement. And one of the reasons OO was invented was because of exactly that, that you ended up with a bunch of case statements. And every time you add some new functionality, you have to go to every such case statement and figure out, what do I need to do for each of these cases. Unless it's very simple and unless it's a completely internal detail, it's crazy because you know have client code having to make these decisions.
And, on top of that, he turns around and creates a class hierarchy of functors to get around the fact that he didn't create a class hierarchy to begin with, AND makes it all templatized so that it isn't explicitly typed.
It's like some sort of bad joke to see if we get it.
How is variant/ visit better than smart pointers?
I would not say better, but using variant allows you to use the stack instead of the heap at the expense of using a compile time fixed set of types
This is faster because it saves 1 indirection and lots of memory for the shared pointers (at least 48 bytes per item on 64bit). Also the class hierarchy gets less dependencies which might be nice or irrelevant.
In addition to what Lothar said, also in the variant example the elements are faster to transverse since the elements (Circles and Lines) are next to each other.
In the pointer example, the vector only contains the pointers, the objects they point to can be anywhere in memory.
@@llothar68 I think viewing those in terms of stacks and heaps is a very low-level point of view here. Variants is an attempt at providing sum types in C++. Smart pointers is an attempt at providing ownership semantics (similar to Rust's), a crude version of linear types.
@@Evan490BC Sorry i'm too old for this type esoteric bullshit. I stopped when they started to call simple down casting (to void as an extrem) type erasure. Everything in computers is explained much much better when you go to assembler level and then explain it from there.
SmartPointers is not ownership, it's reference counting and nothing else. The ownership semantics are just one use case for it. I can put two different reference counters on the same object and provide an invoked when reaching zero that might do something totally different and it would still be legal C++. I think this is the main reason why people today can't program anymore.
Great features! The only problem is it is too late!
It's better than nothing. C++ is the King of Programming Languages.
😂😂😂yeah agree, i plan to learn Rust instead of c++ for boost my web projects.
Good list.. good to see C++ catch up with D language.. but still can't beat that
Wrong. Two words: TOOLS and LIBRARIES
c++ is such a mess
Just because it goes over your head doesn't mean it's a mess.
Agree. To name a few: std::vector{1} vs std::vector(1); forwarding references; two phase lookup and the iostream library. I still prefer C++ over any other language mainly due to its low overhead.
C++ is just playing catchup and adding complexity to the language. So glad languages like Rust and Go are going to replace it soon.
"Soon", meaning in the next 20 to 30 years, right?
Not Go. Go targets a different space. Rust, maybe.
yeah, soon.....
I wouldn't bet on Go but Rust? definitely.
No