In my last post I described a light-weight serialization framework I recently implemented (video where I go over it in detail). After receiving great feedback from r/cpp I have implemented several improvements that were suggested to me: better unpack transform signature, safer unpacking code, unpack casting iterator just to name a few. The latest code […]
Light-weight serialization framework
UPDATE: Better serializer In my very first YouTube Channel video I discuss in detail the design of a serialization framework I came up with in response to a question I was recently asked. In this post I want to give a brief overview of how it works and how to get started using it. The […]
The future of C++
I hope the title of this post got your attention! What I really mean is the future direction of this blog… In 2019 I created 85 short articles, in 2020 I blogged only twice. The last 12 months have pulled my attention away from this site and toward mentoring other engineers at work by hosting […]
Make std::vector of T, efficiently
What I want to briefly talk about today is likely obvious to seasoned C++ programmers, but may be of benefit for the newcomers to the language and the STL: that is how to efficiently create std::vector of any number of elements of type T, whatever T may be. The code is short and sweet, so […]
Singleton Pattern
First things first: if you’re still reading this blog, thanks! I haven’t posted anything since last December; it has been a rough first half of the year: COVID-19, working from home, isolation, you know the deal, but I have not given up on blogging, just finding the time for it has been nearly impossible. I […]
std::unique_ptr, or how to express explicit ownership
When we talk about std::unique_ptr we must mention the idea of explicit resource ownership as well as the concept of a resource source and sink. By wrapping a pointer inside std::unique_ptr we state that whoever holds the std::unique_ptr owns the resource explicitly: has complete control over its lifetime. Prior to C++11 this was expressed using […]
When exactly does the std::shared_ptr take ownership?
In a post I wrote few days ago titled “A word on std::shared_ptr” I was mistakenly arguing that, should the std::shared_ptr fail to allocate its control block (where the reference count and other information is stored), the passed raw pointer would not be deleted. Example: auto p = std::shared_ptr<T>(new T); Here, if the allocation and construction of T succeeded, […]
In-depth look at C++ shared pointers
First, you should use std::make_shared (most of the time) to create shared pointers. It is optimized to perform only one allocation for both the reference count / control block and the object it holds. It is also safer to use std::make_shared in the presence of exceptions: some_function(std::shared_ptr<T>(new T), std::shared_ptr<T>(new T)); Prior to C++17, one of the possible orders […]
Avoiding deadlocks the C++ way
When interviewing engineers for a C++ programming position the question of deadlocks often comes up (ask me how I know this 😉 ). What is it? And how to avoid it? Often times a deadlock occurs due to a wrong order of acquiring locks: multiple threads need to access 2 or more shared resources; each […]
Multi-hashing
Yes I totally invented this term 😛 What I mean by it is producing multiple hashes from a single key. Like this (if the syntax is unfamiliar to you read this):
|
1 |
auto [h1, h2, h3] = hashNT<3>("key"); |
Or like this (for non-template version which returns a vector):
|
1 |
auto hashes = hashN("key", 3); |
Why? One place where I needed such sorcery was my bloom filter […]
#pragma
There are two useful #pragma directives I like to use in my code: one let’s the preprocessor know that you want to include a header fine only once, and another deals with structure packing. Instead of using the header include guards, which are ugly as sin, use #pragma once at the beginning of your header files, […]
Exception safe assignment
Longer title: exception safe assignment operator of resource owning objects. Uff. Because the object owns a resource, how do we write an exception safe assignment operator which will have to free up the old and allocate the new resource. By exception safe I don’t mean that it will never throw, that’s not possible. Instead, I […]
Hashing the C++ way
Modern C++ brought us std::hash template (read more about it here). In short: it’s a stateless function object that implements operator() which takes an instance of a type as parameter and returns its hash as size_t. It has specializations for all primitive types as well as some library types. You can also specialize it yourself […]
Data alignment the C++ way
Before modern C++ the only way to align variables or structures on a given byte boundary was to inject padding; to align a struct to 16 bytes you had to do this:
|
1 2 3 4 5 |
struct Old { int x; char padding[16 - sizeof(int)]; }; |
Not any more! Modern C++ introduced a keyword just for that: alignas (read more about it here). Now you can specify struct’s […]
Simple file I/O
I was playing around with file I/O the C++ way and decided to create a file hashing program using ifstream and Botan crypto library. The program reads an entire file specified as the command line argument and takes the SHA1 hash of the content. It’s amazing what you can accomplish with well designed frameworks in […]
Better bloom filter
Based on this implementation it supports multiple hashes for better positive hit ratio. Can be initializes with size in bits and number of hashes to perform, like this: bloom_filter bloom(128, 5);As always, complete implementation on GitHub: bloom.hpp.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
#pragma once #include <vector> #include <random> #include <functional> #include <cstddef> #include <cassert> namespace { template<typename Key, typename Hash = std::hash<Key>> class mixer { public: mixer(std::size_t size, const Key& key) : m_size(size), m_random(Hash{}(key)) { assert(size > 0); } std::size_t operator()() { return m_random() % m_size; } private: std::size_t m_size; std::mt19937 m_random; }; } template <typename Key, typename Hash = std::hash<Key>> class bloom_filter { public: bloom_filter(std::size_t size, std::size_t hashes) : m_size(size), m_hashes(hashes), m_bits(size) { assert(size > 0); assert(hashes > 0); } void add(const Key& key) { mixer<Key, Hash> m(m_size, key); for(std::size_t i = 0; i < m_hashes; ++i) m_bits[m()] = true; } bool contains(const Key& key) const { mixer<Key, Hash> m(m_size, key); for(std::size_t i = 0; i < m_hashes; ++i) if(!m_bits[m()]) return false; return true; } private: std::size_t m_size; std::size_t m_hashes; std::vector<bool> m_bits; }; |
Bloom Filters
From Wikipedia: A Bloom filter is a space-efficient probabilistic data structure, conceived by Burton Howard Bloom in 1970, that is used to test whether an element is a member of a set. In other words, given a set of elements, bloom filter can tell you that: A) given element is definitely not in the set, or B) given element is maybe in the set. […]
C++ Attributes
C++11 introduced standard attributes: a way to mark fragments of code with useful information for the developer or optimization information for the compiler. See a complete list of standard attributes here, Clang attributes here, and Microsoft attributes here. I will go over a few of them in this post. [[nodiscard]] – when specified with a […]
Initialization list exceptions and raw pointers
What to do when an exception is thrown on the initialization list when allocating memory for a raw pointer? The situation is easy if your class only has one raw pointer member, but it gets complicated with two or more. Here’s a code example that’s guaranteed to leak memory if the second new int throws an […]
Function try-catch blocks
Syntactic sugar or a useful feature? More than just sweet sweet sugar baby! This little known feature is a nice way of wrapping an entire function in a try catch block. So instead of writing this:
|
1 2 3 4 5 6 7 8 9 10 11 |
void eat_it() { try { throw runtime_error("System error from eat_it()"); } catch(exception& e) { cout << "Swallowing: " << e.what() << endl; } } |
You can write this:
|
1 2 3 4 5 6 7 8 |
void eat_it_sugar() try { throw runtime_error("System error from eat_it_sugar()"); } catch(exception& e) { cout << "Swallowing: " << e.what() << endl; } |
The meaning of the two functions is identical. Notice here I’m swallowing the […]