Collaborative Online Compilers

by Jens Weller

While doing some brainstorming for possible (youtube) live formats with C++ content, the thought of having a shared online IDE/Compiler came into my mind. Think of Google Docs but for C++...

Compiler Explorer's embedded view

by Matt Godbolt

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

by Vittorio Romeo

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

by Glennan Carnie

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 Rob Irving and Jason Turner

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.

Randomizing a CSV File with Standard C++

by Jens Weller

For this years student program I had to come up with a way to randomly select n students from all applicants. I wanted to do this in a clean and nice C++ program. So here it is...

The Observable C++ library

by Daniel Dinu

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

by Adi Shavit

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.

Use Stronger Types!

by Arne Mertz

Is everything we use a string for really just a bunch of characters? Is everything we use an int for really just a number? Probably not. We can have stronger types than that...

A better date and time C++ library

by Marius Bancila

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...