Friends and where to find them
Corner cases of friendship connected with name lookup and templates – all explained.
Objects, their lifetimes and pointers
You intuitively know what objects are and what is their lifetime. I bet though, that not all of the tricky corner cases are known to you. Read this post if you are interested in a very detailed knowledge about that topic.
Dynamic_cast and typeid as (non) RTTI tools.
You are already very likely to know about the dynamic_cast and typeid tools from the C++ language. Those tools allow you to get some information about the types of objects in the runtime. And yes… runtime. It’s slow, right? So we would rather not use those tools at all. In this article, we will have […]
Point of declaration
After difficult posts about the coroutines and before yet another one I decided to take a break and write about something easier instead. This time we will have a look at one of the aspects of the declarations namely – point of declaration. So what is this point of declaration? Intuitively it’s a point in […]
Have you been co_awaiting the next post about the coroutines? Well after some break from writing finally it’s here. So first of all, if you are reading this post, I assume you are already familiar with the introduction to the coroutines and description of the promise types, since this is just a continuation of a […]
Your first coroutine
Once you got familiar with the introduction to the coroutines, then I think it’s high time to actually implement your first co-routine object. This whole post is all about understanding how to implement co-routines and related entities (especially promise_type). Before we start the adventure, please ensure that your compiler does support coroutines. (as of this […]
Let’s consider following piece of code from the C++ standard: Can you see the issue here? theoretically we are assigning the pointer to the pointer to the non const to the pointer to pointer to the const char. On first sight nothing dangerous happens here. After all we are assigning the pointer, through which we […]
And so it’s happened. After a long time of doubts, opposition, and preparation of this feature, WG21 agreed on how the coroutines should look like, and coroutines will likely come into C++ 20. Since it’s a significant feature, I think it’s good to start preparing and learning this now (remember there are also modules, concepts, […]
Value categories – [l, gl, x, r, pr]values
So you have heard about lvalues and rvalues for sure, but there actually are also xvalues, prvalues and glvalues. It’s easy to get lost in it, so let’s have a look at what actually are those things. The picture shows the division of the value categories defined in the draft standard. In this particular case, […]
Error handling now and tomorrow
So we will be talking about the error handling. Well first, I guess I need to explain myself why I decided to talk about this topic. You all know about error handling mechanisms in the C++ language right? You know you can throw exceptions, you know you shouldn’t throw them too often, because of performance […]