How do I write complex initialization?--Stack Overflow

By Adrien Hamelin | Feb 11, 2015 11:21 AM | Tags: intermediate c++11

Quick A: Initialize it using a lambda that’s invoked immediately.

Recently on SO:

Best practice for declaring variable without initialising it, so auto is unavailable

I want to declare two variables of the same type, and have the compiler figure out the types. However I don't want to initialise one of the variables until later. I don't think I can use auto here, so what's the best option?

std::vector<int> v;

// `start` and `end` should be the same type
auto start = v.begin();
??? end;

// complicated code to assign a value to `end` (i.e. putting
// the code in a function or using ?: is not practical here) 
if (...) {
    end = ...;
} else {
    end = v.end();
}

What's the best way to tell the compiler that end should be the same type as start, but without having to initialise the variable?

auto start = v.begin(), end;  // Doesn't work, `end` has to be initialised
decltype(start) end;          // Does work, but not sure if it's best practice

Update

A couple of comments have suggested ways that would work in certain situations, so I am clarifying my situation here:

std::vector<int> v;
int amount = 123;

// `start` and `end` should be the same type
auto start = v.begin();
??? end;

// code to assign a value to `end`
if (amount) {
    end = start + amount;
    amount = 0;
} else {
    end = v.end();
}

I believe a lamda function would be trickier here, because amount is being reset to 0 after end is calculated, so in a lamda function that calculates a value for end, amount = 0 would have to come after the return statement. The only option would be to create more local variables, which would incur an (admittedly tiny) performance penalty.

The Rule of Zero revisited: The Rule of All or Nothing--Arne Mertz

By Adrien Hamelin | Feb 11, 2015 11:17 AM | Tags: c++11 basics

In this article you will find a new rule of thumb:

The Rule of Zero revisited: The Rule of All or Nothing

by Arne Mertz

From the article:

In 2012, Martinho Fernandes coined the Rule of Zero in a blog post. In 2014, Scott Meyers wrote a blog post about a concern with that rule and proposed a Rule of Five Defaults.

Back then, I had written a small comment on Scott’s post that deserves some further elaboration. In this post I am going to wrap up my thoughts about the two posts and propose a “Rule of All or Nothing”...

the asynchronous library - Christophe Henry @ Meeting C++ 2014

By Meeting C++ | Feb 11, 2015 10:24 AM | Tags: performance parallelism intermediate experimental c++11

A new video from Meeting C++ 2014:

the asynchronous library

by Christophe Henry

From the talk description:

An infrastructure library on which Boost Meta State Machine can build. This will be provided by the Asynchronous library: Active Objects, proxies, threadpools, parallelization algorithms, work-stealing, distributed programming...

CppCon 2014 How HHVM Uses Modern C++ for Fun and Profit (Literally)--Drew Paroski

By Adrien Hamelin | Feb 11, 2015 08:00 AM | Tags: intermediate

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:

How HHVM Uses Modern C++ for Fun and Profit (Literally)

by Drew Paroski

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

HHVM is a just-in-time compiler for PHP used by Facebook to serve billions of requests each day. This talk will give a quick overview of HHVM's history and architecture, followed by a deep dive into what made C++ the language of choice for writing HHVM.

C++ hits a sweet spot between performance and control on one end, and safety, maintainability, and convenience on the other.

The topics we’ll cover will include:
how to call into generated machine code from C++;
taking advantage of C++'s power to control "unsafe" details with memory including how memory is allocated, field size and layout, unions, reinterpret_casts, bit-stealing;
integrating generated machine code with C++ exception handling and C++ profiling tools;
leveraging templates and using the X Macro technique to improve performance and maintainability;
and taking advantage of new C++11 features like unrestricted unions and move constructors.
Finally, we'll go over some obstacles we encountered such as generating machine code that calls C++ virtual methods, and how C++'s superb flexibility allowed us to work around these obstacles.

Call for Papers: C++ track at NDC Oslo 2015, June 17-19

By Olve Maudal | Feb 10, 2015 01:09 PM | Tags: oslo norway conference cfp

There was a lot of interest for the very strong C++ track that we hosted at the NDC conference in Oslo last summer. Here is a brief summary of the event, including links to the videos we recorded.

We are repeating the success this year, June 17-19. A few big C++ names has already been signed up, but there is still available slots in the agenda. If you would like to be part of the C++ track this year, please submit your proposal soon.

Call For Papers for NDC Oslo 2015

The CFP closes February 15.

Desired compile-time failures--Andrzej Krzemieński

By Adrien Hamelin | Feb 10, 2015 08:51 AM | Tags: intermediate c++11

Sometimes, an error is what we want:

Desired compile-time failures

by Andrzej Krzemieński

From the article:

However, even though [not introducing breaking changes] works in most of the cases, I believe that this criterion of a “safe addition” is not technically correct, as it fails to take into account an important fact: failure to compile certain programs is a useful, important feature, and if these programs suddenly start to compile, it can cause harm. In this post we will go through the cases where compile-time failure is considered a useful feature...

GCC5 and the C++11 ABI--rhjason

By Adrien Hamelin | Feb 10, 2015 08:24 AM | Tags: c++11 advanced

A new article of interest for library developers:

GCC5 and the C++11 ABI

by rhjason

From the article:

The GNU C++ team works hard to avoid breaking ABI compatibility between releases, including between different -std= modes. But some new complexity requirements in the C++11 standard require ABI changes to several standard library classes to satisfy, most notably to std::basic_string and std::list. And since std::basic_string is used widely, much of the standard library is affected...

Overload 125 is now available

By Felix Petriconi | Feb 10, 2015 02:08 AM | Tags: intermediate c++14

ACCU's Overload journal of February 2015 is out. It contains C++ related articles.

Overload 125

From the journal:

Making a Tool of Deception: Is it possible to use modern C++ to make mocking easy? Björn Fahller introduces Trompeloeil, a header-only mocking framework for C++14.

Modern C++ Testing: Various C++ testing framework exist. Phil Nash compares CATCH with the competition.

I Like Whitespaces: Bob Schmidt shares why he thinks whitespaces matters.

Release of C++ Format 1.0, a small, safe and fast formatting library for C++--Victor Zverovich

By Adrien Hamelin | Feb 9, 2015 09:39 AM | Tags: performance intermediate

Here is a new library:

Release of C++ Format 1.0, a small, safe and fast formatting library for C++

by Victor Zverovich

From the main page:

C++ Format is an open-source formatting library for C++. It can be used as a safe alternative to printf or as a fast alternative to IOStreams...

CppCon 2014 Modernizing Legacy C++ Code--James McNellis & Kate Gregory

By Adrien Hamelin | Feb 9, 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:

Modernizing Legacy C++ Code

by James McNellis and Kate Gregory

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

C++ is a programming language with a long, storied history spanning over three decades--four if one includes its C ancestry. The C++ language has undergone many changes during that time, compiler technology has advanced substantially, and computers today are very different from the computers of decades past. But despite all of these advances, there's an awful lot of C++ code in use today that looks like it was written in the 1980s. In some cases, the code was written in the 1980s and it's still in use; in other cases, it's recently-written code that just doesn't use modern style.

In this talk, we'll discuss some of the problems with legacy code, and review some practical techniques for applying principles of modern C++ to gradually improve the quality of legacy code and improve maintainability and debuggability. We'll show how some very small changes to code can yield huge benefits.