October 25, Pavia, Italy
November 6-8, Berlin, Germany
November 3-8, Kona, HI, USA
By Blog Staff | Feb 27, 2015 07:33 AM | Tags: None
New WG21 papers are available. If you are not a committee member, please use the comments section below or the std-proposals forum for public discussion.
Document number: N4386
Date: 2015-02-24
Unspecialized std::tuple_size should be defined
by Nevin Liber
Excerpt:
This paper is wording for issue LWG 2446 / LEWG 42.
By Felix Petriconi | Feb 27, 2015 12:45 AM | Tags: boost basics
Arne Mertz goes into the details of using boost operators.
Operator Overloading – Introduction to Boost.Operators, Part 1
Operator Overloading – Introduction to Boost.Operators, Part 2
by Arne Mertz
From the articles:
In my first two posts about operator overloading I have written about the basics and common practice. This post shows some lessons from the common practice post on a concrete example and then introduces to Boost.Operators, a library that conveniently reduces the boilerplate involved when overloading multiple operators for a class.
Operators Travel in Packs
If we look at the list of operators, we see that there are about 50 of them, and many of them can be overloaded in different ways. Even if we restrict ourselves to a few operations that make sense for a given class, then one of those operations often brings two or more operators.
By Adrien Hamelin | Feb 26, 2015 02:10 PM | Tags: c++11 advanced
On the matter of having a useful error message:
SFINAE std::result_of? Yeah, right!
by Scott Prager
From the article:
Return type deduction pre-decltype and auto could really make one mad. Back then, if you wanted a function object, you had to make it "adaptable", meaning it had to inherit from
std::unary_orbinary_functionand define itsfirst_argument_type,second_argument_type, andresult_type. There had been no concept of "transparent functors" allowing us to pass polymorphic functions to higher order functions (likestd::plus<>tostd::accumulate). For an example of programming in these dark ages, check out the FC++ FAQ.
By Adrien Hamelin | Feb 25, 2015 08:00 AM | Tags: intermediate c++11
While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:
C++11 in the Wild: Techniques from a Real Codebase
by Arthur O'Dwyer
Summary of the talk:
This talk presents several reusable constructs from a production C++11 codebase, each of which would not be possible without C++11's new features. Auto() is what Alexandrescu's ScopeGuard looks like after a dozen years of C++ evolution. make_iterable() constructs a container from a pair of iterators, enabling simple "foreach" iteration over legacy containers. spaceship() is an efficient "strcmp" for tuples. Time permitting, we'll look at some more arcane code samples.
By Adrien Hamelin | Feb 23, 2015 02:39 PM | Tags: c++11 basics
If you are confused about the topic, read this article:
Type Deduction and Braced Initializers
by Arne Mertz
From the article:
I just finished watching a talk from CppCon 2014 by Scott Meyers: Type Deduction and Why You Care. All in all it was a very interesting and entertaining talk, and I learned a thing or two, especially about the combination of type deduction and braced initializers. Since this blog is about simplifying the use of C++, I want to have a short look at that special combination and derive a rule of thumb from it...
By Adrien Hamelin | Feb 23, 2015 02:32 PM | Tags: c++11 basics
Here is a useful thing to know that appeared with C++11:
Non Static Data Members Initialization
by Bartlomiej Filipek
From the article:
My short summary for non static data members initialization from modern C++. A very useful feature. Should we use it or not?
By Adrien Hamelin | Feb 23, 2015 08:00 AM | Tags: advanced
While we wait for CppCon 2015 in September, we’re featuring videos of some of the 100+ talks from CppCon 2014. Here is today’s feature:
Using C++ on Mission and Safety Critical Platforms
by Bill Emshoff
Summary of the talk:
The Joint Strike Fighter (JSF) is the first major DOD aircraft program to use C++. Much of this software is either safety critical or mission critical and so must be written in such a way as to be clear, readable, unambiguous, testable, and maintainable. We discuss the driving requirements behind the standard and its evolution. We give a quick overview of our standard and discuss how it differs from later standards such as MISRA C++. We discuss lessons learned over our nine year history of applying the standard to a large embedded software program. We also address ambiguities in rules and difficulties with automated checking of conformance with the standard.
By Vittorio Romeo | Feb 23, 2015 06:35 AM | Tags: intermediate c++11
Almost every C++ application and game deals with entity management.
Video Tutorial -- Handle-based entity management
By Vittorio Romeo
From the tutorial:
Entities are usually self-contained objects that...
- ...store data and/or logic.
- ...are tied a specific concept (e.g. an UI widget, or a 3D model).
- ...we need to keep track of.
- ...can either be alive or dead.
- ...are extremely often used in groups.
Problem: we need to keep track of specific entity instances, and iterate on every instance. We also need to remove dead entities and add new entities.
Keeping track of specific instances is easily solved with pointers and smart pointers.
Fast-iteration of a group of objects with the same type is achieved with cache-friendly memory locality and no indirection.
Adding and removing entities stored in a cache-friendly manner invalidates existing pointers.How can we facilitate instance tracking/addition/removal and still allow fast iteration?
In this video, we will create a generic container that stores objects in a cache-friendly way, allows to keep track of specific object instances and also allows addition and removal of entities.
By Mantosh Kumar | Feb 21, 2015 10:38 PM | Tags: None
Published on InformIT in which John Lakos interviews Alexander Stepanov and Daniel Rose about various aspects of generic programming and modern C++.
From Mathematics to Generic Programming: An Interview with Alexander Stepanov and Daniel Rose
John Lakos interviews Alexander Stepanov and Daniel Rose, authors of From Mathematics to Generic Programming, on their new book, why it applies to everyday programmers, and their positions on some closely related technical issues — including value semantics, concepts, contracts, and polymorphic memory resources — facing the C++ Standards Committee today.
By Mantosh Kumar | Feb 21, 2015 09:09 PM | Tags: None
This article talks about how modern C++ idioms could be used to avoid memory leak and errors.
Fighting off memory leaks and errors (C++11)
by Kacper Kolodziej
From the article:
Modern tools provided with C++11's standard library make fight with memory leaks and errors easier and more effective. Sometimes problems which are seemingly not dangerous might put an end to your application. We are going to learn how to find and avoid them.