October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
By Blog Staff | Apr 24, 2014 04:00 PM | Tags: None
A nice digest-sized highlights reel of C++14:
An overview of C++14 language features
by Alex Korban
From the article:
In this post, I’m going to highlight some of the new language features in the draft of the C++14 standard. This is an excerpt from my book C++11 Rocks: VS2013 Edition. I looked at the level of C++14 support in different compilers in a previous post.
By Blog Staff | Apr 17, 2014 04:02 AM | Tags: intermediate basics
On the Oracle Tech Network, a nice reminder of the still-"new"-to-some hash-based containers, co-authored by the chair of the U.S. C++ standards committee:
Understanding the New Set and Map Containers in the C++11 Standard Library
by Steve Clamage and Darryl Gove
From the article:
One of the areas in the new C++ standard that has seen the most enhancement is the Standard Library. The functionality that is most likely to be immediately useful to developers is the additions to the container classes. This article describes the new set and map containers.
By Blog Staff | Apr 16, 2014 05:58 AM | Tags: intermediate basics
A classic on SO:
Why do we copy then move?
I saw code somewhere in which someone decided to copy an object and subsequently move it to a data member of a class. This left me in confusion in that I thought the whole point of moving was to avoid copying. Here is the example:
struct S { S(std::string str) : data(std::move(str)) {} };Here are my questions:
- Why aren't we taking an rvalue-reference to
str?- Won't a copy be expensive, especially given something like
std::string?- What would be the reason for the author to decide to make a copy then a move?
- When should I do this myself?
By Blog Staff | Apr 15, 2014 11:48 AM | Tags: basics
Quick: Would you resort to stringstream? But that's so C++98... and so hard.
More people need to know about to_string and its cousins. Marius Bancila takes us for a short tour:
The standard way of converting between numbers and strings in C++11
by Marius Bancila
From the article:
C++11 provides several standard functions for converting numbers to strings and strings to numbers, all of them available in the
<string>header.For converting numbers to strings there are two new overloaded functions:
to_string()andto_wstring(). They take one argument of various numeric types (int,long,long long,double,long double, etc.) and return either astd::stringor astd::wstringwith the number converted to text. ...For the other way around of converting strings to numbers there are several overloaded methods (taking either a
std::stringor astd::wstring): ...
By Marco Arena | Apr 15, 2014 05:01 AM | Tags: intermediate
Marco Arena points out an important difference between shared_ptr and unique_ptr regarding polymorphic deletion. The article also shows two ways to equip unique_ptr with a type-erased deleter, one with no usage of dynamic dispatching.
Ponder the use of unique_ptr to enforce the Rule of Zero
by Marco Arena
I read the article "Enforcing the Rule of Zero" from latest Overload (of ACCU) and I'd like to point out something that I misapprehended at a first reading. ... a clever point the author underlines is about polymorphic deletion: what to do when we want to support polymorphic deletion, or when our classes have virtual functions? ...
Then the author suggests to use a
shared_ptr: ...
By Blog Staff | Apr 14, 2014 03:02 PM | Tags: intermediate
Today from the desk of Andrzej:
Common Optimizations
by Andrzej Krzemieński
From the article:
Language designers, compiler and library vendors make a great effort to make your programs run faster and faster. This post is a tour of some common performance optimizations in C++.
Consider the following code that deals with
std::string: ...
By matt | Apr 10, 2014 02:26 PM | Tags: xml performance parsing intermediate efficiency advanced
Some high-performance techniques that you an use for more than just parsing, including this week's darling of memory management:
Parsing XML at the Speed of Light
a chapter from "The Performance of Open Source Applications"
by Arseny Kapoulkine
From the chapter:
This chapter describes various performance tricks that allowed the author to write a very high-performing parser in C++: pugixml. While the techniques were used for an XML parser, most of them can be applied to parsers of other formats or even unrelated software (e.g., memory management algorithms are widely applicable beyond parsers). ...
Optimizing software is hard. In order to be successful, optimization efforts almost always involve a combination of low-level micro-optimizations, high-level performance-oriented design decisions, careful algorithm selection and tuning, balancing among memory, performance, implementation complexity, and more. Pugixml is an example of a library that needs all of these approaches to deliver a very fast production-ready XML parser–even though compromises had to be made to achieve this. A lot of the implementation details can be adapted to different projects and tasks, be it another parsing library or something else entirely.
By Blog Staff | Apr 9, 2014 03:41 AM | Tags: None
Recently on SO:
What does "[ this ]" mean in C++?
When I was reading the Cocos2dx 3.0 API, I found something like this:
auto listener = [this](Event* event){ auto keyboardEvent = static_cast<EventKeyboard*>(event); if (keyboardEvent->_isPressed) { if (onKeyPressed != nullptr) onKeyPressed(keyboardEvent->_keyCode, event); } else { if (onKeyReleased != nullptr) onKeyReleased(keyboardEvent->_keyCode, event); } };What does
[this]mean? Is this new syntax in C++11?
By Blog Staff | Apr 8, 2014 01:28 PM | Tags: None
Overload 120 is now available. It contains the following C++-related articles, and more:
Juan Alday considers how the new standards have affected a common rule.
Martin Moene tries a more powerful code search tool.
Sergey Ignatchenko and Dmytro Ivanchykhin compare 32-bit and 64-bit programs.
Roger Orr sees how the stack organisation has changed.
By Blog Staff | Apr 8, 2014 12:12 PM | Tags: None
When you see anyone claim performance parity between <other language> and C++, one of the first things to look for is whether the C++ version of their test code is correctly using arrays and traversing them in order. If the test code is just doing equivalent pointer-chasing in both languages, the performance comparison is largely meaningless because the program is probably memory-bound and not properly written to use C++'s default container (vector).
Note: The question below has been modified since originally posted and now shows more reasonable numbers that demonstrate contiguous arrays are indeed faster. The comments are still enlightening to read, however.
Today on SO:
Unable to reproduce: C++ Vector performance advantages over C# List performance
At Microsoft's BUILD conference Herb Sutter explained that C++ has "Real Arrays" and C#/Java languages do not have the same or sort of.
I was sold on that. You can watch the full talk here http://channel9.msdn.com/Events/Build/2014/2-661
Here is a quick snapshot of the slide where he described this. http://i.stack.imgur.com/DQaiF.png
But I wanted to see how much difference will I make.
So I wrote very naive programs for testing, [...] Here are the results on my dell laptop with Core i7 processor:
count C# (List<string>) C# (ArrayList) C++ 1000 24 ms 21 ms 7 ms 10000 214 ms 213 ms 64 ms 100000 2 sec 123 ms 2 sec 125 ms 678 ms