New version of CLion, a cross-platform C and C++ IDE, is released

Summer brings the new release of CLion, a cross-platform C/C++ IDE from JetBrains.

Welcome CLion 1.1 with improved C++ parser, LLDB on OS X, and code style settings

by Anastasia Kazakova

From the post, there are the new features and improvements on board:

  • Massive C++ parser overhaul to handle tricky modern C++ cases.
  • LLDB integration for OS X users.
  • Predefined code styles (like for example Google, Qt, GNU, Stroustrup).
  • New code styles settings for CMake
  • And more

Find a demo from Dmitri Nesteruk at the end of the post.

CppCon 2015 Program Highlights, 2 of N

The CppCon 2015 conference program has been posted for the upcoming September conference. We’ve received requests that the program continue to be posted in “bite-sized” posts, a few sessions at a time, to make the 100+ sessions easier to absorb, so here is another set of talks. This series of posts will conclude once the entire conference program has been posted in this way.

 

The standard template library (STL) is an important part of the C++ language. Knowing what there is inside and how to use it is an important part to create a program.

The following interrelated CppCon 2015 talks tackle these issues and more.

In this post:

  • STL Algorithms in Action
  • Enhancing STL containers
  • C++11/14/17 Atomics the Deep dive: the gory details, before the story consumes you!
  • Parallelizing the C++ Standard Library
  • Ranges and the Future of the STL

 

STL Algorithms in Action

This will be an entertaining trip through the STL algorithms, where we will view many of them in their natural habitats, going about their natural algorithm business. Then we will take some of them out of their native environments and make them do tricks that are entirely unexpected. In the end, you will gain a new appreciation for what the algorithms are and how pervasively they can be used throughout your code.

 

Enhancing STL containers

STL has a big history. Due to class paradigm of C++, many STL containers have a flat layout in memory, i.e. containers naturally store objects and address objects rather than their indexing entities such as smart pointers (which are, strictly speaking, objects too). This model has a benefit of lower memory fragmentation, that causes better CPU cache performance. However, many tasks in real life require reordering of objects, that requires compexity of O(n*q), where q is a size of an object and n is a compexity measured in operations. Thus, some imlementations of operations with reordering objects in some containers are much slower that they could be. This problem could sometimes be solved by storing “pointers” as index entities in containers instead of the objects by themselves, what improves performance by q times, but causes memory fragmentation and worse cache performance. Algorithmically, the solution with pointers is obviously better, but it is still not the most efficient one. In the presentation I will show myimplementations of containers using both approaches and having the best of two worlds. I will compare these methods with classical and modern approaches and draw some conclusion, encouraging everybody to use the power of algorithms with C++.

 

C++11/14/17 Atomics the Deep dive: the gory details, before the story consumes you!

In 2011, C++11 atomics offered three memory models but 6 settings. Most compilers have started implementing most of these (relaxed, seq_cst, acquire, release, acq_rel) but not consume (For that you will need to see Paul's talk which naturally follows this talk.) For this, I will deep dive into what each memory model setting means (especially for Games Development and low latency, a new SG14 in the C++ Standard) and how C++11 atomics are used to improve handling of mutable shared state. We have improved on it in C++14 and have more crazy things planned for C++17. I will also look at how C++ atomics are a natural precursor to SG5's Transactional Memory which was approved in Lenexa for publication.

 

Parallelizing the C++ Standard Library

As the era of frequency scaling comes to an end, multi-core parallelism has become an essential focal point in computational research. Mainstream languages, however, have not yet adapted to take full advantage of parallelism provided by the hardware. While new languages such as Rust and Swift are catching on and implementing multi-core algorithms in their libraries, C++ has only started to do so. A parallel Standard Library could bring with it many positive features that users can begin taking advantage of.

This talk will focus around two standards proposals, N4409 and N4406. N4409 outlines the details of a parallel Standard Library and features of these new parallel algorithms. The complementary N4406 outlines abstractions to take advantage of various mechanisms for parallel execution. We will cover the reasons why the new Standard Library would be beneficial to C++ users and our experience implementing these algorithms in HPX. The presentation will address what exactly the two proposals define, the challenges we faced, and the results we collected. In addition, we will discuss extensions made to these proposals and the C++11/14 standard in HPX to support these semantics in a distributed environment.

 

Ranges and the Future of the STL

Range-based interfaces are functional and composable, and lead to code that is correct by construction. With concepts and ranges coming to the STL, big changes are in store for the Standard Library and for the style of idiomatic C++. The effort to redefine the Standard Library is picking up pace. Come hear about one potential future of the STL from one of the key people driving the change.

Videos from 2015 ACCU Conference

If you missed the last ACCU conference, you can see some sessions here:

Videos from 2015 ACCU Conference

From the page:

The following videos from the ACCU 2015 Conference are currently available:

  • Axel Naumann · Large-Scale Scientific C++ For Casual Coders: Why You (Should) Care
  • Pete Goodliffe · Becoming a Better Programmer
  • Chris Oldwood · In the Toolbox - Live!
  • Hubert Matthews · The Dos and Don'ts of Multithreading

Bitesize Modern C++: std::initializer_list--Glennan Carnie

Do you know how to use initializer lists?

Bitesize Modern C++: std::initializer_list

by Glennan Carnie

From the article:

An aggregate type in C++ is a type that can be initialised with a brace-enclosed list of initialisers. C++ contains three basic aggregate types, inherited from C:

  • arrays
  • structures
  • unions

Since one of the design goals of C++ was to emulate the behaviour of built-in types it seems reasonable that you should be able to initialise user-defined aggregate types (containers, etc.) in the same way...

CppCast Episode 22: Bounded Integers with David Stone

Episode 22 of CppCast the only podcast by C++ developers for C++ developers. In this episode Rob and Jason are joined by David Stone to discuss his bounded integer library.

CppCast Episode 22: Bounded Integers with David Stone

by Rob Irving and Jason Turner

About the interviewee:

David Stone has spoken at C++Now and Meeting C++. He is the author of the bounded::integer library and has a special interest in compile-time code generation and error checking, as well as machine learning. He owns DoubleWise C++ Consulting, providing on-site training with an emphasis on performance and correctness. He also works at Markit integrating real-time financial data. He once wrote an optimizing compiler that solved the halting problem, and is just waiting for it to finish compiling his program.

 

QWidgets and data

The sixt part of my series takes a look at QWidgets and how to exchange data:

QWidgets and data

by Jens Weller

From the article:

The sixt part of my series about writing applications in C++ using Qt and boost is about my thoughts on widgets and how to interact with data from them.

Boost Version 1.59 Released

The next version of boost is released.

Boost 1.59

From the release note:

These new libraries has been added:

  • Convert: An extendible and configurable type-conversion framework, from Vladimir Batov.
  • Coroutine2: (C++14) Coroutine library, from Oliver Kowalke.

A huge number of bugfixes and improvements were implemented for the existing libraries.

 

Many thanks to all contributors and maintainer!