C++ Insights - Implicit Conversions--Andreas Fertig

By Adrien Hamelin | Mar 20, 2019 12:25 PM | Tags: intermediate community

A good tool!

C++ Insights - Implicit Conversions

by Andreas Fertig

From the article:

This series is motivated by a brief conversation I had with Andreas. I asked him if he has some use case examples which show how C++ Insights can be helpful when teaching. I think there are many things. This article is the start of a series of five posts by Andreas which I will publish at Modernes C++ because I think C++ Insights is an invaluable tool to get a deeper insight in the C++ compiler magic. In case, you are new to C++ Insights consider this introductory article. Without further ado, Andreas post. When you follow the link near to each example, you can directly analyse the example in C++ Insight...

Quick Q: Deletion of copy-ctor & copy-assignment - public, private or protected?

By Adrien Hamelin | Mar 20, 2019 12:21 PM | Tags: intermediate c++11

Quick A: The meaning is the same for the compiler, so chooses what make sense to you.

Recently on SO:

Deletion of copy-ctor & copy-assignment - public, private or protected?

I would put them in the public section.

This is because deleting a constructor or an assignment operator is orthogonal to making them private / protected; and when these aren't deleted, they are public. Putting the deletions in one of those two sections seems to me like hinting "If I hadn't deleted them, I would have made them private/protected" - which is not a message you want to convey in your case.

Note, though, that the compiler doesn't care which section you put the deletion in.

Macro Evil in C++ Code

By Andrey Karpov | Mar 20, 2019 10:53 AM | Tags: macros bugs

The C++ language opens extensive opportunities to go without macros. So let’s try to use macros as seldom as possible!

Macro Evil in C++ Code

by Andrey Karpov

From the article:

The ATL library provides such macros, as A2W, T2W and so on for string conversion. However, few people know that it is very dangerous to use these macros inside loops. Within the macro, a call to the alloca function occurs, which will repeatedly allocate memory on each loop iteration on the stack. A program makes show that it works correctly. Once a program starts to handle longer strings and the number of loop iterations increases, the stack can just end at the most unexpected moment.

Template meta-functions for detecting template instantiation--Ivan Čukić

By Adrien Hamelin | Mar 19, 2019 11:44 AM | Tags: c++17 advanced

Templates are great.

Template meta-functions for detecting template instantiation

by Ivan Čukić

From the article:

I’ve been playing around with type meta-tagging for my Voy reactive streams library (more on that some other time) and realized how useful it is to be able to check whether a given type is an instantiation of some class template, so I decided to write a short post about it...

Quick Q: What is a lambda expression in C++11?

By Adrien Hamelin | Mar 19, 2019 11:42 AM | Tags: c++11 basics

Quick A: A convenient way to create a functor.

Recently on SO:

What is a lambda expression in C++11?

C++ includes useful generic functions like std::for_each and std::transform, which can be very handy. Unfortunately they can also be quite cumbersome to use, particularly if the functor you would like to apply is unique to the particular function.

#include <algorithm>
#include <vector>

namespace {
  struct f {
    void operator()(int) {
      // do something
    }
  };
}

void func(std::vector<int>& v) {
  f f;
  std::for_each(v.begin(), v.end(), f);
}

If you only use f once and in that specific place it seems overkill to be writing a whole class just to do something trivial and one off...

Little-known C++: function-try-block--Marius Bancila

By Adrien Hamelin | Mar 19, 2019 11:34 AM | Tags: intermediate

Did you know?

Little-known C++: function-try-block

by Marius Bancila

From the article:

Function-try-block is a mechanism in C++ to establish an exception handler around the body of a function...

A gentle introduction to jump threading optimizations--Aldy Hernandez

By Adrien Hamelin | Mar 18, 2019 10:50 AM | Tags: performance advanced

Your complier does magic.

A gentle introduction to jump threading optimizations

by Aldy Hernandez

From the article:

As part of the GCC developers‘ on-demand range work for GCC 10, I’ve been playing with improving the backward jump threader so it can thread paths that are range-dependent. This, in turn, had me looking at the jump threader, which is a part of the compiler I’ve been carefully avoiding for years. If, like me, you’re curious about compiler optimizations, but are jump-threading-agnostic, perhaps you’ll be interested in this short introduction...

Thanks for the memory (allocator)--Glennan Carnie

By Adrien Hamelin | Mar 18, 2019 10:49 AM | Tags: c++17

Unifying the types.

Thanks for the memory (allocator)

by Glennan Carnie

From the article:

One of the design goals of Modern C++ is to find new – better, more effective – ways of doing things we could already do in C++.  Some might argue this is one of the more frustrating aspects of Modern C++ – if it works, don’t fix it (alternatively: why use lightbulbs when we have perfectly good candles?!)

This time we’ll look at a new aspect of Modern C++:  the Allocator model for dynamic containers.  This is currently experimental, but has been accepted into C++20.

The Allocator model allows programmers to provide their own memory management strategy in place of their default library implementation.  Although it is not specified by the C++ standard, many implementations use malloc/free.

Understanding this feature is important if you work on a high-integrity, or safety-critical, project where your project standards say ‘no’ to malloc...

Quick Q: Pointer to class data member “::*”

By Adrien Hamelin | Mar 13, 2019 12:53 PM | Tags: advanced

Quick A: a pointer that lets you access the value of the member of an instance.

Recently on SO:

Pointer to class data member “::*”

It's a "pointer to member" - the following code illustrates its use:

#include <iostream>
using namespace std;

class Car
{
    public:
    int speed;
};

int main()
{
    int Car::*pSpeed = &Car::speed;

    Car c1;
    c1.speed = 1;       // direct access
    cout << "speed is " << c1.speed << endl;
    c1.*pSpeed = 2;     // access via pointer to member
    cout << "speed is " << c1.speed << endl;
    return 0;
}

As to why you would want to do that, well it gives you another level of indirection that can solve some tricky problems. But to be honest, I've never had to use them in my own code.

Edit: I can't think off-hand of a convincing use for pointers to member data. Pointer to member functions can be used in pluggable architectures, but once again producing an example in a small space defeats me. The following is my best (untested) try - an Apply function that would do some pre &post processing before applying a user-selected member function to an object:

void Apply( SomeClass * c, void (SomeClass::*func)() ) {
    // do hefty pre-call processing
    (c->*func)();  // call user specified function
    // do hefty post-call processing
}

The parentheses around c->*func are necessary because the ->* operator has lower precedence than the function call operator.

C++ Core Guidelines: Mixing C with C++--Rainer Grimm

By Adrien Hamelin | Mar 13, 2019 12:39 PM | Tags: community

Mixing C and C++ from the point of view of a C++ engineer.

C++ Core Guidelines: Mixing C with C++

by Rainer Grimm

From the article:

The chapter in the C++ core guidelines is called: C-style programming. Honestly, my first thought was to skip it, but after more thoughts I decided to write about it. My reason is twofold:

1. This are the typical issues we have when dealing with legacy code.
2. One reader wanted that I write more about the challenges of legacy code.