Implementing Queues for Event-Driven Programs--“No Bugs” Hare

By Adrien Hamelin | Jun 13, 2016 12:57 PM | Tags: performance intermediate

An interesting article:

Implementing Queues for Event-Driven Programs

by “No Bugs” Hare

From the article:

We’ve already discussed things related to sockets; now let’s discuss the stuff which is often needed (in particular, it is of Utmost Importance when implementing Reactors), but which is not that common to be universally available as a part of operating system.

I’m speaking about queues. And not only just about “some” queue, but about queues which have certain properties desirable for our Reactors a.k.a. ad-hoc Finite State Machines a.k.a. Event-Driven Programs.

Compile Time Constants Part 2: Compile Time Calculations--Arne Mertz

By Adrien Hamelin | Jun 10, 2016 01:16 PM | Tags: intermediate efficiency

The compile time story continues...

Compile Time Constants Part 2: Compile Time Calculations

by Arne Mertz

From the article:

I have written about what we need compile time constants for last week. This time I will dig a bit into where we can get compile time constants from, and how we can do compile time calculations...

Using the not_null Template for Pointers That Must Never Be Null--Kate Gregory

By Marco Arena | Jun 10, 2016 08:15 AM | Tags: gsl basics

A new post about the Guidelines Support Library (GSL):

Using the not_null Template for Pointers That Must Never Be Null

by Kate Gregory

From the article:

I'll show you how to ensure a pointer is never null, which will make your applications both faster and less likely to encounter runtime errors...

Quick Q: c++ lambda capture by value

By Adrien Hamelin | Jun 6, 2016 01:22 PM | Tags: None

Quick A: A capture by value is a copy.

Recently on SO:

c++ lambda capture by value

That's because the variable is captured by value (i.e. copied) only once, when you define the lambda. It's not "updated" as you may believe. The code is roughly equivalent to:

#include <iostream>

int x = 0;
struct Lambda
{
    int _internal_x; // this is used to "capture" x ONLY ONCE
    Lambda(): _internal_x(x) {} // we "capture" it at construction, no updates after
    void operator()() const
    {
        std::cout << _internal_x << std::endl;
    }
} qqq;

int main()
{
    qqq();
    x = 77; // this has no effect on the internal state of the lambda
    qqq();
}

C++ in Competitive Programming: string basics--Marco Arena

By Marco Arena | Jun 6, 2016 12:28 AM | Tags: basics

In this installment we’ll meet std::string and some standard functions:

C++ in Competitive Programming: string basics

by Marco Arena

From the article:

We need a type representing a sequence of characters and in C++ we have std::string, the main string datatype since 1998 (corresponding to the first version of the ISO C++ standard – known as C++98)...

C++ Annotated: March – May 2016--Anastasia Kazakova

By Adrien Hamelin | Jun 3, 2016 02:30 PM | Tags: community

An overview of the recent C++ world:

C++ Annotated: March – May 2016

by Anastasia Kazakova

From the article:

In this edition:

• Conferences
• News & Stories
• Webinars
• Releases

VoidParam Puzzle -- Alex Marmer

By Alex Marmer | Jun 3, 2016 12:28 AM | Tags: None

Alex Marmer has openend a puzzle.

VoidParam Puzzle 

From the article:

How to handle 'void' parameter passed in a macro. He provides a solution as well.

In case that you have other or better solutions, don't hesitate to use the comment option on this site.

Compile Time Constants Part 1: Why We Need Them--Arne Mertz

By Adrien Hamelin | Jun 1, 2016 02:47 PM | Tags: performance intermediate

The title says it all:

Compile Time Constants Part 1: Why We Need Them

by Arne Mertz

From the article:

Compile time constants are an important part of C++. They contribute to program correctness and allow the optimizer to do a better job. Today I will deal with what is possible in terms of compile time constants and compile time calculations in C++03.

Quick Q: If nullptr_t isn't a keyword, why are char16_t and char32_t?

By Adrien Hamelin | Jun 1, 2016 02:41 PM | Tags: c++11 advanced

Quick A: To allow overloading with the underlying types of uint_least16_t and uint_least32_t

Recently on SO:

If nullptr_t isn't a keyword, why are char16_t and char32_t?

The proposal itself explains why: to allow overloading with the underlying types of uint_least16_t and uint_least32_t. If they were typedefed this wouldn't be possible.

Define char16_t to be a distinct new type, that has the same size and representation as uint_least16_t. Likewise, define char32_t to be a distinct new type, that has the same size and representation as uint_least32_t.

[N1040 defined char16_t and char32_t as typedefs to uint_least16_t and uint_least32_t, which make overloading on these characters impossible.]

As for why they aren't in the std namespace, this is for compatibility with the original C proposal. C++ prohibits the C definitions from appearing in its own version of <cuchar>

[c.strings] / 3

The headers shall not define the types char16_t, char32_t, and wchar_t (2.11).

The types then would need to be global typedefs, which carries its own set of issues such as

typedef decltype(u'q') char16_t;

namespace foo {
  typedef int char16_t;
}

The reason for std::nullptr_t not being a keyword can be found in the question you linked

We do not expect to see much direct use of nullptr_t in real programs.

making nullptr_t the real exception here.

 

C++ for Games: Performance, Allocations and Data Locality -- Sergey Ignatchenko

By Blog Staff | May 31, 2016 11:39 AM | Tags: None

Well-illustrated, and well-illustrated, gems:

C++ for Games: Performance, Allocations and Data Locality

by Sergey Ignatchenko

From the draft chapter:

One further thing to keep in mind with regards to 90-10 (or 70-30) rule is that even if only performance of 10% of the code matters, the rest of the code can still affect performance of critical 10% in a Pretty Bad Way :-( ...