October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
By Adrien Hamelin | Jan 16, 2015 03:32 PM | Tags: intermediate c++11
Here is a follow-up on a previous article about a simple signal system:
An update on “A simple signal system”
by Adrien Hamelin
From the article:
Almost a month ago from now (already), I wrote a post about “A simple signal system“. Check it out if you have not already, as in this post I will speak a little further about it...
By Blog Staff | Jan 16, 2015 02:08 PM | Tags: None
A fresh here's-the-code-spot-the-performance-problem analysis.
Why does a single integer assignment statement consume all of my CPU?
by Raymond Chen
From the article:
Profiling showed that over 80% of the time spent by
CalculateTheValuewas inside theSetInt32method call, in particular on the line*reinterpret_cast<int32_t *>(m_data) = value;Why does it take so much time to store an integer to memory, dwarfing the actual computation to calculate that integer?
Spoiler hint: [Chaotic neutral]
By Felix Petriconi | Jan 16, 2015 01:55 AM | Tags: basics
Arne Mertz describes in a series of articles the principles of operator overloading.
Operator Overloading
Operator Overloading: Common Practice
by Arne Mertz
From the articles:
Operators can be used to make user defined classes act like known types, e.g. like numbers, pointers and iterators. That way they facilitate the usage of those classes. They can also be used to make your objects do whatever you want them to do, for example build structures that save the operations for later evaluation. The latter is especially useful for building embedded DSLs and gives enough subject matter for a whole series of blog posts. [The first] post will cover the former use of operator overloading, i.e. writing operators that behave like “normal” operators.
... In [the second] post I will go into the details and write a bit about each operator and how a straight forward implementation might look if the operator is meant to work similar to built in operators.
By Mantosh Kumar | Jan 15, 2015 06:18 PM | Tags: None
A complementary guideline to help to simplify the application code, without risking resource management issues.
The Rule of Zero
In a previous article – "The Rule of the Big Four (and a half)" we looked at resource management policies in C++.
Resource management is the general term for using the mechanisms in C++ to ensure that resources – files, dynamic memory, sockets, mutexes, etc – have their lifetimes automatically controlled so as to prevent resource leaks, deadlocks, etc. C++ refers to these mechanisms as RAII/RDID ( “Resource Acquisition Is Initialisation / Resource Destruction is Deletion”)
In this article we’ll have a look at a complementary guideline to help simplify your application code, without risking resource management issues – The Rule of Zero.
If you’re not familiar with the concepts of resource management I’d highly recommend having a look at the whitepaper before reading on.
By Meeting C++ | Jan 15, 2015 07:32 AM | Tags: community c++14 basics
My yearly overview on the things that might come:
C++ in 2015
by Jens Weller
From the article:
The year is still young, so lets have an outlook about what is going to happen in C++ Land in 2015...
By Mantosh Kumar | Jan 14, 2015 06:58 PM | Tags: None
Discussion on how to use/replace auto for loop index variables.
Reader Q&A: auto and for loop index variables
by Herb Sutter
From the reader's question:
So I’ve been reading all I can about c++11/c++14 and beyond when time permits. I like auto, I really do, I believe in it. I have a small problem I’m trying to decide what to do about. So in old legacy code we have things like this:
for (int i = 0; i < someObject.size(); i++) { … }
By Adrien Hamelin | Jan 14, 2015 03:26 PM | Tags: intermediate c++11
Sasha Goldshtein begins to show us how to implement the basis of a useful tool from the STL: the tuple.
Implementing std::tuple From The Ground Up – Part 1
by Sasha Goldshtein
From the article:
std::tuple is a very nice facility originally introduced in C++ TR1. It is a heterogenous container of elements that has a statically known size. In C++ 11, std::tuple can be implemented using variadic templates; a single std::tuple class can support an arbitrary number of template type arguments. In this series of blog posts we will implement std::tuple from first principles. The purpose of this exercise is not to provide the best-performing or most-conformant tuple implementation, but rather to see what foundational concepts are required to implement it...
By Blog Staff | Jan 14, 2015 11:37 AM | Tags: None
Toward using a more modern C++ compiler:
Raspberry Pi -- Install GCC 4.9 and compile C++14 programs
by Sol
From the article:
... I will show you next how to install only GCC 4.9 and his dependencies from Jessie and keep Wheezy as the default source for all the other packages. I’ve tested the next steps on a Raspberry Pi revision B+, but it should work on older models too...
By Blog Staff | Jan 14, 2015 10:33 AM | Tags: intermediate
Quick A: Inherit from enable_shared_from_this.
Recently on SO:
Cast 'this' to std::shared_ptr
I have a method on a class to make a particular instance an "active" instance:
void makeActive() { activeInstance = this; }However it doesn't work since
activeInstancehas typestd::shared_ptr< ClassName >. How can I cast this tostd::shared_ptr<ClassName>?
By Blog Staff | Jan 14, 2015 10:24 AM | Tags: None
Slides are now available from last month's Belgian C++ user group meeting:
Slides of the 17th of December 2014 BeCPP Meeting
by Marc Gregoire
There were two talks -- kudos for the pun in the second talk title: