Is Moving Objects Worth the Hassle? -- Andrew Koenig

By Blog Staff | Jul 26, 2013 11:06 AM | Tags: basics

Koenig's latest just went live at DDJ:

Is Moving Objects Worth the Hassle?

by Andrew Koenig

From the article:

Last week, I discussed how C++ compilers use overloading to decide whether to move or copy an object. This week, I'd like to take a step back and discuss why moving instead of copying is worth doing in the first place.

You might think that this claim needs no justification. After all, copying takes time; so programs that copy a lot of data will be slower than programs that avoid doing so. However, this kind of unthinking optimization can lead to trouble. For example...

The Universal Reference/Overloading Collision Conundrum -- Scott Meyers

By NoSenseEtAl | Jul 24, 2013 07:22 AM | Tags: intermediate

[Blog suggestion by NoSenseEtAl. Text below added by editor.]

Scott Meyers gave a well-received "beta" talk last week at NWCPP on the topic below, which he described as the most complex Item he's encountered as he prepares his upcoming book Effective C++11/14:

The Universal Reference/Overloading Collision Conundrum

by Scott Meyers

Abstract:

To help address the confusion that arises when rvalue references become lvalue references through reference collapsing, Scott Meyers introduced the notion of "universal references." In this presentation, he builds on this foundation by explaining that overloading functions on rvalue references is sensible and useful, while seemingly similar overloading on universal references yields confusing, unhelpful behavior. But what do you do when you want to write a perfect forwarding function (which requires universal references), yet you want to customize its behavior for certain types? If overloading is off the table, what's on? In this talk, Scott surveys a variety of options.

Though Scott will give a one-slide overview of the idea behind universal references at the beginning of the presentation, attendees are encouraged to familiarize themselves with the notion in more detail prior to the talk. Links to written and video introductions to universal references are available here.

The Point of No Return -- bulldozer00

By Blog Staff | Jul 24, 2013 04:20 AM | Tags: basics

A cute nugget about [[noreturn]]:

The Point of No Return

by bulldozer00

As part of learning the new feature set in C++11, I stumbled upon the weird syntax for the new “attribute” feature: [[ ]]. One of these new C++11 attributes is [[noreturn]]. ...

C++'s Best Feature -- Andrzej Krzemieński

By Blog Staff | Jul 18, 2013 05:07 PM | Tags: basics

Andrzej's title is not only catchy, but completely correct (we politely disagree with your final disclaimer, sorry Andrzej): Deterministic lifetime with destructors is C++'s best feature, and very underappreciated. Like most wonderful things, you appreciate it most when it's gone, namely when you're using another language where it's absent.

C++'s best feature

by Andrzej Krzemieński

From the article:

C++, if you want to learn all of it, is big, difficult and tricky. If you look at what some people do with it, you might get scared. New features are being added. It takes years to learn every corner of the language.

But you do not need to learn all of it. Effective use of C++ requires only the knowledge of a couple of its essential features. In this post, I am going to write about one C++ feature that I consider one of the most important. The one that makes me choose C++ rather than other popular programming languages. ...

Sometimes You Must Violate an Abstraction to Maintain It -- Andrew Koenig

By Blog Staff | Jul 17, 2013 01:55 PM | Tags: basics

Koenig explains std::move as, well, just a bit of a fib, really:

Sometimes You Must Violate an Abstraction to Maintain It

by Andrew Koenig

From the article:

What std::move really does is to return its argument as an rvalue reference. In effect, every time we use std::move, we are telling a lie. In this case, by writing std::move(t.s), we are saying that we want to use t.s, but to do so in a way that treats t.s as an rvalue. It is acceptable for us to tell this lie for exactly the same reason that it is acceptable for us to cast t.s to string&& in the previous example: We know that t.s is a member of t, and t really refers to an rvalue in our caller's context.

We can tell such lies any time we are willing to take responsibility for the consequences. ...

How the C++ Compiler Decides to Move Objects -- Andrew Koenig

By Blog Staff | Jul 15, 2013 04:18 AM | Tags: basics

Recently at Dr. Dobb's:

How the C++ Compiler Decides to Move Objects

by Andrew Koenig

From the article:

After reading this post, you should be able to figure out what std::move does, although not necessarily how it does it...

C++11/14 Training Materials -- Scott Meyers

By Blog Staff | Jul 13, 2013 04:59 PM | Tags: intermediate basics

C++14 is still very much a draft -- it only became feature-complete in April and is now in its primary comment ballot. But interest in this new standard is high, with a restarted "Guru of the Week" series focusing on C++14 and now Scott Meyers has produced the first book-like materials that include significant coverage of C++14.

C++11 Training Materials Updated -- Now With C++14 Info!

For the seventh time since originally releasing them over three years ago, I've updated my annotated training materials for "The New C++". Until this update, "the new C++" referred to C++11, but with this revision, I'm including treatment of several features from draft C++14 that I believe will make it into the new new standard. As far as I know, this makes my training materials the first "book-like" publication that covers features in C++14.

What are “rvalue references for *this” for? -- StackOverflow

By Blog Staff | Jul 11, 2013 05:33 AM | Tags: intermediate

Readers ask:

What are “rvalue references for *this” for?

What are the most typical use cases of "rvalue references for *this" which the standard also calls reference qualifiers for member functions?

By the way, there is a really good explanation about this language feature here.

Optimizing C++ Code: Constant-Folding -- Jim Hogg

By Blog Staff | Jul 10, 2013 08:18 AM | Tags: optimization intermediate

The Visual C++ Team Blog has been publishing an article series about optimizations that C++ compilers perform for you under the covers to make your code more efficient. This short nugget answers a question people sometimes ask: "What's constant folding, and why do I care?"

Optimizing C++ Code: Constant-Folding

by Jim Hogg

From the article:

This post examines Constant-Folding -- one of the simplest optimizations performed by the VC++ compiler.  In this optimization, the compiler works out the result of an expression while it is compiling (at “compile-time”), and inserts the answer directly into the generated code.  This avoids the cost of performing those same calculations when the program runs (at “runtime”).

Here is an example...

Working with Dynamic Memory in C++ -- Stan Lippman, Josée Lajoie, Barbara Moo

By Blog Staff | Jul 9, 2013 09:57 AM | Tags: basics

A chapter worth reading on InformIT, excerpted from C++ Primer 5th Edition:

Working with Dynamic Memory in C++

by Stan Lippman, Josée Lajoie, Barbara Moo

C++ lets you allocate objects dynamically. The authors of C++ Primer discuss why properly freeing dynamic memory is a rich source of bugs, and how the new library defines smart pointers -- shared_ptr, unique_ptr, and weak_ptr -- that make managing dynamic memory much safer.