Home » Blog » Tags » intermediate

intermediate

Quick Q: Accessing protected members in a derived class

By Adrien Hamelin | Jun 18, 2018 12:06 PM | Tags: intermediate

Quick A: Only your own type can be accessed.

Recently on SO:

Accessing protected members in a derived class

You can only access protected members in instances of your type (or derived from your type).
You cannot access protected members of an instance of a parent or cousin type.

In your case, the Derived class can only access the b member of a Derived instance, not of a different Base instance.

Changing the constructor to take a Derived instance will also solve the problem.

Hello CMake!--Arne Mertz

By Adrien Hamelin | May 28, 2018 01:14 PM | Tags: intermediate community

Do you use it?

Hello CMake!

by Arne Mertz

From the article:

Since I have mentioned CMake in a handful of past blog posts, it is time to give a short introduction for those that don’t know it yet.

CMake is one of the most popular build systems for C++ out there. One of the main reasons probably is that it is cross-platform: It does not build the project itself but operates a platform-specific system. That means it can generate Makefiles, ninja-build files, or project files for Visual Studio or Xcode, to name just a few...

Error Handling and std::optional--Bartlomiej Filipek

By Adrien Hamelin | May 24, 2018 12:56 PM | Tags: intermediate c++17

Do you have a prefered way?

Error Handling and std::optional

by Bartlomiej Filipek

From the article:

In my last two posts in the C++17 STL series, I covered how to use std::optional. This wrapper type (also called “vocabulary type”) is handy when you’d like to express that something is ‘nullable’ and might be ‘empty’. For example, you can return std::nullopt to indicate that the code generated an error… but it this the best choice?

std::accumulate vs. std::reduce--Simon Brand

By Adrien Hamelin | May 22, 2018 01:04 PM | Tags: stl intermediate

Old vs new.

std::accumulate vs. std::reduce

by Simon Brand

From the article:

std::accumulate has been a part of the standard library since C++98. It provides a way to fold a binary operation (such as addition) over an iterator range, resulting in a single value. std::reduce was added in C++17 and looks remarkably similar. This post will explain the difference between the two and when to use one or the other...

Quick Q: typedef pointer const weirdness

By Adrien Hamelin | May 18, 2018 11:15 AM | Tags: intermediate

Quick A: Don't hide pointers in typedefs.

Recently on SO:

typedef pointer const weirdness

Note that

typedef int* intptr;
const intptr x;

is not the same as:

const int* x;

intptr is pointer to int. const intptr is constant pointer to int, not pointer to constant int.

so, after a typedef pointer, i can't make it const to the content anymore?

There are some ugly ways, such as gcc's typeof macro:

typedef int* intptr;
intptr dummy;
const typeof(*dummy) *x;

but, as you see, it's pointless if you know the type behind intptr.

C++ Weekly Episode 115: Compile Time ARM Emulator—Jason Turner

By Jason Turner | May 14, 2018 02:47 PM | Tags: intermediate efficiency c++17

Episode 115 of C++ Weekly.

Compile Time ARM Emulator

by Jason Turner

About the show:

This episode of C++ Weekly demonstrates a compile time ARM CPU emulator using C++17 constexpr. No special tricks were necessary to accomplish this feat, merely following a rule of "constexpr everything that is reasonable." The code is portable and currently compiles with GCC and Clang in about 2 seconds for simple compile-time test cases.

Non-Ownership and Generic Programming and Regular types, oh my!==Barry Revzin

By Adrien Hamelin | May 11, 2018 12:41 PM | Tags: intermediate

Do you know about it?

Non-Ownership and Generic Programming and Regular types, oh my!

by Barry Revzin

From the article:

This post is about a specific collection of types in the C++ core language and standard library. I am not sure of a good way to name this collection, and some terms that come to mind come with their own baggage, so I’m going to for now group them together under an umbrella that is clearly widely unrelated to programming and call them Westie types (because, like my dog, they are awesome yet enigmatic).