N4087: Multidimensional bounds, index and array_view, revision 3 -- Łukasz Mendakiewicz, Herb Sutter

By Blog Staff | Jul 1, 2014 08:04 PM | Tags: None

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

Date: 2014-07-01

Multidimensional bounds, index and array_view, revision 3

by Łukasz Mendakiewicz and Herb Sutter

Excerpt:

Overview

Revision 3 incorporates the feedback received in Rapperswil from LEWG and some other minor fixes: ...

Acknowledgements

Thanks to Stephan T. Lavavej and the members of LEWG for the suggested improvements. Thanks to the interlocutors at ISO C++ Standard -- Future Proposals forum for the valuable feedback. Thanks to all correspondents expressing feedback in private emails.

POCO Development Release 1.5.3 Available -- Guenter Obiltschnig

By Blog Staff | Jul 1, 2014 02:34 PM | Tags: None

A minor update of POCO is available with some new functionality. Release 1.5.3 is planned to be the last in the series of 1.5.x development releases. Next is 1.6.0. and 2.0, with introduction of C++11/14 features.

POCO Development Release 1.5.3 Available

by Guenter Obiltschnig

We're told by the POCO labs that the list of major 1.5.3 additions is as follows:

New Libraries:

• SevenZip

New Classes:

• Poco::Clock
• Poco::Net::NTPClient

New major features:

• Windows PowerShell build script

New Platforms supported:

• SmartOS
• Windows Embedded Compact 2013

JetBrains ReSharper for C++ -- Daria Dovzhikova

By Blog Staff | Jul 1, 2014 02:16 PM | Tags: None

For those interested in checking out some new C++ refactoring tools support, if you're working in Visual Studio, news from JetBrains:

ReSharper for C++ EAP Goes On

by Daria Dovzhikova

From the article:

As you might have already heard the Early Access Program for ReSharper with C++ support is in progress.

We prepared a new build and wanted to share a quick update on what new features and options it brings to the table: ...

Quick Q: When are copy and move operations automatically generated? -- StackOverflow

By Blog Staff | Jun 30, 2014 11:53 AM | Tags: None

Recently on SO:

What are the rules for automatic generation of move operations?

In C++98, the C++ compiler could automatically generate copy constructor and copy assignment operator via member-wise copy, e.g.

struct X {
    std::string s;
    std::vector<int> v;
    int n;
};

The compiler automatically generates copy constructor and copy assignment operator for X, using member-wise copy.

But how do things change in C++11 with move semantics?

Are the move constructor and move assignment operator automatically generated, like copy constructors and copy assignment operators?

Are there cases in which move operations are not automatically generated?

Quick Q: Is vector storage contiguous? -- Stack Overflow

By Blog Staff | Jun 30, 2014 09:50 AM | Tags: basics

Quick A: Yes.

Recently on SO:

std::vector: contiguous data and copy/move

I have two questions for the following code: 1) Will the elements of faces be contiguous? 2) Does std::vector copy or move Face f when inserting it?

#include <vector>   
int main()
{
    struct Face {};
    std::vector<Face> faces;

    for (int i=0; i<10; ++i)
    {
        Face f;

        faces.push_back (f);
    }

    return 0;
}

Accessing C++11 Features of the Android NDK -- Gastón Hillar

By Blog Staff | Jun 30, 2014 09:45 AM | Tags: c++14 c++11

C++ is quietly becoming a language of choice for cross-platform mobile apps, because it's the only modern language that can target iOS, Android, and more with the same source code.

In that vein, recently on Dr. Dobb's:

Accessing C++11 Features of the Android NDK

by Gastón Hillar

C++11 language features are supported in the NDK, but they require a non-default configuration.

The Drawbacks of Implementing Move Assignment in Terms of Swap -- Scott Meyers

By Blog Staff | Jun 24, 2014 12:02 PM | Tags: performance intermediate efficiency

Hot off the Meyers press: How would you implement move, and why? Scott Meyers explains two related issues:

The Drawbacks of Implementing Move Assignment in Terms of Swap

by Scott Meyers

From the article:

More and more, I bump into people who, by default, want to implement move assignment in terms of swap. This disturbs me, because (1) it's often a pessimization in a context where optimization is important, and (2) it has some unpleasant behavioral implications as regards resource management.

CppCon Status Update, Second Keynote -- Boris Kolpackov

By Blog Staff | Jun 24, 2014 08:57 AM | Tags: None

CppCon has announced a second keynote: C++ on Mars by Dr. Mark Maimone, JPL's lead architect for the C++ self-driving software in Mars Rover Curiosity and other rovers. He will be speaking on what it took to use C++ in this environment, and how this experience and lessons learned apply to other projects. This is a real treat you will not want to miss. More details below...

But first, a note: The full conference program is still coming soon, but its publication has been slightly delayed because the Program Committee had an unexpectedly high workload -- there were nearly twice as many talk proposals submitted as the conference has room for. Even though CppCon 2014 will have six full-week tracks with a total of 100 sessions, the PC had to make the difficult choice to reject many good talks that just didn't fit -- so many, in fact, that the good turned-down talks could fill another four-track full-week conference by themselves. (The silver lining is that the PC may have a head start on the program of CppCon 2015...)

If you haven't registered, register today -- Early Bird Registration ends in just over a week.

Status Update, Second Keynote

by Boris Kolpackov

From the announcement:

There are several developments in preparation for the conference: We’ve sent the acceptance notifications to authors who proposed talks. If you haven’t received the email, please contact the Program Committee. The Program Committee is now hard at work putting together and scheduling the program and we still aim to have it ready by the 27th of June. Note also that the early bird deadline is only 9 days away. Finally, we have the second keynote for CppCon 2014:

C++ on Mars: Incorporating C++ into Mars Rover Flight Software

by Dr. Mark Maimone

One of the more challenging aspects of developing flight software (FSW) for NASA’s Spirit and Opportunity Mars Exploration Rovers (MER) and Curiosity, the Mars Science Laboratory rover was how to enable them to drive themselves safely through unknown Martian terrain. When the MER mission was approved in the year 2000, JPL researchers had already demonstrated that capability on prototype rovers using software written primarily in C++ on a VxWorks realtime O/S platform with shared memory. So when asked to incorporate that capability into the MER vehicles which also relied on a similar VxWorks realtime O/S, the team concluded it would be safest and most expedient to incorporate the already field-tested C++ software. But that presented a challenge, since at that point all rover FSW development was mandated to be done mainly in the C programming language.

In this talk we present some of the challenges we faced and solutions we found in deploying C++ onto the Mars Rovers. For example, dynamic allocation was initially precluded, but development of a specialized memory allocator (using the C++ “placement new” operator) enabled us to incorporate it safely into the flight system. We will discuss what aspects of C++ were incorporated, what simulation environments aided development, describe some of the tools used to validate system behavior, and explain how our success using C++ for the implementation of autonomous navigation on MER has influenced future FSW efforts.

Speaker’s bio: Dr. Mark Maimone is a Navigation and Machine Vision researcher at JPL. Mark designed and developed the autonomous vision and navigation software that lets the MER and MSL Mars Rovers drive themselves safely, and wrote ground software that automated the analysis of Mobility and arm operations on MER. Mark is now a Rover Driver for Curiosity, and he continues to develop and enhance the onboard autonomous vision and navigation software for the rovers. Mark earned his Ph.D. in Computer Science at Carnegie Mellon University in 1996, and completed a postdoc there in 1997 as Navigation and Software Lead for the 1997 Atacama Desert Trek. At JPL since 1997, Mark has also worked on the Long Range Science Rover, Planetary Dexterous Manipulator, and Pioneer Vision System for Chornobyl Inspection projects, delivering 3D vision systems for autonomous robotic operations and mapping.

Effective Modern C++ due October, preview in early July -- Scott Meyers

By Blog Staff | Jun 24, 2014 07:44 AM | Tags: intermediate

Scott Meyers' highly anticipated new book Effective Modern C++ is on the way:

Effective Modern C++ Status Report

by Scott Meyers

From the announcement:

In recent days, two major milestones for Effective Modern C++ have been achieved. First, I sent a draft of the book's Introduction out for technical review. That was the last part of the book to be written, so I finally have a full draft manuscript. Second, I received an image of the book cover from my publisher, so I now know what the book will look like.

...

• Early October: Digital versions of the book become available.
• Late October: Print versions of the book become available.

If you're dying to see what's in the book, and you don't mind dealing with a manuscript that's in draft form (and hence contains technical errors, awkward prose, Item titles in need of revision, primitive diagrams, confusing explanations, and, I hope, some stuff in decent shape), Effective Modern C++ will be part of O'Reilly's Early Release Program, meaning you'll have a chance to see the book in the same form as my technical reviewers. You'll also be able to offer comments on it. As things stand now, the book is slated to be available in Early Release form the week of July 7th.

Why C++ Sails When the Vasa Sank -- Scott Meyers

By Blog Staff | Jun 23, 2014 10:24 AM | Tags: intermediate basics

Now available online, a nice talk by Scott Meyers about why modern C++ is alive and continues to enjoy life and growth:

Why C++ Sails When the Vasa Sank

by Scott Meyers

The Vasa was a 17th-century Swedish warship which suffered such feature creep during construction that it sank shortly after leaving the harbour on its maiden voyage. In the early 1990s, the C++ standardisation committee adopted the Vasa as a cautionary tale, discouraging prospective language extensions with "Remember the Vasa!" Yet C++ continued to grow, and by the time C++ was standardised, its complexity made the Vasa look like a rowboat.

The Vasa sank, however, while C++ cruised, and it looks likely to continue doing so even as the latest revised standards (C++11 and C++14) add dozens of new features, each with its own idiosyncrasies. Clearly, C++ has gotten some important things right. In this talk, Scott Meyers considers the lessons to be learned from the ongoing success of a complex programming language that's over 30 years old, yet very much alive and kicking.