Home » Blog » Categories » Articles & Books

Articles & Books

Quick Q: Why can't a data member be in a lamba capture list -- StackOverflow

By Blog Staff | May 22, 2014 12:01 PM | Tags: basics

Quick A: Because you can only capture local (stack) objects, including function parameters, and to access a data member in a member function you capture the local variable this.

Today on SO:

Why can't a data member be in a lamba capture list

I have a class foo that has bar as a member variable.

In another member function of the class, I'm writing a lambda function:

[bar](void){}

But I can't include bar in the capture list. Why is that?

Vector of Objects vs Vector of Pointers Updated -- Bartlomiej Filipek

By Blog Staff | May 22, 2014 07:30 AM | Tags: performance memory intermediate efficiency

More in the "contiguous enables fast" department:

Vector of Objects vs Vector of Pointers Updated

by Bartlomiej Filipek

From the article:

For 1000 particles we need on the average 2000 cache line reads! This is 78% more cache line reads than the first case! Additionally Hardware Prefetcher cannot figure out the pattern -- it is random -- so there will be a lot of cache misses and stalls.

In our experiment the pointer code for 80k of particles was more 266% slower than the continuous case.

ACCU 2014 talk slides now available

By Blog Staff | May 21, 2014 02:58 PM | Tags: intermediate

[Ed: Here's a candidate for the most hilarious thing you'll probably see today: Kevlin Henney's slide deck, including a link to this @netbat tweet.]

The recent ACCU 2014 was another resounding success, and many of the talk slides have now been posted. You can find them here:

Slides, Photos, Blogs via #accu2014 (accu.org)

Some fun C++ highlights with slides available include:

  • Dietmar Kuhl · Performance Choices
  • Howard Hinnant · Everything You Ever Wanted To Know About Move Semantics (and then some)
  • Hubert Matthews · Where is C++ headed?
  • Jonathan Wakely · There Ain't No Such Thing As A Universal Reference
  • Jonathan Wakely · The C++14 Standard Library
  • Kevlin Henney · Immutabilty FTW!
  • Marshall Clow · C++ Undefined Behavior -- what is it, and why should I care?
  • Olve Maudal · C++ Pub Quiz
  • Pattabi Raman · Random number generation in C++ -- present and potential future
  • Peter Sommerlad · C++14 an overview on the new standard for C++(11) programmers
  • Steve Love · Range and Elevation -- C++ in a modern world
  • ... and more (see the page).

Stopping the Spew -- Tony DaSilva

By Blog Staff | May 15, 2014 09:07 AM | Tags: None

Today on Bulldozer00:

Stopping the Spew!

by Tony DaSilva

From the article:

Every C++ programmer has experienced at least one, and most probably many, “Template Spew” (TS) moments. You know you’ve triggered a TS moment when, just after hitting the compile button on a program the compiler deems TS-worthy, you helplessly watch an undecipherable avalanche of error messages zoom down your screen at the speed of light. ...

... Fear not, because help is on the way via C++14 in the form of "concepts lite".

Quick Q: How do generic lambdas work? -- StackOverflow

By Blog Staff | May 12, 2014 08:31 AM | Tags: basics

Quick A: They generate a templated operator(), and that means you can call the same closure object with all sorts of different parameters and it just stamps out the function for each set of parameter types.

A "new classic" question on SO, classic because it was posted a year ago, but newly relevant because now the mainstream compilers are implementing the feature:

How does generic lambda work in C++14?

How does generic lambda work (auto keyword as argument type)?

Is it similar to templates where for each different argument type compiler generates functions with the same body but changed types or is it more similar to Java's generics?

Code example:

auto glambda = [](auto a) { return a; };

Fast Polymorphic Collections with Devirtualization -- Joaquín M López Muñoz

By Blog Staff | May 9, 2014 08:17 AM | Tags: intermediate

munoz.pngStill on the theme of "contiguous enables fast," a followup on the recent "Fast Polymorphic Collections" article:

Fast Polymorphic Collections with Devirtualization

by Joaquín M López Muñoz

From the article:

The poly_collection template class we implemented for fast handling of polymorphic objects can be potentially speeded up in the case where some of the derived classes it manages are known to the compiler at the point of template instantiation...

Allowing for the specification of a list of statically known derived class types as part of a poly_collection instantiation opens up possibilities for internal performance optimizations that do not impact the usage interface of this template class. The actual improvements achieved depend very much on the compiler being used, but in general are greater when passing polymorphic functors (such as generic lambdas) to for_each and qualifying virtual functions as final where possible.

Introducing emplacer -- Tim

By Blog Staff | May 9, 2014 06:44 AM | Tags: intermediate

Another nice way to have a polymorphic collection without sacrificing that performance-precious contiguous memory layout:

Introducing emplacer: allocate subtypes of an abstract base class directly in a container

by Tim

From the article:

So I complained to my friend Jeremy that C++ should be able to do this. This isn't Java, I shouldn't have to do a separate allocation for each object...

As alluded to earlier, you can also use it in containers. Here's an example:

std::vector<ShapeAny> shapes;

shapes.emplace(shapes.end())->emplace<Rect>(3, 4);
shapes.emplace(shapes.end())->emplace<Square>(3);

//emplace returns reference to *this, so you can use it like this too
shapes.push_back(ShapeAny().emplace<Rect>(5, 6));
shapes.push_back(ShapeAny().emplace<Circle>(1));

for (auto shape: shapes) {
  std::cout << shape->area() << std::endl;
}