Home » Blog » Categories » Articles & Books

Articles & Books

6 Tips to supercharge C++11 vector performance--Deb Haldar

By Mantosh Kumar | Nov 21, 2016 10:34 PM | Tags: performance efficiency

Discussion on how we can efficiently use std::vector<T> container.

6 Tips to supercharge C++11 vector performance

by Deb Haldar

From the article:

Vector is like the swiss army knife of C++ STL containers. In the words of Bjarne Stroutsoup – “By default, use Vector when you need a container”. For mere mortals like us, we take this as gospel and just run with it. However, Vector is just a tool and like any tool, it can be used both effectively or ineffectively.

In this article we’ll look at 6 ways to optimize usage of vectors. We’ll look at both efficient and inefficient ways to perform the most common programming tasks using vectors, measure the performance gain we obtain by using vectors efficiently and try to understand why we’re getting the performance gain.

Help me sort out the meaning of "{}" as a constructor argument--Scott Meyers

By Mantosh Kumar | Nov 21, 2016 09:44 PM | Tags: None

Discussion on "Distinguish between () and {} when creating objects".

Help me sort out the meaning of "{}" as a constructor argument

by Scott Meyers 

From the article:

My experiments showed that one factor affecting whether "{{}}" as an argument list yields a zero-length std::initializer_list<T> was whether T had a default constructor, so I threw together some test code involving three classes, two of which could not be default-constructed. I then used both "({})" (note the outer parentheses) and "{{}}" as argument lists to a constructor taking a std::initializer_list for a template class imaginatively named X. When the constructor runs, it displays the number of elements in its std::initializer_list parameter.

When type inference fails -- Krzysztof Ostrowski

By fj | Nov 14, 2016 02:34 AM | Tags: None

C++11 re-introduces auto keyword that enables basic type inference. Using auto not only improves code readability.

When type inference fails

by Krzysztof Ostrowski

From the article:

Use of type inference puts impact on what is possible to be done with certain value, i.e. on its interface or concept it models, rather than on its concrete type. Unfortunately, auto does type inference locally, thus is not such powerful as we might expect. Here follows some examples of auto-inference failures.

Infographics: Operation Costs in CPU Clock Cycles--“No Bugs” Hare

By Adrien Hamelin | Nov 11, 2016 12:54 PM | Tags: performance advanced

A very interesting article about the cost of our basic operations.

Infographics: Operation Costs in CPU Clock Cycles

by “No Bugs” Hare

From the article:

Whenever we need to optimise the code, we should profile it, plain and simple. However, sometimes it makes sense just to know ballpark numbers for relative costs of some popular operations, so you won’t do grossly inefficient things from the very beginning (and hopefully won’t need to profile the program later �� )...

Terminators--Adi Shavit

By Adrien Hamelin | Nov 7, 2016 12:02 PM | Tags: advanced

Do you know how a program ends?

Terminators

by Adi Shavit

From the article:

A GraphViz diagram that shows both normal and unexpected program termination flows in C++.

There are multiple ways a C++ program may terminate. These include both normal and unexpected termination.
This GraphViz diagram shows the program termination flows as defined by the standard...

Why you should use Boost.MultiIndex (Part I)--David Gross

By Adrien Hamelin | Nov 7, 2016 11:56 AM | Tags: community boost

Did you know that container?

Why you should use Boost.MultiIndex (Part I)

by David Gross

From the article:

Although Boost.MultiIndex is a pretty old library — introduced in Boost 1.32, released in 2004 — I found it rather unsung and underestimated across the C++ community in comparison to other non-standard containers.

In this article, split into multiple parts, I will highlight all the benefits you can get using boost::multi_index_container instead of the standard containers: faster, cleaner and simpler code.

Collaborative Online Compilers

By Meeting C++ | Nov 7, 2016 03:44 AM | Tags: experimental basics

I was doing some research on possible live formats...

Collaborative Online Compilers

by Jens Weller

From the article:

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

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