October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
By Adrien Hamelin | Feb 23, 2016 05:51 AM | Tags: intermediate
How to handle events?
Automatic event cleanup in C++
by Nercury
From the article:
Event subscriptions have a downside: someone has to unsubscribe. Usual approach is to make sure it happens when the subscibtion is no longer needed.
But, can we do it automatically, in a way that is easy to use and extend?
Let's see how it can be done in C++...
By Marco Arena | Feb 23, 2016 01:47 AM | Tags: None
A new post from the Visual C++ team about how VC++ has evolved in the past for supporting different characters sets, and what's new:
New Options for Managing Character Sets in the Microsoft C/C++ Compiler
by Jim Springfield
From the article:
The Microsoft C/C++ compiler has evolved along with DOS, 16-bit Windows, and 32/64-bit Windows. Its support for different characters sets, code pages, and Unicode has also changed during this time...
By Bjarne Stroustrup | Feb 22, 2016 03:27 PM | Tags: None
Over the years, there have been several suggestions and proposals for allowing programmers to define operator.() so as to be able to provide “smart references” similar to the way we provide “smart pointers.” I first considered that in 1983, but couldn’t solve the problem. In early 2014, Gabriel Dos Reis and I decided that now we really had to solve it: Too much code was getting too complicated and too ugly because of the lack of smart references. Operator -> is good for objects with pointer semantics, but we needed a general way of providing value semantics for a handle.
Operator dot differs from other operators by having its right-hand operand be a name rather than a value: for x.m, m is not the value of some variable it is the name of a member of some class. Ideally, dot would be a binary operator taking into account both x and m for x.m. Many have tried, including Gaby and I, but that quickly gets complicated. The current rules for operator->() and the proposed design for operator.() “solves” those problems by considering the right-hand operand only when looking for possible candidates. This allows composition of interfaces without requiring inheritance. If someone figures out a good and simple way of taking the member name into account in a more general form, we are reasonably sure that we have not proposed anything that prevents that. When designing, you must always try to avoid painting yourself into a corner by closing off possible evolution paths.
Historically, the key sticking point with the operator.() proposals has been how to distinguish operations on the reference object (the handle) from operations on the referred-to object (the value). The current proposal “forwards” every operation to the referred-to object unless that operation has been explicitly declared in the handle. This is simple and quite general. In particular, we can apply operators on a smart reference (e.g., ++r) and have ++ apply to reference is we so desire, but by default it is applied to the referred-to object (as it would for a built-in reference). The papers outline why we think that this is – by far – the design that best balances the needs of the various use cases. The focus is on allowing the user to define a class that is a reference, just like the built-in reference, except that it is “smart” in some way (e.g., it can have a rebind() member) analogously to the way a “smart pointer” is just like a pointer except that it is “smart” in some way (e.g., takes care of ownership). If you can define or use a smart pointer, you can define or use a smart reference.
The proposal has been quite stable. There have been proposals for alternatives and major extensions, but few suggested modifications. We tried to find a way to prevent a pointer (or reference) to the referred-to object to escape from the smart reference, but couldn’t find a simple way of guaranteeing that so we gave up, quoting “C++ protects against Murphy, not Machiavelli.” We ensured that you can define a matching set of smart . (dot), -> (arrow), * (dereference), and [] (subscript) operators with the relations they have for built-in types.
By Marco Arena | Feb 22, 2016 10:05 AM | Tags: performance basics
Is RAII in C++ only possible with exceptions? Eli Bendersky clarifies the matter:
C++: RAII without exceptions
by Eli Bendersky
From the article:
this post is not about whether exceptions are good or bad. What it is about is RAII as a C++ dynamic resource management technique that stands on its own and is useful with or without exceptions. In particular, I want to explain why RAII is indeed useful even if you have exceptions disabled in your C++ code...
By robwirving | Feb 19, 2016 08:57 AM | Tags: None
Episode 45 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Paul Miller to discuss C++ in the Visual Effects Industry.
CppCast Episode 45: C++ in the Visual Effects Industry with Paul Miller
by Rob Irving and Jason Turner
About the interviewee:
Paul Miller is a partner and lead engineer at Digital Film Tools/Silhouette FX. He has been writing visual effects and image processing software for over 20 years, and has been using C++ for most of that time. He started his love of graphics and digital music on the Amiga in 1986, teaching himself C with K&R and the Amiga ROM Kernel manuals. In 1992 he ended up Wisconsin, writing software for the relatively new digital post production industry on Silicon Graphics workstations, and has been writing widely-used tools for that industry since. He uses Qt for cross-platform UI, Python, OpenGL, and OpenCL extensively.
He holds a private pilot's license and enjoys going to movies and beer festivals.
By Felix Petriconi | Feb 18, 2016 09:13 AM | Tags: c++14 c++11 advanced
Bartlomiej explains in his recent blog post in nice details the SFINAE construct.
Notes on C++ SFINAE
by Bartlomiej Filipek
From the article:
This time I’d like to tackle a bit more complex problem: SFINAE. I’m not using this paradigm on a daily basis, but I’ve stumbled across it several times and I thought it might be worth trying to understand this topic.
What is SFINAE? Where can you use it? Do you need this on a daily basis? Let’s try to answer those questions.
In the article he goes into details of Overload Resolution, Where can I use it?, enable_if, Expression SFINAE, Any disadvantages?, and Alternatives to SFINAE.
By Meeting C++ | Feb 18, 2016 07:51 AM | Tags: qtdev intermediate basics advanced
A follow up on an older Blog post of mine:
Revisiting QWidgets & data, refactoring and performance
by Jens Weller
From the article:
My CMS project has grown quite a bit, and there are a few places where I think I should refactor the code. One of the larger ones is that TreeItem::get<T> returns a pointer instead of a reference. Another one is related to how the Qt UI application is acting when opening a new panel in the TabControl. There used to be a noticeable delay...
By Mantosh Kumar | Feb 16, 2016 10:47 PM | Tags: c++11
How to use std::async for task-based parallelism in C++11.
The promises and challenges of std::async task-based parallelism in C++11
by Eli Bendersky
From the article:
"Task-based parallelism" refers to a higher level of abstraction, where the programmer manages "tasks" - chunks of work that has to be done, while the library (or language) presents an API to launch these tasks. It is then the library's job to launch threads, make sure there are not too few or too many of them, make sure the work is reasonably load-balanced, and so on. For better or worse, this gives the programmer less low-level control over the system, but also higher-level, more convenient and safer APIs to work with. Some will claim that this also leads to better performance, though this really depends on the application.
By Marco Arena | Feb 16, 2016 09:29 AM | Tags: visual studio
Today the Visual C++ team is announcing a new experiment: releasing the VC++ toolset as a NuGet package that can be added to any C++ project or solution targeting desktop:
Try out the latest C++ compiler toolset without waiting for the next update of Visual Studio
by Andrew Pardoe
From the article:
Why might you want to try out new tools? There’s a lot of change happening in Visual C++ today: support for new features going into the C++17 language such as Coroutines...
By Adrien Hamelin | Feb 15, 2016 09:17 AM | Tags: intermediate c++11
A nice story with a goal:
One of C++ most underrated features: Namespace aliases
by Jonathan Müller
From the article:
About two months ago I wrote the following r/cpp comment:
[compte supprimé]
- You could always just alias the namespace like namespace fnc = FunctionalPlus.
foonathan
- Namespace aliases are one of C++ most underrated features.
In the thread a new library was presented. One user complained about the long namespace name, (s)he got the above replies. Judging by the number of upvotes, people seemed to agree with my comment. In this blog post I am going to elaborate it...