Home » Blog » Categories »

Compiler Explorer's embedded view--Matt Godbolt

By Adrien Hamelin | Nov 4, 2016 01:14 PM | Tags: community

An interesting tool:

Compiler Explorer's embedded view

by Matt Godbolt

From the article:

Today I updated Compiler Explorer to support better sharing, specifically to allow embedding a Compiler Explorer view into another site, useful for blog posts that wish to demonstrate how compilers generate code, or how language constructs actually become assembly...

checking expression validity in-place with C++17--Vittorio Romeo

By Adrien Hamelin | Nov 4, 2016 01:09 PM | Tags: experimental advanced

An introduction to the world of C++17.

checking expression validity in-place with C++17

by Vittorio Romeo

From the article:

When writing generic code, it is sometimes useful to check whether or not a particular SFINAE-friendly expression is valid (e.g. to branch at compile-time). Let's assume that we have the following class declarations...

struct Cat
{
    void meow() const { cout << "meow\n"; }
};

struct Dog
{
    void bark() const { cout << "bark\n"; }
};

...and that we would like to write a template function make_noise(x) that calls x.meow() and/or  x.bark() if they are well-formed expressions:

template <typename T>
void make_noise(const T& x)
{
    // Pseudocode:
    /*
        if(`x.meow()` is well-formed)
        {
            execute `x.meow();`
        }
        else if(`x.bark()` is well-formed)
        {
            execute `x.bark();`
        }
        else
        {
            compile-time error
        }
    */
}

In this article I'll show how to implement the pseudocode in:

C++11: using std::void_t and std::enable_if.

C++14: using boost::hana::is_valid and vrm::core::static_if.

C++17: using if constexpr(...), constexpr lambdas, and std::is_callable. This version will allow expression validity to be checked in-place (i.e. directly in the if constexpr predicate). Variadic preprocessor macros will also be used to make the user code easier to read and maintain...

Getting your head around auto’s type-deduction rules--Glennan Carnie

By Adrien Hamelin | Nov 4, 2016 12:53 PM | Tags: intermediate experimental

Are the rules clear to you?

Getting your head around auto’s type-deduction rules

by Glennan Carnie

From the article:

Automatic type-deduction is perhaps one of the more divisive features of Modern C++.  At its core it’s a straightforward concept:  let the compiler deduce the type of an object from its initialiser.   Used in the right way this can improve the readability and maintainability of your code.

However, because auto is based on template type-deduction rules there are some subtleties that can catch the unwary programmer.

In this article we’ll have a look at auto in the context of the template type-deduction rules to see where all these subtleties come from...

CppCast Episode 77: Blaze with Klaus Iglberger

By robwirving | Nov 4, 2016 07:26 AM | Tags: None

Episode 77 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Klaus Iglberger to discuss the Blaze high performance math library.

CppCast Episode 77: Blaze with Klaus Iglberger

by Rob Irving and Jason Turner

About the interviewee:

Klaus Iglberger has finished his PhD in computer science in 2010. Back then, he contributed to several massively parallel simulation frameworks and was an active researcher in the high performance computing community. From 2011 to 2012, he was the managing director of the central institute for scientific computing in Erlangen. Currently he is on the payroll at CD-adapco in Nuremberg, Germany, as a senior software engineer. He is the co-organizer of the Munich C++ user group (MUC++)and he is the initiator and lead designer of the Blaze C++ math library.

The Observable C++ library -- Daniel Dinu

By Daniel Dinu | Nov 3, 2016 11:04 PM | Tags: None

A simple library for implementing the observer pattern.

The Observable C++ library

by Daniel Dinu

From the article:

Whenever I need to subscribe to events, I usually implement some variation of the observer pattern, or (if available) hack and misuse Qt’s signals and slots mechanism to do the job. Because of this, usually I’m not happy with the results; especially if I misuse QObjects.

Polymorphism Polymorphism -- Adi Shavit

By Adi | Nov 3, 2016 11:02 PM | Tags: None

C++17 gives us std::variant<> which allows for a new form of runtime polymorphism.

Polymorphism Polymorphism

by Adi Shavit

From the article:

Polymorphism allows manipulating different types identically when they implement the same interface.
C++ supports both static and dynamic polymorphism.
Dynamic run-time polymorphism in C++ is achieved using sub-typing with inheritance and virtual functions. This is the way it has always been in C++: Polymorphism ⇒ Heap-allocated objects. 

C++17 gives us std::variant<> which allows for a new form of runtime polymorphism.

A better date and time C++ library--Marius Bancila

By Adrien Hamelin | Nov 2, 2016 01:11 PM | Tags: community c++11

Did you know that library?

A better date and time C++ library

by Marius Bancila

From the article:

C++11 added a date and time utility library called chrono, available in namespace std::chrono and header <chrono>. The problem with it is that the library is a general purpose one and therefore lacks many useful features, such as working with dates, weeks, calendars, timezones and other related features. Fortunately, a rich date and time library based on chrono has been created by Howard Hinnant and is available on github...

Coroutines Internals--Marco Alesiani

By Marco Arena | Nov 2, 2016 02:37 AM | Tags: None

What are coroutines and why should you care?

Coroutines Internals

    by Marco Alesiani

From the article:

Coroutines provide a powerful abstraction to offer the same level of concurrency one would get with asynchronous callbacks by offering at the same time a chance to write more maintainable code..