Top 10 dumb mistakes to avoid with C++ 11 smart pointers -- Deb Haldar

By Mantosh Kumar | May 15, 2016 10:36 PM | Tags: intermediate

Discussion on various aspect of C++11 smart pointers uses.

Top 10 dumb mistakes to avoid with C++ 11 smart pointers

by  Deb Haldar

From the article:

I love the new C++ 11 smart pointers. In many ways, they were a godsent for many folks who hate managing their own memory. In my opinion, it made teaching C++ to newcomers much easier.

However, in the two plus years that I've been using them extensively, I've come across multiple cases where improper use of the C++ 11 smart pointers made the program inefficient or simply crash and burn. I've catalogued them below for easy reference.

CppCon 2015 Implementation of a component-based entity system in modern C++--Vittorio Romeo

By Adrien Hamelin | May 13, 2016 02:17 PM | Tags: performance efficiency c++14

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

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

Implementation of a component-based entity system in modern C++

by Vittorio Romeo

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

An alternative to deep inheritance trees for game and application architecture design is "composition". Separating data (in independent components) from logic (in independent systems) allows the code to be more reusable and more efficient, alongside additional benefits. Using modern C++11 and C++14 features, it is possible to design an efficient and user-friendly component-based entity system library, with intuitive syntax and convenient cost-free abstractions.

boost 1.61.0 released

By Felix Petriconi | May 13, 2016 06:48 AM | Tags: boost

The boost community has released their library in version 1.61.0.

boost 1.61.0 released

by the boost organization

From the release note:

Beside many bug fixes and enhancements in the existing libraries, these new libraries were added:

New Libraries

Compute:
Parallel/GPU-computing library

DLL:
Library for comfortable work with DLL and DSO. Library provides a portable across platforms way to:

• load libraries
• import any native functions and variables
• make alias names for C++ mangled functions and symbols
• query libraries for sections and exported symbols
• self loading and self querying
• getting program and module location by exported symbol

Hana:
A modern C++ metaprogramming library. It provides high level algorithms to manipulate heterogeneous sequences, allows writing type-level computations with a natural syntax, provides tools to introspect user-defined types and much more.

Metaparse:
A library for generating compile time parsers parsing embedded DSL code as part of the C++ compilation process. The library is similar to Spirit, however while parsers built with Spirit parse at run-time, parsers built with Metaparse parse at compile-time.

CppCon 2015 Ranges for the Standard Library--Eric Niebler

By Adrien Hamelin | May 11, 2016 01:03 PM | Tags: intermediate experimental

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

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

Ranges for the Standard Library

by Eric Niebler

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

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.

CppCon 2015 Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My!--Chandler Carruth

By Adrien Hamelin | May 9, 2016 01:24 PM | Tags: performance advanced

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

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

Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My!

by Chandler Carruth

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

A primary use case for C++ is low latency, low overhead, high performance code. But C++ does not give you these things for free, it gives you the tools to control these things and achieve them where needed. How do you realize this potential of the language? How do you tune your C++ code and achieve the necessary performance metrics?

This talk will walk through the process of tuning C++ code from benchmarking to performance analysis. It will focus on small scale performance problems ranging from loop kernels to data structures and algorithms. It will show you how to write benchmarks that effectively measure different aspects of performance even in the face of advanced compiler optimizations and bedeviling modern CPUs. It will also show how to analyze the performance of your benchmark, understand its behavior as well as the CPUs behavior, and use a wide array of tools available to isolate and pinpoint performance problems. The tools and some processor details will be Linux and x86 specific, but the techniques and concepts should be broadly applicable.

Quick Q: Is this std::ref behaviour logical?

By Adrien Hamelin | May 9, 2016 01:19 PM | Tags: intermediate c++11

Quick A: Yes, std::ref can be reassigned (see example)

Recently on SO:

Is this std::ref behaviour logical?

A small modification to f2 provides the clue:

template<class T>
void f2(T arg)
{
    arg.get() = xx;
}

This now does what you expect.

This has happened because std::ref returns a std::reference_wrapper<> object. The assignment operator of which rebinds the wrapper. (see http://en.cppreference.com/w/cpp/utility/functional/reference_wrapper/operator%3D)

It does not make an assignment to the wrapped reference.

In the f1 case, all is working as you expected because a std::reference_wrapper<T> provides a conversion operator to T&, which will bind to the implicit right hand side of ints implicit operator+.

cppformat 3.0.0 and becomes fmt--Victor Zverovich

By Adrien Hamelin | May 9, 2016 01:15 PM | Tags: intermediate c++14

A new versionb of fmt is out:

cppformat 3.0.0 and becomes fmt

by Victor Zverovich

From the release:

The project has been renamed from C++ Format (cppformat) to fmt for consistency with the used namespace and macro prefix (#307). Library headers are now located in the fmt directory:

#include "fmt/format.h"

Including format.h from the cppformat directory is deprecated but works via a proxy header which will be removed in the next major version. The documentation is now available at http://fmtlib.net...

C++ Weekly Episode 9: std::future Quick-Start -- Jason Turner

By Jason Turner | May 8, 2016 11:28 PM | Tags: None

Episode 9 of C++ Weekly.

std::future Quick-Start

by Jason Turner

About the show:

In this episode Jason gives a very fast quick-start to what std::future is and how to use std::async to run a function in another thread.

CppCast Episode 56: Conan with Diego Rodriguez-Losada

By robwirving | May 6, 2016 10:50 AM | Tags: None

Episode 56 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Diego Rodriguez-Losada from Conan to discuss the new C++ Package Manager.

CppCast Episode 56: Conan with Diego Rodriguez-Losada

by Rob Irving and Jason Turner

About the interviewee:

Diego's passions are robotics and SW development. He has developed many years in C and C++ in the Industrial, Robotics and AI fields. He was also a University (tenure track) professor till 2012, when he quit academia to try to build a C/C++ dependency manager, co-founded startup biicode, since then mostly developing in Python. Now he is working as freelance and having fun with conan.io.

Introducing a new, advanced Visual C++ code optimizer--Gratian Lup

By Adrien Hamelin | May 5, 2016 11:35 PM | Tags: performance efficiency

Visual C++ compiler evolves again:

Introducing a new, advanced Visual C++ code optimizer

by Gratian Lup

From the article:

We are excited to announce the preview release of a new, advanced code optimizer for the Visual C++ compiler backend. It provides many improvements for both code size and performance, bringing the optimizer to a new standard of quality expected from a modern native compiler.

This is the first public release and we are encouraging people to try it and provide suggestions and feedback about potential bugs. The official release of the new optimizer is expected to be Visual Studio Update 3, while the release available today is unsupported and mostly for testing purposes...