Quick Q: Why does this function take a parameter by value? -- StackOverflow

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?

The standard way of converting between numbers and strings in C++11 -- Marius Bancila

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() and to_wstring(). They take one argument of various numeric types (int, long, long long, double, long double, etc.) and return either a std::string or a std::wstring with the number converted to text. ...

For the other way around of converting strings to numbers there are several overloaded methods (taking either a std::string or a std::wstring): ...

Ponder the use of unique_ptr to enforce the Rule of Zero -- Marco Arena

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: ...

CppCon 2014 super early bird almost sold out -- ~20 tickets left

By Blog Staff | Apr 15, 2014 04:10 AM | Tags: intermediate basics advanced

If you've been thinking of registering for CppCon, you can save by doing it in the next couple of days. Over at CppCon.org, Boris Kolpackov reports:

Super Early Bird Last Chance

In the past couple of weeks a lot of C++ enthusiasts have registered for CppCon 2014 and as a result we only have about 20 super early bird entries left. If you are planning to attend, this is your last chance to register at the most affordable price.

After the limited Super Early Bird is full, Early Bird registration will be available until the end of June. Student registrations are also available at a heavily subsidized rate to ensure students can take advantage of the program.

See also the Call For Submissions to see the kinds of topics that you can expect to see covered.

Common Optimizations -- Andrzej Krzemieński

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: ...

Parsing XML at the Speed of Light--Arseny Kapoulkine

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.

Continue reading...

What does [this] mean in C++? -- StackOverflow

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?

Overload 120 is now available

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:

Overload 120

Enforcing the Rule of Zero

Juan Alday considers how the new standards have affected a common rule.

Search with CppCheck

Martin Moene tries a more powerful code search tool.

Size Matters

Sergey Ignatchenko and Dmytro Ivanchykhin compare 32-bit and 64-bit programs.

Windows 64-bit Calling Conventions

Roger Orr sees how the stack organisation has changed.

Are contiguous C++ arrays really faster than Java/C# ArrayLists? -- StackOverflow

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

C++ and Beyond Road Show 2014 -- September 29 - October 1, Stuttgart, Germany

By Blog Staff | Apr 7, 2014 09:05 AM | Tags: intermediate advanced

Today on the C++ and Beyond blog, Scott Meyers announced that registration is now open for a C&B event in Germany this fall, largely repeating the C&B December 2013 material for the benefit of those who were not able to attend the sold-out event in December.

C&B 2014: September 29 - October 1 in Stuttgart!

with Scott Meyers, Herb Sutter, Andrei Alexandrescu

Maritim Hotel, Stuttgart, Germany
September 29 - October 1, 2014

Note: The web page for the event is in German, but the seminar itself will be given in English.

From the announcement:

You can think of this event as the C&B Road Show, because the organization is a little different from how we’ve done things in the past: Most of the talks will be updated versions of the presentations we gave at C&B 2013. (See the schedule here.) If you were unable to attend C&B this past December, this is your chance to see what you missed. ... [See the] web page for C&B 2014 for all the details of this event.

This will be the only C&B in 2014, so we hope to see you in Stuttgart at the end of September for the first-ever C&B in Europe!