Quick Q: Why can’t a data member be in a lamba capture list—StackOverflow

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?

N3976: Multidimensional bounds, index and array_view, revision 2—Ɓukasz Mendakiewicz, Herb Sutter

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3976

Date: 2014-05-21

Multidimensional bounds, index and array_view, revision 2

by Łukasz Mendakiewicz and Herb Sutter

Excerpt:

The feedback we have received during the Issaquah meeting was to prepare the wording for the proposal as-is. Consequently, only the wording (with minor improvements) is provided in this version. Interested readers should find the rationale, background information and design discussion in the previous revision of the proposal, viz. N3851.

C++Now 2014 talk slides now available

Many of the slides from last week's sold-out C++Now event are now posted on GitHub at the link below, and more are still being added.

If you missed C++Now this year, head over to check out the new CppCon coming this September...

C++Now 2014 Presentations

Tuesday, May 13

Library in a Week - c++ templating engine

Keynote: Axiomatic Programming: From Euclidean Deductions to C++ Templates and Beyond

C++14: Through the Looking Glass

Coroutines, Fibers, and Threads, Oh My

The Canonical Class

ConceptClang: Theoretical Advances with Full C++ Concepts

Generic Programming of Generic Spaces: Compile-Time Geometric Algebra with C++11

Test-Driven Development With Boost.Test and Turtle Mock, Part I/II

Removing undefined behavior from integer operations: the bounded::integer library

Value Semantics and Range Algorithms - Composability and Efficiency

Preparing the C++11 Library AFIO for Boost Peer Review

Wednesday, May 14

MPL11: A New Metaprogramming Library for C++11

The Optimization of a Boost.Asio-Based Networking Server

Undefined Behavior in C++; what is it, and why should I care

Mach7: The Design and Evolution of a Pattern Matching Library for C++

Practical Type Erasure: A boost::any Based Configuration Framework

A Tutorial Introduction to C++11/14 Part I/II

C++11 in Space Plasma Model Development

C++11 Library Design

Goals for Better Code: Implement Complete Types

Multiplatform C++

Octopus: A Policy-Driven Framework for CFD Simulations

Thursday, May 15

Keynote: Beware of C++

Interactive Metaprogramming Shell Based on Clang

libcppa: Type-safe Messaging Systems in C++

Unicode in C++

CppComponents: A Modern Portable C++11 Component System

UI. Aesthetics. C++

Accelerator Programming with C++ AMP

Designing XML API for Modern C++

Modern C++ as Concurrent Assembly

Understanding &&

Boost Library Incubator | Zip Archive

Friday, May 16

Iterators May Stay | LibreOffice File

Value Semantics: It ain't about the syntax!

Create Your Own Refactoring Tool with Clang

How to Design C++ Implementations of Complex Combinatorial Algorithms

Intro to Functional Programming in C++

Managing Object Lifetimes

0xBADC0DE

Expected — An Exception-friendly Error Monad

Lifetime and Usage of Global, Thread-local, and Static Data

Functional Data Structures in C++

Asynchronous Programming Using Boost.MetaStateMachine and the Upcoming Asynchronous Library

Ownership of Memory in C++

Saturday, May 17

The Future of Accelerator Programming in C++

Functional Reactive Programming - Cleanly Abstracted Interactivity

Disambiguation: The Black Technology

My Thoughts on Large Code Base Change Ripple Management in C++

Future of Boost: Boostache

Future of Boost: Community Management Team

N3975: URI - Proposed Wording (Revision 5)—Glyn Matthews and Dean Michael Berris

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3975

Date: 2014-05-22

URI - Proposed Wording (Revision 5)

by Glyn Matthews and Dean Michael Berris

Excerpt:

Revisions to N3947

  1. Numerous updates to wording and style to make it more compatible with the standard document.
  2. Removed string_type member typedef for the uri class.
  3. Improved specification of the definition of port [uri.definition.port].
  4. Updated [uri.requirements] to be the same as the filesystem proposal.
  5. Renamed uri_error_code to uri_errc [class.uri_errc].
  6. Added an additional sentence in [uri.scope] to describe the uri_errc enum.
  7. Made member functions constexpr and noexcept, where appropriate.
  8. Improved specification of equality and comparison operators [uri.header-synopsis.equality-comparison].
  9. Added a section describing uri encoding conversions [class.uri.conversions]
  10. Added some sentences on make_error_code, make_error_condition and uri_category [uri.header-synopsis.error-handling].
  11. Updated uri_builder.
  12. Improved specification for to_uri and to_filesystem_path to handle the case where the URI or filesystem path is relative [uri.header-synopsis.filesystem-interop].

Vector of Objects vs Vector of Pointers Updated—Bartlomiej Filipek

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.

N4015: A proposal to add a utility class to represent expected monad—V. Escriba and P. Talbot

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N4015

Date: 2014-05-20

A proposal to add a utility class to represent expected monad

by Vicente J. Botet Escriba and Pierre Talbot

Excerpt:

Class template expected<E,T> proposed here is a type that may contain a value of type T or a value of type E in its storage space. T represents the expected value, E represents the reason explaining why it doesn't contains a value of type T, that is the unexpected value. Its interface allows to query if the underlying value is either the expected value (of type T) or an unexpected value (of type E). The original idea comes from Andrei Alexandrescu C++ and Beyond 2012: Systematic Error Handling in C++ talk. The interface and the rational are based on std::optional N3793 and Haskell monads. We can consider that expected<E,T> is a generalization of optional<T> providing in addition a monad interface and some specific functions associated to the unexpected type E. It requires no changes to core language, and breaks no existing code.

N3989: Working Draft, Technical Specification for C++ Extensions for Parallelism—Jared Hoberock

A new WG21 paper is available. A copy is linked below, and the paper will also appear in the next normal WG21 mailing. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.

Document number: N3989

Date: 2014-05-23

Working Draft, Technical Specification for C++ Extensions for Parallelism

by Jared Hoberock

Excerpt:

This Technical Specification describes requirements for implementations of an interface that computer programs written in the C++ programming language may use to invoke algorithms with parallel execution. The algorithms described by this Technical Specification are realizable across a broad class of computer architectures. ... The goal of this Technical Specification is to build widespread existing practice for parallelism in the C++ standard algorithms library.

ACCU 2014 talk slides now available

[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).

Qt 5.3 released

 

Qt 5.3 is now available.

Qt is the most widely-known and -used portable UI framework for C++. It offers native code performance and modern sophisticated user experiences across desktop, embedded, and mobile platforms. Both commercial and open source versions are available.

More details from the Qt 5.3 product page:

With Qt 5.3 a lot of effort was put into enhancing the overall quality and user experience across all the platforms. Qt 5.2 introduced a completely new dimension into cross-platform: the mobile platforms and it has been downloaded an amazing amount of more than 1 million times!

...

  • Added Qt Positioning API support for Android and iOS. Use the GPS directly from convenient Qt APIs!
  • Qt Bluetooth API has now support for Android as well
  • Printing support for Qt has been greatly enhanced
  • Qt 5.3 ships with Qt Creator 3.1, which also introduced a lot of enhancements and stability to existing features as well as an initial support for WinRT tooling, a new clang-based code model and improved Android tool chain integration.

CppCon: My Proposed Talks (Part 2)—Herb Sutter

cppcon-108.PNGFollowing up on Herb's three talk proposals posted yesterday, the other two titles and abstracts are now posted, this time of new talks (note: again, pending review and selection by the program committee, so this is not final -- they may or may not be selected if there is stronger material).

CppCon: My Proposed Talks (Part 2)

by Herb Sutter

From the post:

GC for C++, and C++ for GC: “Right” and “Wrong” Ways to Add Garbage Collection to C++ (1 to 2 hours)

"Garbage collection is essential to modern programming!" "Garbage collection is silly, who needs it!"

As is usual with extremes, both of these statements are wrong. Garbage collection (GC) is not needed for most C++ programs; we're very happy with determinism and smart pointers, and GC is absolutely penalizing when overused, especially as a default (or, shudder, only) memory allocator. However, the truth is that GC is also important to certain high-performance and highly-concurrent data structures, because it helps solve advanced lock-free problems like the ABA problem better than workarounds like hazard pointers.

This talk presents thoughts about how GC can be added well to C++, directly complementing (not competing with) C++'s existing strengths and demonstrating why, as Stroustrup says, "C++ is the best language for garbage collection."

 

Addressing C++’s #1 Problem: Defining a C++ ABI (1 hour)

"Why can't I share C++ libraries even between my own internal teams without using the identical compiler and switch settings?" "Why are operating system APIs written in unsafe C, instead of C++?" "Why can’t I use std::string in a public shared library interface; it's the C++ string, isn't it?!"

These and more perennial questions are caused by the same underlying problem: For various historical reasons, C++ does not have a standard binary interface, or ABI. Partial solutions exist, from the Itanium ABI which addresses only the language and only on some platforms, to COM and CORBA which do both less and far more than is needed.

It is deeply ironic that there actually is a way to write an API in C++ so that it has a de facto stable binary ABI on every platform: extern "C".

This session describes current work driven by the presenter to develop a standard C++ ABI. This does not mean having identical binaries on all platforms. It does mean tackling all of the above problems, including directly addressing the #1 valid reason to use C instead of C++, and removing a major obstacle to sharing binary C++ libraries in a modern way.