As part of today’s VS 2013 launch, in addition to the live talks and Q&A we also have some recently recorded talks that are now also live. My talk is a quick 20-minute tour of the new ISO C++ conformance features in VC++ 2013 — nothing I haven’t said before, so if you’ve seen my last two Build talks you’ve seen this material, only here I’ve condensed it to a distilled two-minute overview of each feature using examples.
Here they are, each between 4 and 20 minutes long. Note that these are just the (V)C++-specific topics — be sure to look at the Related Videos of each to see other new features that light up for C++ as well as for other languages.
ISO C++ Additions in Visual C++ 2013 (Herb Sutter)
ISO C++ received a major upgrade with the latest standard, adding many features that make the language both simpler and more powerful. Visual C++ 2010 and 2012 have already implemented a number of these features, from auto to range-for to lambdas. In this video, Herb Sutter reviews the additional ISO C++ standards conformance improvements in Visual C++ 2013, and how each of them contributes to making modern C++ code clean, safe, and faster than ever.
What’s New for C++ Developers in Visual Studio 2013 IDE (Jennifer Leaf)
Visual Studio 2013 includes several compelling new features for C++ developers. In this video, you’ll learn about IntelliSense improvements, the new code formatting feature, and other changes that help you navigate through and write your code.
New Compiler Optimizations for C++ Applications (Jim Hogg & Ankit Asthana)
C++ developers will find many improvements in Visual Studio 2013 — including new versions of the compiler, linker and tools — that make code run faster. In this video we’ll cover C++ performance improvements, including better vectorization; permutation in the order of loop nests; better Profile-Guided Optimization (that now applies to Windows Store apps); a new vector calling convention; and more support for C++ Accelerated Massive Parallelism (AMP).
Debugging Improvements for C++ Developers (Brad Sullivan)
Introducing Visual Studio 2013 for Windows Developers Building C++ Apps (Raman Sharma)
Visual C++ in Visual Studio 2013 includes improvements for Windows App developers in the core language and libraries, as well in tooling, debugging and designers. This video will provide an overview of these new features in Visual Studio 2013 for C++ developers building Windows Store apps.
5 thoughts on “(V)C++ recorded talks at VS 2013 Launch”
tnx for the A…
BTW I wonder if maybe auto* when combined with const more expressive in a sense that you can stick 2 consts on pointers(if the ptr changes, if pointed to changes) but this is mostly trivia for me, so I dont even wanna try, to figure it out, but if somebody cares g++ compiles this:
const auto * const cptocv=p;
@nosenseetal: Using auto or auto* deduces the same type, just I guess auto* is mostly useful to explicitly say you want a raw pointer. Non-owning raw pointers are okay to observe an object that will outlive them, such as a tree node owned by its parent (via a unique_ptr(node), say) and observing its parent via a node*. I don’t have any more guidance than to say my impression is that it’s a style point whether you prefer code like “auto p = my_parent();” or “auto* p = my_parent();” — the type is the same in either case.
I was thinking about more of a small LRU cache, if you want to have flexible size you cant use contiguous “array” buffer because linear search will kill your perf.
and for delete this i kind of dislike it because it means ppl containing this class need to be aware of its suicidal :P aspirations. :)
BTW regarding that code:
auto * context = static_cast(response._get_server_context());
I have never before seen auto * before.(ignoring const I have seen only auto, auto&, auto&&)
Do you have any comment on using auto*?
@nosenseetal: I’m not sure a circular buffer would be ideal — we don’t want to lose weak_ptrs while there are outstanding shared_ptrs and the number of outstanding live objects is not known in advance.
As for ‘delete this;’, it is overused and dangerous in the wrong hands, but it can be appropriate for an object that controls its own lifetime and you know you won’t have pointers or references to it. In this case, just from the snippet you provided you can see the object is probably using intrusive reference counting and just implementing it by hand. I might prefer using standard smart pointers instead of reimplementing it by hand, possibly including using enable_shared_from_this if appropriate, but I haven’t inspected the code.
Herb this is offtopic, but regarding memory leak in your fav 10 liner…
seems like a job for:
Also I know you probably hate to comment on quality of MS code but do you have opinion is this an ok modern C++ code or it could be done cleaner:
if (–m_refs == 0)
I ask because you once said you havent wrote delete in years. :)
Comments are closed.