By fj | Dec 5, 2016 04:09 AM | Tags: c++11 basics
Using fundamental types to do "simple things simple" fits very well in the most of cases.
Basic dependent typing
by Krzysztof Ostrowski
From the article:
If we assume that our application uses only a subset of values carried by given fundamental type, we are likely to get warning from the compiler. We shall take that warning seriously. How to inform type system about our assumptions? Example solutions follow.
By Meeting C++ | Dec 1, 2016 09:17 AM | Tags: community
The monthly list of upcoming C++ User Group meetings:
C++ User Group meetings in December
by Jens Weller
From the article:
In total its already 30 groups which are meeting, also there are 10 new groups since the last posting:
Minsk, London, Melbourne, Karlsruhe, Ulm (Qt), San Diego, Belgrade, Luxembourg, Dallas FW, Plano.
By Adrien Hamelin | Nov 29, 2016 02:25 PM | Tags: intermediate
Something we should be aware of:
The One-Definition Rule
by Andrzej Krzemieński
From the article:
We have been hit by the same bug twice already this year. It ends in a crash, and it took developers days to find it (in each case), even though it is reproducible on each run of unit tests. The code, after significant simplifications, looks like this:
namespace tests { struct Fixture { std::vector<int> v1; std::vector<int> v2; static Fixture create(); }; TEST_CASE(test1) { auto fixture = Fixture::create(); std::cout << "running test1"; } }
By Adrien Hamelin | Nov 29, 2016 01:57 PM | Tags: intermediate community
The series continue:
Why you should use Boost.MultiIndex (Part II)
by David Gross
From the article:
A few weeks ago, I posted the first part of this article, where I explained the advantages of Boost.MultiIndex over the standard containers when you need to have multiple views on a set of data.
In this second part, I would like to talk about the benefits you can get from using Boost.MultiIndex as a single-index hash table, as a replacement of
std::unordered_map.One interesting and powerful aspect of Boost.MultiIndex is that it allows you to add an index of type T, where T is different from the stored type. And it is more frequent and useful that you could think.
By Adrien Hamelin | Nov 28, 2016 12:33 PM | Tags: experimental advanced
With the next version of C++.
Compose and curry as folds
by Nick Athanasiou
From the article:
In a previous post we introduced C++17 fold expressions and described a way to extend them for arbitrary callables. Implementation details don’t matter for what we’re elaborating on here but it should be clear that (given the tools we developed) the following is possible:
(Op<F>(args) + ...) (... + Op<F>(args))
By bfilipek | Nov 27, 2016 10:22 AM | Tags: None
An example of a refactoring where variadic templates were used.
Variadic Templates and a Factory Function
by Bartlomiej Filipek
From the article:
Variadic Templates from C++11 is probably not a feature that you use on a daily basis. But recently, I’ve come across one refactoring example where I’ve decided to give a try and apply variadics.
By Marco Arena | Nov 27, 2016 02:54 AM | Tags: community
My experience at the latest standard meeting in Issaquah:
Peeking into the latest ISO C++ Standard Meeting for a half-day
by Marco Arena
From the article:
You probably know that the committee is divided into a few working and study groups – WG and SG. The working groups are Evolution, Library Evolution, Library, and Core...
By Marco Arena | Nov 26, 2016 05:46 AM | Tags: visual studio intermediate c++17
In this article, Marius shortly looks at the new standard library features from Visual C++ 2017:
New standard library features in Visual C++ 2017 RC
by Marius Bancila
From the article:
The new Visual C++ 2017, currently in release candidate phase, provides a series of updates and fixes to both the C++ compiler and the standard library...
By Jonas Devlieghere | Nov 24, 2016 08:49 AM | Tags: None
Guaranteed Copy Elision deserves some attention!
Guaranteed Copy Elision
by Jonas Devlieghere
From the article:
The new C++17 standard brings many exciting new features. A smaller, more subtle improvement it brings is guaranteed copy elision. The keyword is guaranteed, as copy elision itself has always been part of the standard. Although it might not be a change as radical as, say, structured bindings, I'm very happy to see it made it into the standard.
By bfilipek | Nov 24, 2016 08:48 AM | Tags: None
Try using IIFE to do a complex initialization of a const variable.
<img alt="IFFE for complex initialization" data-cke-saved-src="https://1.bp.blogspot.com/-9WW-Z66fu78/WB-KKBbQ7SI/AAAAAAAACwI/JhwPEgx4L9sF18ypVHBUJSPSY-X4n7DXACLcB/s1600/iife.png" src="https://1.bp.blogspot.com/-9WW-Z66fu78/WB-KKBbQ7SI/AAAAAAAACwI/JhwPEgx4L9sF18ypVHBUJSPSY-X4n7DXACLcB/s1600/iife.png" 523px;="" height:="" 140px;"="" style="float: right; height: 62px; width: 230px;">
IIFE for Complex Initialization
by Bartlomiej Filipek
From the article:
How do you initialize your variables, especially the const ones? What do you do when the code for the initialization is complicated? Do you move it to other method or just write inside the current scope?