Why does C++ not allow multiple types in one auto statement? -- StackOverflow

By Blog Staff | Nov 7, 2013 12:20 PM | Tags: basics

Recently on SO:

Why does C++ not allow multiple types in one auto statement?

The 2011 C++ standard introduced the new keyword auto, which can be used for defining variables instead of a type, i.e.

auto p=make_pair(1,2.5);                   // pair<int,double>
auto i=std::begin(c), end=std::end(c);     // decltype(std::begin(c))

In the second line, i and end are of the same type, referred to as auto. The standard does not allow

auto i=std::begin(container), e=std::end(container), x=*i;

when x would be of different type. My question: why does the standard not allow this last line? ...

Ode To a Flat Set -- Jon Kalb

By Blog Staff | Nov 7, 2013 11:16 AM | Tags: performance intermediate efficiency boost

A nice short overview of when you might want your associative container to use a contiguous implementation instead of a tree under the covers:

Ode to a Flat Set

by Jon Kalb

From the article:

The Boost Container library has a family of flat_* containers that have associative container interfaces and semantics, but are implemented as sorted vectors.

In addition to faster lookup, the flat_* containers have much faster iteration, less memory overhead, fewer allocations, and improved cache performance.

However, as with all things, there are trade-offs.

Exception safety: The strong guarantee and move semantics

By Blog Staff | Nov 4, 2013 01:27 AM | Tags: intermediate

An interesting question was asked recently on StackOverflow that nicely ties in with Scott Meyers' "Effective C++11/14 Sampler" talk two months ago at GoingNative 2013 and the interestingly named feature std::move_if_noexcept, both referenced in the answers.

Since the gorier details of the answer lie in "watch Scott's talk," we merrily abuse a snapshot of Dr. Meyers during said talk as the highlight graphic for this post.

Exception safe code and move semantics

I want to write container class. This container has insert method that have two specializations -- first uses copy constructors to copy data from one container to another container element wise. If copy constructor throws exception I just undo all changes to the container like nothing happens.

The second specialization uses move constructor and thats the place where things got complicated. When I move items from one container to another container element by element, move constructor can throw exception. If this happens -- I've got really messy state when some elements are moved and other elements stays in it's original places. If I try to move elements back -- I can get another exception.

Is it possible to write something like this in exception safe manner or exception safety and move semantics are mutually exclusive?

C++ User Group Meetings November

By Meeting C++ | Nov 2, 2013 04:58 PM | Tags: intermediate community basics

An overview of C++ User Groups which meet in November:

C++ User Group Meetings in November

by Jens Weller

From the Article:

November has come, Meeting C++ Conference is soon...
... and also 12 C++ User Groups are meeting...

Compiling and Linking in C++ -- Rusty Ocean

By Blog Staff | Nov 1, 2013 03:01 PM | Tags: basics

Life'n'gadget just published a nice overview of the basic C++ compilation model, useful for people who are new to programming in C++.

Compiling and Linking in C++

by Rusty Ocean

From the article:

When you write a C++ program, the next step is to compile the program before running it. The compilation is the process which convert the program written in human readable language like C, C++ etc into a machine code, directly understood by the Central Processing Unit. There are many stages involved in creating a executable file from the source file. The stages include Preprocessing, Compiling and Linking in C++...

Duetto: A C++ compiler for the Web going beyond emscripten and node.js

By Blog Staff | Oct 31, 2013 09:49 AM | Tags: None

Learning Technologies Ltd. has released a new Clang-based C++ compiler for the Web:

Duetto: a C++ compiler for the Web going beyond emscripten and node.js

From the announcement:

Today Lean­ing Tech­nolo­gies Ltd. releases duetto, a com­piler designed to develop integrated (back­end and fron­tend) web appli­ca­tions in C++. duetto is now avail­able to the pub­lic as FOSS here, and will be offered in a com­mer­cial pack­age with closed-source-friendly licens­ing soon.

[... duetto] allows to pro­gram both the fron­tend and the back­end of a Web appli­ca­tion in an inte­grated C++ code­base, com­pil­ing them respec­tively to JavaScript and native code.

Duetto com­bines the advan­tages of emscripten and node.js by allow­ing the pro­gram­mer to:

• write web appli­ca­tions in C++, reusing exist­ing code and mak­ing port­ing of whole appli­ca­tions and games to the browser plausible.
• code both the fron­tend and the back­end of a web appli­ca­tion in the same lan­guage and codebase

In addi­tion to this, duetto pro­vides some nice features:

• Bring the robust­ness and proven scal­a­bil­ity of C++ pro­gram­ming to the Web
• You can access all browser APIs directly. Duetto inher­its the C++ phi­los­o­phy of expos­ing the plat­form capa­bil­i­ties (and lim­i­ta­tions) to the users. There is no mid­dle man.
• Duetto is based on LLVM/clang. An indus­try stan­dard C++ com­piler is a programmer’s best friend: code san­ity is ver­i­fied as com­pile time, includ­ing RPC signatures.
• The LLVM tool­chain also guar­an­tees that a mind-blowing set of opti­miza­tions is run at com­pile time, gen­er­at­ing highly effi­cient code. This decreases the bur­den on JavaScript JIT com­piler at runtime.
• Con­trar­ily to emscripten we do not try to emu­late a tra­di­tional address space using typed arrays, but directly map C++ objects to JS objects. This reduces mem­ory con­sump­tion since the garbage col­lec­tor can delete unused object.

New Adventures in C++ with Cinder and More -- Ale Contenti

By NoSenseEtAl | Oct 31, 2013 08:15 AM | Tags: intermediate

The Cinder C++ library for graphics got a shout-out from Herb Sutter at GoingNative'13, and now we get a full hour-long talk about Cinder from Visual Studio's own Ale Contenti.

New Adventures in C++ with Cinder and More

Play and be productive with modern C++, graphics, on-the-fly projects and more! Starting from the latest Going Native 2013 talks as an inspiration, we will explore how easy is to mold ideas into graphics apps with C++ and Cinder, and how simple tools and techniques can help us be more productive in Visual Studio!

Watch the video, or download the slides.

Quick Q: Is 'auto' type deduction static (compile time) or dynamic (run time)?

By Blog Staff | Oct 29, 2013 01:56 PM | Tags: basics

Recently on StackOverflow:

C++ 11 auto compile time or runtime?

auto a = 10;

When compiler knows a is int, at compile time or at run-time? If it deduce type at run-time, will it not affect performance?

Interview: Bjarne Stroustrup Discusses C++ -- William Wong

By Blog Staff | Oct 29, 2013 09:51 AM | Tags: None

William Wong recently interviewed Bjarne Stroustrup for Electronic Design.

Interview: Bjarne Stroustrup Discusses C++

by William Wong

Much of the content will be familiar to those who've seen or read other recent interviews, but it's a nice concise summary of the essence of C++ including examples in code. If someone you know wonders why C++ was created, or what is the essence of its purpose as a language, or how modern C++ code looks and feels, this article is a good place to send them.

Why does std::condition_variable take a std::unique_lock instead of a std::mutex? -- StackOverflow

By Blog Staff | Oct 25, 2013 03:54 AM | Tags: None

Recently on StackOverflow, someone asked: What's the job of std::unique_lock when used with std::condition_variable::wait()?

A more detailed answer is available in this earlier question, including why taking a unique_lock makes the C++ version superior to some other libraries' designs:

C++11: Why does std::condition_variable use std::unique_lock?

I am a bit confused about the role of std::unique_lock when working with std::condition_variable. As far as I understood the documentation, std::unique_lock is basically a bloated lock guard, with the possibility to swap the state between two locks.

I've so far used pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) for this purpose (I guess that's what the STL uses on posix). It takes a mutex, not a lock.

What's the difference here? Is the fact that std::condition_variable deals with std::unique_lock an optimization? If so, how exactly is it faster?