February 10-15, Hagenberg, Austria
March 19-21, Madrid, Spain
April 1-4, Bristol, UK
June 16-21, Sofia, Bulgaria
By Adrien Hamelin | Jul 23, 2019 11:36 AM | Tags: stl intermediate
Continuing.
More Rules to the Regular Expression Library
by Rainer Grimm
From the article:
There is more to write to the usage of regular expressions than I wrote in my last post The Regular Expression Library. Let's continue...
By Adrien Hamelin | Jul 16, 2019 11:31 AM | Tags: stl intermediate
Quick A: the difference is in the performance and the behaviour in case an element is not already inserted.
Recently on SO:
insert vs emplace vs operator[] in c++ map
In the particular case of a map the old options were only two: operator[] and insert (different flavors of insert). So I will start explaining those...
By Adrien Hamelin | Jul 16, 2019 11:15 AM | Tags: stl intermediate
A quick introduction.
The Regular Expression Library
by Rainer Grimm
From the article:
My original plan was it to write about the rules of the C++ Core Guidelines to the regex and chrono library, but besides the subsection title, there is no content available. I already wrote a few posts about time functionality. So I'm done. Today, I fill the gap and write about the regex library.
By Adrien Hamelin | Jul 8, 2019 10:42 AM | Tags: intermediate c++11
Quick A: the result is the same as calling the function you're forwarding to directly.
Recently on SO:
Concise explanation of reference collapsing rules requested: (1) A& & -> A& , (2) A& && -> A& , (3) A&& & -> A& , and (4) A&& && -> A&&
The reference collapsing rules (save for A& & -> A&, which is C++98/03) exist for one reason: to allow perfect forwarding to work...
By Adrien Hamelin | Jun 24, 2019 01:19 PM | Tags: intermediate
Simple and efficient.
A simple workaround for the fact that std::equal takes its predicate by value
by Raymond Chen
From the article:
The versions of the std::equal function that takes a binary predicate accepts the predicate by value, which means that if you are using a functor, it will be copied, which may be unnecessary or unwanted.
In my case, the functor had a lot of state, and I didn’t want to copy it....
By Adrien Hamelin | Jun 11, 2019 01:45 PM | Tags: intermediate community
The series continue.
C++ Core Guidelines: Avoid Bounds Errors
by Rainer Grimm
From the article:
When you access an element outside a container of the STL, the result is not so promising. You effect may be an error or undefined behaviour. Undefined behaviour means all bets are open...
By Adrien Hamelin | Jun 10, 2019 12:22 PM | Tags: intermediate community
Quick A: read the SO FAQ.
Recently on SO:
What are the basic rules and idioms for operator overloading?
- The General Syntax of operator overloading in C++
- The Three Basic Rules of Operator Overloading in C++
- The Decision between Member and Non-member
- Common operators to overload
- Overloading new and delete
...
By Adrien Hamelin | Jun 4, 2019 11:04 AM | Tags: intermediate c++14
Quick A: mostly for exception safety.
Recently on SO:
Differences between std::make_unique and std::unique_ptr with new
The motivation behind make_unique is primarily two-fold:
make_unique is safe for creating temporaries, whereas with explicit use of new you have to remember the rule about not using unnamed temporaries.
foo(make_unique<T>(), make_unique<U>()); // exception safe foo(unique_ptr<T>(new T()), unique_ptr<U>(new U())); // unsafe*The addition of make_unique finally means we can tell people to 'never' use new rather than the previous rule to "'never' use new except when you make a unique_ptr".
There's also a third reason:
make_unique does not require redundant type usage. unique_ptr<T>(new T()) -> make_unique<T>()None of the reasons involve improving runtime efficiency the way using make_shared does (due to avoiding a second allocation, at the cost of potentially higher peak memory usage).
By Adrien Hamelin | Jun 4, 2019 11:01 AM | Tags: intermediate
Quick A: See below
Recently on SO:
With arrays, why is it the case that a[5] == 5[a]?
The C standard defines the [] operator as follows:
a[b] == *(a + b)Therefore a[5] will evaluate to:
*(a + 5)and 5[a] will evaluate to:
*(5 + a)a is a pointer to the first element of the array. a[5] is the value that's 5 elements further from a, which is the same as *(a + 5), and from elementary school math we know those are equal (addition is commutative).
By Adrien Hamelin | Jun 3, 2019 11:47 AM | Tags: stl intermediate
What do you think?
The Difference Between std::copy_backward and std::copy with Reverse Iterators
by Jonathan Boccara
From the article:
A couple of months ago, I made a talk at the ACCU conference about learning every algorithm there is in the STL. Amongst them, we covered std::copy_backward, that makes a copy of a source range to a destination range, starting from its end and working its way back to the beginning.
In the questions session at the end of the talk, attendant Oscar Forner rose an interesting point: is there any difference between performing a std::copy_backward versus performing a simple std::copy on the reverse iterators from the source collection?