A date and time library for use with C++11 and C++14 -- Howard Hinnant

By Ion Gaztañaga | Jul 22, 2015 08:47 AM | Tags: c++14 c++11

This paper fully documents a date and time library for use with C++11 and C++14.

Library documentation:

by Howard Hinnant

From the article:

Implementation

This entire library is implemented in a single header: date.h and is open source (with generous open source terms — not generous enough? Contact me, I'm flexible).

It uses the algorithms from chrono-Compatible Low-Level Date Algorithms. If you want detailed explanations of the algorithms, go there.

It performs best with C++14, which has vastly improved constexpr rules. However, the library will auto-adopt to C++11, sacrificing several constexpr declarations. In C++11, this will effectively transfer some computations that should be done at compile-time to run-time. Porting to C++98/03 has not been attempted.

Overview

This library builds date and date/time support on top of the <chrono> library. However it does not support timezones nor leap seconds. A separate library is provided, built on top of this one, for timezone and leap second support. Thus you only pay for such support if you need it.

SourceMeter for C/C++ with open-source SonarQube plugin released

By Rudolf Ferenc | Jul 22, 2015 08:41 AM | Tags: None

FrontEndART has release a new version of their SourceMeter.

SourceMeter 7.0 released with support for C/C++

by FrontEndART team

From the article:

Most important product characteristics of SourceMeter:

• Platform-independent command line tools
• Transparent integration into build processes
• Coding issue detection
• Clone detection (copy-pasted source code fragments) extended with clone tracking and "clone smells"
• Metrics calculation at component, file, namespace, class, function and method levels
• C++14 support (almost complete, based on EDG front-end)
• SonarQube plug-in

Online demo

CppCon 2014 Costless Software Abstractions for Parallel Architectures--Joel Falcou

By Adrien Hamelin | Jul 22, 2015 08:00 AM | Tags: experimental efficiency

Have you registered for CppCon 2015 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2014 for you to enjoy. Here is today’s feature:

Costless Software Abstractions for Parallel Architectures

by Joel Falcou

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Performing large, intensive or non-trivial computing on array like data structures is one of the most common task in scientific computing, video game development and other fields. This matter of fact is backed up by the large number of tools, languages and libraries to perform such tasks. If we restrict ourselves to C++ based solutions, more than a dozen such libraries exists from BLAS/LAPACK C++ binding to template meta-programming based Blitz++ or Eigen. If all of these libraries provide good performance or good abstraction, none of them seems to fit the need of so many different user types.

Moreover, as parallel system complexity grows, the need to maintain all those components quickly become unwieldy. This talk explores various software design techniques - like Generative Programming, MetaProgramming and Generic Programming - and their application to the implementation of a parallel computing librariy in such a way that:

- abstraction and expressiveness are maximized - cost over efficiency is minimized

We'll skim over various applications and see how they can benefit from such tools. We will conclude by discussing what lessons were learnt from this kind of implementation and how those lessons can translate into new directions for the language itself.

N4548: WG21 2015-07-20 Telecon Minutes -- Roger Orr

By Blog Staff | Jul 20, 2015 03:36 PM | Tags: None

A new WG21 paper is available. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N4548

Date: 2015-07-20

WG21 2015-07-20 Telecon Minutes

by Roger Orr

Excerpt:

"Move to direct the Convener to transmit the approved updated Concepts TS working paper (attachment ts.pdf r2) for publication." [...] There were no objections, so the poll was carried.

CppCon 2014 Hourglass Interfaces for C++ APIs--Stefanus DuToit

By Adrien Hamelin | Jul 20, 2015 08:00 AM | Tags: intermediate efficiency

Have you registered for CppCon 2015 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2014 for you to enjoy. Here is today’s feature:

Hourglass Interfaces for C++ APIs

by Stefanus DuToit

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

C++ provides a much richer set of abstractions than C. Classes, templates, overloading, and other core C++ features can be leveraged for more readable syntax, better compile time typechecking, more open ended genericity and improved modularity. On the flip side, C89 still boasts some advantages over C++, especially when viewed through a pragmatic lens. C ABIs on many platforms have been stable for decades, practically every language supports binding to C code through foreign function interfaces, and including nearly any C89 header has a negligible effect on compile time on modern computers.

The Hourglass pattern provides the best of both worlds. It's a way to structure libraries that retains the pragmatic benefits of C89 while still providing C++'s richness both at an interface and implementation level. It makes providing bindings from other languages to C++ libraries easier, and insulates from ABI issues such as incompatibilities between debug and release variants of runtimes. This talk provides an overview of the pattern, teaches practical techniques for its implementation using C++98 and C++11, and shares experience from using the pattern in real world projects.

RVO V.S. std::move -- Zhao Wu

By Mantosh Kumar | Jul 19, 2015 11:05 PM | Tags: intermediate c++11

Discussion about the RVO optimization technique & std::move.

RVO V.S. std::move

by Zhao Wu

From the article:

To summarize, RVO is a compiler optimization technique, while std::move is just an rvalue cast, which also instructs the compiler that it's eligible to move the object. The price of moving is lower than copying but higher than RVO, so never apply std::move to local objects if they would otherwise be eligible for the RVO.

CppCon 2014 C++ Test-driven Development--Peter Sommerlad

By Adrien Hamelin | Jul 17, 2015 08:00 AM | Tags: intermediate

Have you registered for CppCon 2015 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2014 for you to enjoy. Here is today’s feature:

C++ Test-driven Development

by Peter Sommerlad

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Unit Testing and TDD, if applied correctly, lead to high quality and simple code. If done by hand, both often require writing some boiler-plate code and can be slow and cumbersome. Especially refactoring without good tool support can be a burden. Java and C# developers are used to have good tool support for these tasks to be effective. Many C++ developers often aren't even aware of the need for the practices, because without tool support and training of the goals, they are hard to discover.

This talk introduces C++ Unit Testing, Test-driven Development, and Refactoring and demonstrates the tooling available for Eclipse CDT for free on www.cevelop.com that was inspired and implemented by the author and his team.

For example, when phrasing a unit test to use a to-be-defined class, the class is generated automatically from its name used as a type. Another tool feature is simplifying a function, by extracting a sub-function and placing a call in its place.

Efficient optional values -- Andrzej Krzemieński

By Felix Petriconi | Jul 16, 2015 11:48 PM | Tags: intermediate boost

Andrzej goes into some details of optional values in his recent blog post.

Efficient optional values

by Andrzej Krzemieński

From the article:

What do you use Boost.Optional for? In my experience, the answer was typically one of the following:

1. Because my type T has no null state (like -1) that would indicate that I have no proper value.
2. Because, I need to perform a two-phase initialization (I cannot initialize my T yet, but I already need it alive).
3. Because I need an interface that would indicate to the type system that my value may not be there and that its potential absence should be checked by the users.

In this post we will focus exclusively on the third motivation.

Bitesize Modern C++: using aliases--Glennan Carnie

By Adrien Hamelin | Jul 16, 2015 11:25 AM | Tags: c++11 basics

Do you know how to use type aliasing?

Bitesize Modern C++: using aliases

by Glennan Carnie

From the article:

In a C++ program it is common to create type aliases using typedef. A type alias is not a new type, simply a new name for an existing declaration. Used carefully, typedef can improve the readability and maintainability of code – particularly when dealing with complex declarations...

Programmatic access to the call stack in C++--Eli Bendersky

By Adrien Hamelin | Jul 15, 2015 07:46 AM | Tags: advanced

The call stack can be accessed without debugger too:

Programmatic access to the call stack in C++

by Eli Bendersky

From the article:

Sometimes when working on a large project, I find it useful to figure out all the places from which some function or method is called. Moreover, more often than not I don't just want the immediate caller, but the whole call stack. This is most useful in two scenarios - when debugging and when trying to figure out how some code works...