Don’t Try Too Hard! – Exception Handling -- Arne Mertz

By Felix Petriconi | Jan 20, 2015 08:11 AM | Tags: intermediate basics

Arne Mertz describes in his recent article insights about exception handling.

Don’t Try Too Hard! – Exception Handling

by Arne Mertz

From the article:

Among C++ developers there often appears to be a misconception about what it means to deal with code that can throw exceptions. The misconception is that the possibility of exceptions means one has to try and catch often and almost everywhere. I will try to explain why I think that is wrong and where I think try/catch is appropriate and where not.

Type safe handles in C++--Emil Ernerfeldt

By Adrien Hamelin | Jan 16, 2015 03:46 PM | Tags: intermediate

Some time ago, Emil Ernerfeldt wrote about type safe handles. Simple and interesting.

Type safe handles in C++

by Emil Ernerfeldt

From the article:

Let's say you have a system of resources and you identify them using integers as handles. These integers are meaningless to the user, but internally they may be indices into an array, or just a running count...

An update on “A simple signal system”--Adrien Hamelin

By Adrien Hamelin | Jan 16, 2015 03:32 PM | Tags: intermediate c++11

Here is a follow-up on a previous article about a simple signal system:

An update on “A simple signal system”

by Adrien Hamelin

From the article:

Almost a month ago from now (already), I wrote a post about “A simple signal system“. Check it out if you have not already, as in this post I will speak a little further about it...

The C++ Memory Model - Valentin Ziegler @ Meeting C++ 2014

By Meeting C++ | Jan 15, 2015 03:39 AM | Tags: performance parallelism intermediate efficiency concurrency advanced

A new video from Meeting C++ 2014:

The C++ Memory Model

by Valentin Ziegler

From the talk description:

The C++ memory model defines how multiple threads interact with memory and shared data, enabling developers to reason about concurrent code in a platform independent way. The talk will explain multi-threaded executions and data races in C++...

Implementing std::tuple From The Ground Up – Part 1--Sasha Goldshtein

By Adrien Hamelin | Jan 14, 2015 03:26 PM | Tags: intermediate c++11

Sasha Goldshtein begins to show us how to implement the basis of a useful tool from the STL: the tuple.

Implementing std::tuple From The Ground Up – Part 1

by Sasha Goldshtein

From the article:

std::tuple is a very nice facility originally introduced in C++ TR1. It is a heterogenous container of elements that has a statically known size. In C++ 11, std::tuple can be implemented using variadic templates; a single std::tuple class can support an arbitrary number of template type arguments. In this series of blog posts we will implement std::tuple from first principles. The purpose of this exercise is not to provide the best-performing or most-conformant tuple implementation, but rather to see what foundational concepts are required to implement it...

Quick Q: How do I cast 'this' to std::shared_ptr? -- StackOverflow

By Blog Staff | Jan 14, 2015 10:33 AM | Tags: intermediate

Quick A: Inherit from enable_shared_from_this.

Recently on SO:

Cast 'this' to std::shared_ptr

I have a method on a class to make a particular instance an "active" instance:

void makeActive() { activeInstance = this; }

However it doesn't work since activeInstance has type std::shared_ptr< ClassName >. How can I cast this to std::shared_ptr<ClassName>?

Pruning Error Messages From C++ Template Code

By Meeting C++ | Jan 14, 2015 02:35 AM | Tags: templates intermediate experimental c++14 c++11 advanced

A new video from Meeting C++ 2014 is uploaded:

Pruning Error Messages From C++ Template Code

by Roland Bock

From the talk description:

Many template libraries are regarded with ambivalent feelings by developers: On the one hand, such libraries can offer wonderful functionality. On the other hand, they are dreaded for the sheer amount of error messages spilled out...

Discriminated Unions with boost::python and boost::variant - The Blind Guru

By Jeremy Wright | Jan 12, 2015 10:06 AM | Tags: variant python intermediate boost

A useful application of boost::variant with boost::python by Mario Lang.

boost::python and boost::variant

by Mario Lang

From the post:

However, there is one aspect of C++ data types that I couldn't figure out how to interface with Python, which are C++ discriminated unions, or more specifically, heterogeneous containers. While Python has no problems with containers containing objects of different types, C++ does not make this very easy by default.

Generating OpenCL/CUDA source code from C++ expressions in VexCL

By Meeting C++ | Jan 9, 2015 03:40 AM | Tags: parallelism opencl intermediate gpu experimental efficiency cuda concurrency advanced

A solution to generate code for CUDA and OpenCL with C++:

Generating OpenCL/CUDA source code from C++ expressions in VexCL

by Denis Demidov

From the talk description:

VexCL is an opensource C++ vector expression template library for OpenCL/CUDA. It has been created for ease of GPGPU development with C++ and provides convenient and intuitive notation for linear algebra operations, vector arithmetic and various parallel primitives.

Await, coroutines, what could that bring for game development

By simon ferquel | Jan 8, 2015 04:29 PM | Tags: intermediate experimental

[This article is interesting not only because it's about work being proposed for consideration in the Concurrency TS, but also because it's interesting that we seem to be seeing a trend of articles being published on GitHub instead of on a blog... --Ed.]

Await, coroutines, what could that bring for game development

This article shows how we can use await in way not related to threading, tasks, or asynchronous I/O, but in the context of a game, to write game logic-related code spanning accross many frames in a sequencial way, without introducing any threads with little to no performance penalty.