October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
By Marco Arena | Feb 15, 2016 07:16 AM | Tags: c++14 basics
I'm starting a new series about how standard algorithms and containers help in solving competitive programming challenges. Here is an introduction:
C++ in Competitive Programming: intro
by Marco Arena
From the article:
In the last two years I have turned into a Competitive Programming aficionado, mostly active on HackerRank, less on TopCoder and CodingGame...
By Bjarne Stroustrup | Feb 14, 2016 03:43 PM | Tags: None
C++ provides two calling syntaxes, x.f(y) and f(x,y). This has bothered me for a long time. I discussed the problem in the context of multimethods in D&E in 1994, referring back to a proposal by Doug Lea from 1991, and again in 2007. Each of the syntaxes has its virtues, but they force design decisions on people, especially library designers. When you write a library, which syntax do you use for operations on objects passed to you by your users? The STL insists on the traditional functional syntax, f(x,y), whereas many OO libraries insist on the dot notation, x.f(y). In turn, libraries force these decisions on their users.
Interestingly, I solved the problems for operators: x+y doesn’t care whether you provide operator+(T,T) or T::operator+(T). The problem is getting more noticeable as we get more generic libraries. Note begin(c) and c.begin() for range-for loops and in general code. Why do we/someone have to write both? If c.begin() exists, begin(c) should find it, just as x+y finds the right implementation. Such call-syntax adapters are pure overhead and different people’s adapters can clash.
In early 2014, Herb Sutter and I each independently decided to propose a unified syntax. Herb suggested unification based on allowing x.f(y) to find a non-member function, giving preference to the x.f(y) syntax, whereas my ideal was that x.f(y) and f(x,y) should mean exactly the same. After a quick discussion, we joined forces. Based on real input from code and users, I reluctantly agreed that for compatibility reasons, x.f(y) and f(x,y) could not mean exactly the same. The only feasible way forward was to do a traditional lookup based on the syntax used, and then try the other syntax if the first one failed. Stability – backwards compatibility – is an important feature, overruling my desire for perfection.
To my surprise, many people came out strongly against x.f(y) finding f(x,y) – even if member functions were preferred over free-standing functions by the lookup rules. I received email accusing me of “selling out to the OO crowd” and people whose experience and opinion I respect insisted that x.f(y) finding f(x,y) would seriously compromise their ability to design stable interfaces. I think those fears are greatly exaggerated, but I could be wrong. Also, I prefer the dot syntax in some cases; for example, I find x.f(y).g(z) more readable than g(f(x,y),z). However, there was no chance of acceptance of a proposal that included x.f(y) finding f(x,y). Maybe modules will eventually help here. Furthermore, David Vandevoorde pointed out that because of the two-phase lookup rules having x.f(y) find f(x,y) would complicate the task for compiler writers and possibly be expensive in compile time.
So, we are left with a simple proposal to allow f(x,y) to find x.f(y) where f(x,y) wouldn’t work today. This solves the problem for library writers and their users along the lines of the STL:
The proposal was approved by the Evolution Working Group. Faisal Vali did an experimental implementation in Clang. Now we just have to hope that we can agree on exact wording in time for C++17. I consider it a small proposal that will significantly simplify the way we design and use libraries.
By Meeting C++ | Feb 14, 2016 07:35 AM | Tags: ranges performance intermediate efficiency c++17 c++14 c++11 boost basics advanced
From Iterators to Ranges: The Upcoming Evolution Of the STL
by Arno Schödl
By Marco Arena | Feb 12, 2016 06:58 AM | Tags: visual studio
The C++ compiler team is excited for you to try out the compiler in Visual Studio 2015 Update 2 CTP 1. Let’s dive into some of the feature improvements they have made in the compiler for Update 2:
Compiler improvements in VS 2015 Update 2
by Andrew Pardoe
From the article:
Since Update 1 we’ve made progress on being Standards-conformant for lot of C++11 and C++14 features...
By Bjarne Stroustrup | Feb 11, 2016 12:17 PM | Tags: None
[This note from Bjarne provides some background for the updated structured bindings proposal posted yesterday. --Ed.]
In the context of the C++ Core Guidelines, we (Herb Sutter, Gabriel Dos Reis, me, and few others) were discussing sources of bugs and inefficiencies. We noticed that returning multiple values (e.g., from a tuple) was one of the two remaining sources of uninitialized variables. We noticed that there were real cases of bugs and inefficiency (from default initialization followed by assignment rather than initialization) stemming from separating variable introduction from initialization. Use of tie() is at best a partial solution that doesn’t get to the root of the problem.
The next day or so, Herb had a first draft of a proposal. We refined it, adding use cases and implications. I noted that we had a syntax in concepts for the introduction of multiple names that we could borrow. We noted that whatever we came up with had to fit into our ideas for a possible future far-more-general pattern matching design. We always try to ensure that a proposal doesn’t block an important potential evolution path. The design document for the proposal was refined and extended.
It was now obvious that the proposal completed C++’s mechanism for returning multiple values from a function: With structured binding, we can initialize a set of values, {x,y,z}, just as we can return a set of values, {e1,e2,e3}.
In web discussions, and especially at the Kona standards meeting, many alternatives were discussed. We focused on how to deal with user-defined types with private members. The new feature mustn’t discourage encapsulation by providing a convenient notation for structs only. We also considered whether explicit declaration of types were needed and how to achieve conversions. A conversion from a char[] in a return value to a string was considered particularly desirable by several people. These two needs were both addressed by adding the ability for users to define get<N> functions for a class. Jens Maurer refined the proposed wording and in doing so found a few weaknesses in the design.
For the details and code examples, you can find the current proposal and wording papers here for the upcoming meeting in Jacksonville.
By Meeting C++ | Feb 11, 2016 06:36 AM | Tags: performance intermediate efficiency c++14 c++11 boost basics advanced
My series on building applications with Qt an boost continues:
Searching and replacing in strings with boost
by Jens Weller
From the article:
The next big milestone for my CMS is to actually generate HTML files, and I'm almost there. I'll reach it in the next two weeks, most code is written, just a little bit of refactoring is needed. This blog post is about searching and replacing in strings. As I started last week with implementing the functionality, that turns the data in my CMS into an HTML website.
There needs to be a lot of text transformed, in order to turn a shared structure like a cross page layout into a single, special HTML file, one of those transformations is, to replace the internal links with the correct links. A link to a different page in the same website cannot be represented as a text link, instead it is represented by a linkid, which corresponds to the Page it points to. This is to have still the correct link, if the page is renamed or moved...
By Adrien Hamelin | Feb 11, 2016 02:50 AM | Tags: c++14 advanced
ACCU’s Overload journal of February 2016 is out. It contains the following C++ related articles.
Overload 131
From the journal:
Defining Concepts
Concepts provide a new way of constraining code. Andrew Sutton shows us how to define and use them. by Andrew Sutton
On Zero-Side-Effect Interactive Programming, Actors, and FSMs
Functional programming is alien to many programmers. Sergey Ignatchenko considers parallels between actors and finite state machines.
Template Programming Compile Time Combinations & Sieves
Functional style frequently uses sequences. Nick Weatherhead applies these ideas to combinations in C++. by Nick Weatherhead
Classdesc: A Reflection System for C++11
C++ lacks direct support for reflection. Russell Standish brings an automated reflection system for C++, Classdesc, up to date. by Russell Standish
QM Bites : Maximising Discoverability of Virtual Methods
C++11 introduced override as a contextual keyword. Matthew Wilson encourages us to use it. by Matthew Wilson
So Why is Spock Such a Big Deal?
Spock testing in a Java environment is all the rage. Russel Winder talks through the history of testing on the JVM and demonstrates why Spock is so groovy. by Russel Winder
By Adrien Hamelin | Feb 11, 2016 02:43 AM | Tags: c++11 basics
And emplace_back function:
Modern C++ features: in-place construction
by Arne Mertz
From the article:
Move constructors are often cheaper than copy constructors, which makes the construction and immediate relocation of objects in modern C++ more effective than in C++03. However, just moving the parts needed to construct the object in the right place can be even more effective. Several standard library functionalities use perfect forwarding to construct objects right where they are needed.
By robwirving | Feb 10, 2016 07:47 AM | Tags: None
Episode 44 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Bryce Lelbach to discuss High Performance Computing and other C++ topics.
CppCast Episode 44: HPC and more with Bryce Lelbach
by Rob Irving and Jason Turner
About the interviewee:
Bryce Adelstein Lelbach is a researcher at Lawrence Berkeley National Laboratory (LBNL), a US Department of Energy research facility. Working alongside a team of mathematicians and physicists, he develops and analyzes new parallel programming models for exascale and post-Moore architectures. Bryce is one of the developers of the HPX C++ runtime system; he spent five years working on HPX while he was at Louisiana State University's Center for Computation and Technology. He also helped start the LLVMLinux initiative, and has occasionally contributed to the Boost C++ libraries. Bryce is an organizer for C++Now and CppCon conferences and he is passionate about C++ community development. He serves as LBNL's representative to the C++ standards committee.
By Olve Maudal | Feb 9, 2016 03:59 PM | Tags: None
For the third year in a row we will set up a strong C++ track at the NDC conference in Oslo, June 6-10.
At NDC Oslo the typical crowd of 2000+ developers can choose from 9-10 parallel tracks over 3 long days (June 8-10). One of these tracks will be about C++, but there will be tracks on embedded programming, security and IoT just to mention a few. There are also many preconference 2-day tutorials/workshops (June 6-7) and several of these will be on C++ and C (stay tuned).
We have already signed up several solid C++ speakers. Anthony Williams, Mark Isaacson, Hubert Matthews, Dan Saks, Andrei Alexandrescu, will be there. Will you? We have a few more slots available. In particular we are looking for C++ gurus based in Europe. Feel free to also contact Olve Maudal directly if you are interested.
If you are curious about the NDC conference please take a look at the humorous promo video for last years event.