10 tips to be productive in CLion, cross-platform C/C++ IDE -- Anastasia Kazakova

By Anastasia Kazakova | Jun 10, 2015 03:17 AM | Tags: tools productivity

An article on how to improve your productivity when using CLion IDE.

10 tips to be productive in CLion

by Anastasia Kazakova

From the article:

Judging from my own experience as a developer, many C/C++ developers dismiss the idea that an IDE can make them more productive. Because what could be better than the simple and quick Vim or Emacs? Well, let me show you. These 10 CLion tips can take you to a new level of productivity, by letting you focus on the important and complicated tasks while the IDE handles routine jobs for you.

From Smart Code Completion to Inline Variables View...

Overload 127 is now available

By Adrien Hamelin | Jun 8, 2015 09:28 AM | Tags: intermediate

Overload 127 is now available:

Overload 127

It contains the following C++-related articles, and more:

• Mocks are Bad, Layers are Bad
• Terse Exception Messages
• Get Debugging Better!
• Make and Forward Consultables and Delegates

Nugget: static_assert--Glennan Carnie

By Adrien Hamelin | Jun 8, 2015 09:26 AM | Tags: c++11 basics

A short nugget by Glennan Carnie:

static_assert

by Glennan Carnie

From the article:

C’s assert library is a useful tool for catching invalid invariants (conditions that must hold true in order for your system to operate as specified) in your program. The big problem with assert is that it’s a run-time check; in many cases the best you can do  to recover from an assert failure is restart the system or put it into a quiescent state...

Trip report: Spring ISO C++ meeting

By Herb Sutter | Jun 5, 2015 10:50 AM | Tags: None

(I'm writing my trip report now that all the post-meeting papers are available and linkable this week.)

The spring ISO C++ meeting was held on May 4-9 in Lenexa, KS, USA. Many thanks again to Lexmark for hosting us! There were 93 experts at this meeting, officially representing 5 nations. Last fall’s meeting (see trip report) saw a recent-record number of over 120 papers; for this meeting it was over 140 papers in the two pre-meeting mailings (February and April).

As usual, we met for six days, starting Monday morning and ending on Saturday afternoon, with a number of evening sessions to fill out the round-the-clock technical discussions.

There was particular interest in planning for C++17; this was the subject of the Monday evening sessions led by Bjarne Stroustrup based on this draft “Thoughts on C++17” paper published a week before the meeting... after Bjarne’s initial internal and more informal committee email leaked to Reddit. There’s nothing like having a forcing function to write up an actual paper!

For a detailed list of papers that were adopted at this meeting, see the post-meeting mailing that just went live for the papers marked “Adopted 2015-05.” Also, check out STL’s nice summary posted on Reddit, and the video “The future of C++[17] -- Updates from Lenexa” on Channel 9 with Gabriel Dos Reis and Artur Laksberg. [ETA: Also Botond Ballo's detailed trip report.]

TS Milestones: 3 Completed, 1 Sent For Comment Ballot

We finished three more Technical Specifications, incorporating their ballot comments and sending the final text to ISO for publication. These should all be formally published this summer: Transactional Memory TS (project editor: Michael Wong), Parallelism TS (project editor: Jared Hoberock), and the Library Fundamentals TS (project editor: Jeffrey Yasskin). All of them had only minor tweaks at this meeting.

In addition, we also sent the Concurrency TS out for its comment ballot (project editor: Artur Laksberg). We hope to address the comments at our fall meeting in Kona; if they can all be addressed in one meeting, the Concurrency TS would be completed this year, making four TSes published this year. I asked Artur for a summary and here’s what he wrote: “The Concurrency TS consists of three parts: First, it introduces improvements to std::future<T> to enable wait-free composition of asynchronous operations. It introduces the concepts of continuation (the “then” API) for chaining multiple futures as well join and choice operations, represented by, respectively, when_all and when_any APIs. Second, the TS introduces thread coordination mechanisms called latch, barrier and flex_barrier. These mechanisms allow one or more threads to block until an operation is completed. An individual latch is a single-use object: once the operation has been completed, it cannot be reused. A barrier is re-usable: once the operation has been completed, the threads can re-use the same barrier. Flex barriers allow additional behavior to be defined when an operation has completed. Finally, the TS introduces class templates atomic_shared_ptr<T> and atomic_weak_ptr<T>, which are useful for writing lock free code. Compared to the existing mechanisms, the new concepts offer superior performance and are less error-prone.” -- On a personal note, I’m especially happy with that last bit because that was my proposal. Not all proposals succeed even after several meetings’ worth of work, and it’s nice to see the atomic smart pointers make it into the TS.

Note that this means that in under 12 months we have published the C++14 International Standard and three Technical Specifications, and it’s possible that the Concurrency TS might become a fourth. That’s quite an achievement, and thanks very much to the above-mentioned editors and all of our hardworking project editors and contributors! You can always find a list of current projects and their editors at isocpp.org/std/status.

Other Major Projects Update

The Concepts TS just completed its comment ballot, and we considered most of the ballot comments in Lenexa. We’re going to have one more telecon to finish the comments, then decide whether it’s ready to publish this year. Of course, what matters to you as a developer is not just when the committee blesses a document, but when you can try out the feature in your compiler, so I’m happy to report that my understanding is that vendors are not waiting for the TS to be published to implement Concepts in real compilers: I’m told that GCC expects to adopt the Concepts reference implementation into its next release, GCC 6, which if GCC follows its usual schedule would likely be spring 2016; and I’m also told that one or two other major implementations are working on implementing Concepts.

Modules also made good progress where the redesign led by Gabriel Dos Reis got encouragement form the committee and I’m told agreement among the major compiler vendors, though there are still a few important but relatively minor details to decide. Among the major C++ compilers, I’m told there should be at least one shipping experimental implementation of the current modules design available by the end of this year.

Ranges made great progress. Eric Niebler has worked hard over the winter and spring and brought initial draft wording for applying ranges to the entire iterators and algorithms clauses of the standard – this is no small wording undertaking! A reference implementation tracking the proposal is available on GitHub. We hope to see, and possibly adopt, initial working draft wording for Ranges at our fall meeting.

Networking is well on the way to producing a TS working paper based on the Boost.ASIO library with detailed wording also expected for the next meeting where we might be able to start a working draft.

Coroutines (await, generators) made good progress at this meeting and might also have working draft wording in Kona for the primary proposal: Visual C++ is shipping a reference implementation in VS2015, and my understanding is that at least one other major compiler is looking at implementing it this summer for possible release around the end of the year. There are also complementary/alternative coroutines proposals still in flight, so this is an active and important space.

Finally, Reflection had an evening session to progress some papers, and many other papers and proposals made progress too.

CppCon, Games, and a new SG14: Game Development and Low-Latency

I want to end with one interesting thing that happened in Lenexa that involves the C++ community beyond just the traditional standards committee attendees.

This past September, the first-ever CppCon was held, and it’s surprising how influential it already is. Here is one example. There at CppCon, we had a Meet the Authors session – that’s not too unusual at this kind of conference, and you might even think it would likely be a “lightweight” or “fluffy” kind of session. Well, never mind that there were a dozen heavyweight authors on the panel, from Bjarne Stroustrup and Scott Meyers on down all on the same stage, but that hour of discussion had real influence. In particular, the topic of ISO C++ and game development came up from the audience, and Michael Wong volunteered to arrange and lead a session later in the CppCon week on that topic. (CppCon deliberately leaves room for this kind of flexibility to be able to respond to whatever will get the most benefit out of the face-to-face time we have at the event.)

That extra session was strongly attended. In that session and since, Mike has continued to be approached by a steady stream of game developers who are interested in contributing to C++ standardization. And in addition to game-specific developers, there also seems to be a strong overlap with other developers interested in low latency programming for reasons other than frame rates.

What does all this have to do with the spring ISO C++ meeting? In Lenexa, Mike Wong reported the above backstory. When I polled the ISO C++ committee members in the room, a couple of dozen said they would be interested in participating in such work – and that’s a very strong response for a single topic area.

So this discussion that started brewing at CppCon has had a real result: At the Lenexa meeting, I created a new Study Group 14 on Game Development and Low-Latency Computing, with Mike Wong graciously volunteering to serve as the initial SG14 chair.

The next question was, how do we engage with this community? To get started, based on the community’s feedback through Mike, we realized need to overcome two particular challenges:

• Some of these experts have submitted proposals to ISO C++ before, but it was at a time when the committee was busy shutting down C++11 and it might have appeared that the committee wasn’t interested (though we are).
• These developers remain interested in contributing to C++ standardization, but they’re busy with their own conference schedule and product deadlines (so we need to meet them where they are).

Together, we felt this means we should start by meeting the gamers (and other low-latency developers) where they already are – by having official SG14 meetings “out in the field” starting at CppCon this September because that’s where they already were to start this drive last year. Having “side meetings on particular topic areas” that are separate from full ISO C++ meetings is exactly what Study Groups are for.

Our intention is to have formal SG14 meetings in the coming months located where these developers are, in addition to our full ISO C++ meetings:

1. SG14 @ CppCon 2015 in September. Mike and I will convene a full-day formal SG14 meeting at CppCon itself, currently tentatively scheduled for Wednesday. In attendance will be a number of long-time ISO C++ committee members and leadership, including but not limited to Mike (SG14 chair, CEO of OpenMP, and chair of Canada’s C++ committee), Ville Voutilainen (WG21 Evolution Working Group chair, Finland C++ committee), and myself (WG21 convener). We hope this shows we’re serious about engaging on this topic area! The agenda will be to entertain proposal ideas, to find a core set of proposals that could have critical mass of support and volunteers that we can encourage work on, and to set a draft agenda for #2 below... (Note: CppCon registration is not required to attend just the SG14 meeting, but is required if you also want to attend some of the 100+ CppCon sessions.)

Following the outcome of meeting #1 at CppCon, there may also be topics raised at additional SG14 telecons, and/or the two intervening full ISO C++ meetings in October and February. Then...

2. SG14 @ GDC 2016 in March. Mike and I then plan to convene a 2-3 day SG14 meeting (or as much time as is needed), again likely on-site at GDC. As soon as this was suggested, ISO C++ committee member organizations in the room started approaching me to offer facilities support to host this meeting at the GDC site or within short walking distance.

Thanks again everyone in the game development and low-latency computing industries for the strong interest, and to the over 100 volunteers whose hard work behind the scenes made CppCon possible last year to enable this kind of interaction, and who are hard at work as we speak organizing it again this September! CppCon is clearly already getting to be “the place to be” for the whole C++ community – including the intersection of the standard and the industry. This is important, and great to see.

Next meeting

Our next full WG21 face-to-face meeting will be in October in Kona, HI, USA, hosted by Plum Hall and the Standard C++ Foundation.

In the meantime, over the summer we’ll be having several other smaller telecon meetings, including as noted above to try to finalize the Concepts TS and meet at CppCon for the new SG14.

Many thanks especially to the meeting hosts for graciously volunteering to organize these meetings!

The compiler is to blame for everything -- Andrey Karpov

By Andrey Karpov | Jun 4, 2015 11:48 PM | Tags: errors compilers compiler bugs basics

Many programmers are very fond of blaming the compiler for different errors. Let's talk about it.

The compiler is to blame for everything

by Andrey Karpov

From the article:

When a programmer tells you that the compiler causes an error, it is a lie in 99% of cases. When you start investigating the problem, you usually find out the following reasons:

• an array overrun;
• an uninitialized variable;
• a misprint;
• a synchronization error in a parallel program;
• a non-volatile variable used;
• code leading to undefined behavior;
• etc.

Simple C++11 metaprogramming--Peter Dimov

By Adrien Hamelin | Jun 2, 2015 12:05 PM | Tags: c++14 advanced

If you like to play with templates, read this article:

Simple C++11 metaprogramming

by Peter Dimov

From the article:

The wide acceptance of Boost.MPL made C++ metaprogramming seem a solved problem. Perhaps MPL wasn't ideal, but it was good enough to the point that there wasn't really a need to seek or produce alternatives.

C++11 changed the playing field. The addition of variadic templates with their associated parameter packs added a compile-time list of types structure directly into the language...

Holier Than Thou--Tony “Bulldozer00” (BD00) DaSilva

By Adrien Hamelin | Jun 2, 2015 11:51 AM | Tags: advanced

A rare but possible problem that can occur with long running programs:

Holier Than Thou

by Tony DaSilva

From the article:

Since C++ (by deliberate design) does not include a native garbage collector or memory compactor, programs that perform dynamic memory allocation and de-allocation (via explicit or implicit use of the “new” and “delete” operators) cause small “holes” to accumulate in the free store over time. I guess you can say that C++ is “holier than thou“. :( ...

docopt.cpp: A C++11 Port--Jared Grubb

By Adrien Hamelin | Jun 1, 2015 08:02 AM | Tags: intermediate efficiency

A nice library to help you ship a program:

docopt.cpp: A C++11 Port

by Jared Grubb

From the article:

Isn't it awesome how getopt (and boost::program_options for you fancy folk!) generate help messages based on your code?! These timeless functions have been around for decades and have proven we don't need anything better, right?

Hell no! You know what's awesome? It's when the option parser is generated based on the beautiful help message that you write yourself! This way you don't need to write this stupid repeatable parser-code, and instead can write only the help message--the way you want it...

How to implement a stateful meta-container in C++ -- Filip Roséen

By Mantosh Kumar | May 28, 2015 09:27 PM | Tags: experimental c++14 advanced

Implementing stateful meta contianer in C++ Using Modern C++.

How to implement a stateful meta-container in C++

by Filip Roséen

From the article:

This post has explained the technical aspects related to an implementation of a stateful meta-container, allowing a developer to more easily work with, and modify, a given set of entities during the phase of translation.

Together with the previous posts in this series, the formerly unstateful world of translation has gone into a stateful universe — allowing for some crazy, but conforming, implementations.

Quick Q: Why are override and final identifiers with special meaning instead of reserved keywords?

By Adrien Hamelin | May 28, 2015 02:31 PM | Tags: c++11 basics

Quick A: To avoid breaking old code, thanks to context-sensitive keywords.

Recently on SO:

Why are override and final identifiers with special meaning instead of reserved keywords?

Both the override specifier and final specifier were added in C++11. They differ from other specifiers added to C++11 such as constexpr and decltype, in that they are not keywords and so are available for use as identifiers:

int main()
{
  int override = 0 ;    // Ok
  int final = 0 ;       // Ok
  //int constexpr = 0 ; // Error
}

They are referred to as identifiers with special meaning, which is covered in the draft C++11 standard section 2.11 [lex.name] (emphasis mine):

The identifiers in Table 3 have a special meaning when appearing in a certain context. When referred to in the grammar, these identifiers are used explicitly rather than using the identifier grammar production. any ambiguity as to whether a given identifier has a special meaning is resolved to interpret the token as a regular identifier.
and Table 3 -- Identifiers with special meaning lists both override and final.

Why did these two specifiers end up being identifiers with special meaning instead of keywords?