My Newest E-Books
Course: Modern C++ Concurrency in Practice
Course: C++ Standard Library including C++14 & C++17
Course: Embedded Programming with Modern C++
Course: Generic Programming (Templates)
Course: C++ Fundamentals for Professionals
Interactive Course: The All-in-One Guide to C++20
More Profiles
Contact
Subscribe to the newsletter (+ pdf bundle)
All tags
- acquire-release semantic
- arithmetic
- associative containers
- async
- atomics
- atomic_thread_fence
- auto
- bit manipulation
- C
- C++17
- C++20
- class hierarchies
- classes
- concepts
- condition variables
- constexpr
- contracts
- conversions
- coroutines
- CppMem
- declarations
- decltype
- enum
- error handling
- exceptions
- expressions
- final
- finally
- functions
- Guideline Support Library
- if
- initialisations
- inline
- interfaces
- lambdas
- lock
- lock-free
- memory
- memory_order_consume
- modules
- move
- mutex
- new/delete
- noexcept
- nullptr
- Ongoing Optimization
- overloading
- override
- performance
- pointers
- ranges library
- relaxed semantic
- semaphores
- sequential consistency
- shared_ptr
- singleton
- smart pointers
- source files
- spaceship
- statements
- static
- static_assert
- switch
- tasks
- template metaprogramming
- templates
- ThreadSanitizer
- thread_local
- time
- type erasure
- type-traits
- unique_ptr
- user-defined literals
- vector
- volatile
- weak_ptr
Blog archive
- ► 2021 (38)
- ► July (5)
- ► June (7)
- ► May (5)
- ► April (4)
- ► March (6)
- ► February (6)
- ► January (5)
- ► 2020 (60)
- ► December (6)
- ► November (3)
- ► October (6)
- ► September (4)
- ► August (6)
- ► July (5)
- ► June (4)
- ► May (7)
- ► April (5)
- ► March (6)
- ► February (4)
- ► January (4)
- ► 2019 (57)
- ► December (4)
- ► November (2)
- ► October (9)
- C++20: Concurrency
- C++20: The Library
- C++ 20: The Core Language
- C++20: The Big Four
- The new pdf bundle is ready: C++ Core Guidelines: Performance
- The Next Big Thing: C++20
- "Concurrency with Modern C++" has a new chapter
- C++ Core Guidelines: Naming and Layout Rules
- C++ Core Guidelines: Lifetime Safety And Checking the Rules
- ► September (4)
- ► August (6)
- ► July (4)
- ► June (4)
- ► May (4)
- ► April (6)
- ► March (5)
- ► February (5)
- ► January (4)
- ► 2018 (62)
- ► December (5)
- ► November (5)
- ► October (5)
- ► September (4)
- ► August (8)
- C++ Core Guidelines: Rules for Templates and Generic Programming
- C++ Core Guidelines: Rules for Constants and Immutability
- The new pdf bundle is ready: C++ Core Guidelines - Concurrency and Parallelism
- C++ Core Gudelines: goto considered Evil
- For Free: Four Vouchers to Win
- C++ Core Guidelines: finally in C++
- I'm Proud to Present: Modern C++ Concurrency is available as interactive course
- C++ Core Guidelines: Rules to Exception Handling
- ► July (5)
- ► June (6)
- ► May (4)
- ► April (6)
- C++ Core Guidelines: More Rules to Concurrency and Parallelism
- C++ Core Guidelines: Rules for Concurrency and Parallelism
- The new pdf bundle is ready: Functional Features in C++
- C++ Core Guidelines: The Remaining Rules to Performance
- C++ Core Guidelines: More Rules to Performance
- The Truth about "Raw Pointers Removed from C++"
- ► March (6)
- No New New: Raw Pointers Removed from C++
- C++ Core Guidelines: Rules to Performance
- Which pdf bundle should I provide? Make your choice!
- C++ Core Guidelines: Rules to Statements and Arithmetic
- C++ Core Guidelines: More about Control Structures
- C++ Core Guidelines: To Switch or not to Switch, that is the Question
- ► February (4)
- ► January (4)
- ► 2017 (101)
- ► December (6)
- C++ Core Guidelines: Rules for Expressions and Statements
- C++ Core Guidelines: Passing Smart Pointers
- C++ Core Guidelines: Rules for Smart Pointers
- The new pdf bundle is available: Embedded - Performance Matters
- C++ Core Guidelines: Rules for Allocating and Deallocating
- C++ Core Guidelines: Rules to Resource Management
- ► November (6)
- C++ Core Guidelines: Rules for Enumerations
- Which pdf bundle should I provide? Make your choice!
- C++ Core Guidelines: Rules for Unions
- C++ Core Guidelines: More Rules for Overloading
- C++ Core Guidelines: Rules for Overloading and Overload Operators
- The C++ Standard Library: The Second Edition includes C++17
- ► October (5)
- ► September (8)
- C++ Core Guidelines: Function Objects and Lambdas
- Which pdf bundle should I provide? Make your choice!
- C++ Core Guidelines: Comparison, Swap, and Hash
- C++ Core Guidelines: Rules for Copy and Move
- My open C++ Seminars in the First Half of 2018
- C++ Core Guidelines: Constructors
- The new pdf bundle is ready: C++17
- C++ Core Guidelines: Destructor Rules
- ► August (7)
- I Proudly present my Book is Ready "Concurrency with Modern C++"
- C++ Core Guidelines: The Rule of Zero, Five, or Six
- C++ Core Guidelines: Class Rules
- Which pdf bundle should I provide?
- C++ Core Guidelines: Semantic of Function Parameters and Return Values
- C++ Core Guidelines: The Rules for in, out, in-out, consume, and forward Function Parameter
- "Concurrency with Modern C++" is 95% complete; Including all Source Files
- ► July (6)
- ► June (9)
- C++ Core Guidelines: The Philosophy
- Get the Current Pdf Bundle: "Multithreading: The High-Level Interface"
- My Book "Concurrency with Modern C++" is 30% complete
- Why do we need Guidelines for Modern C++?
- What is Modern C++?
- The Winner is: Multithreading: The high-level Interface
- ABA - A is not the same as A
- Which pdf bundle should I provide? Make your cross!
- Blocking and Non-Blocking Algorithms
- ► May (5)
- ► April (7)
- ► March (11)
- C++17 - What's New in the Library?
- How to get your pdf bundle?
- C++17 - What's New in the Core Language?
- And the Winners are: The C++ Memory Model/Das C++ Speichermodell
- Defining Concepts
- Placeholders - The Second
- Concepts - Placeholders
- Task Blocks
- Transactional Memory
- I'm Done - Geschafft: Words about the Future of my Blogs
- Pdf Bundles
- ► February (15)
- Coroutines
- Latches And Barriers
- std::future Extensions
- And the Winners are
- Atomic Smart Pointers
- Parallel Algorithms of the Standard Template Library
- Multithreading with C++17 and C++20
- Expression Templates
- C++ is Lazy: CRTP
- Six Vouchers to Win
- Monads in C++
- Concepts
- The New Ranges Library
- Fold Expressions
- Recursion, List Manipulation, and Lazy Evaluation
- ► January (16)
- Pure Functions
- Immutable Data
- Higher-Order Functions
- First-Class Functions
- The Definition of Functional Programming
- Functional in C++17 and C++20
- Functional in C++11 and C++14: Dispatch Table and Generic Lambdas
- Functional in TR1 and C++11
- Functional in C++98
- Object-Oriented, Generic, and Functional Programming
- Memory Pool Allocators from Jonathan Müller
- Pros and Cons of the various Memory Allocation Strategies
- Strategies for the Allocation of Memory
- Improvements of this Blog
- Memory Management with std::allocator
- Overloading Operator new and delete 2
- ► December (6)
- ► 2016 (97)
- ► December (16)
- Overloading Operator new and delete 1
- Explicit Memory Management
- Garbage Collection - No Thanks
- Perfect Forwarding
- Time for Wishes
- Move Semantic: Two nice Properties
- Copy versus Move Semantic: A few Numbers
- std::array - Dynamic Memory, no Thanks
- Automatic Memory Management of the STL Containers
- std::weak_ptr
- Specialities of std::shared_ptr
- std::shared_ptr
- std::unique_ptr
- Memory and Performance Overhead of Smart Pointers
- Careful Handling of Resources
- Generalized Plain Old Data
- ► November (12)
- Buckets, Capacity, and Load Factor
- Hash Functions
- Associative Containers - A simple Performance Comparison
- Hash Tables
- Type-Traits: Performance Matters
- constexpr Functions
- constexpr - Variables and Objects
- Constant Expressions with constexpr
- inline
- The Null Pointer Constant nullptr
- override and final
- Strongly-Typed Enums
- ► October (12)
- ► September (10)
- ► August (9)
- Thread-Safe Initialization of a Singleton
- Ongoing Optimization: Relaxed Semantic with CppMem
- Ongoing Optimization: A Data Race with CppMem
- Ongoing Optimization: Acquire-Release Semantic with CppMem
- Ongoing Optimization: Sequential Consistency with CppMem
- Ongoing Optimization: Locks and Volatile with CppMem
- Ongoing Optimization: Unsynchronized Access with CppMem
- Looking for Proofreaders for my New C++ Book
- Ongoing Optimization
- ► July (10)
- CppMem - An Overview
- Relaxed Semantic
- Acquire-Release Fences
- Fences are Memory Barriers
- Acquire-Release Semantic - The typical Misunderstanding
- 100 Posts Anniversary - Quo vadis Modernes C++?
- memory_order_consume
- Transitivity of the Acquire-Release Semantic
- Acquire-Release Semantic
- Sequential Consistency applied
- ► June (12)
- ► May (9)
- ► April (7)
- ► December (16)
Source Code
Most Popular Posts
Visitors
Today 4702
Yesterday 6789
Week 48467
Month 209141
All 6857833
Currently are 157 guests and no members online
Latest comments
-
C++ Core Guidelines: Rules for Enumerations
Lee -
Performance of the Parallel STL Algorithms
memory_leakDude the name is GNU/Linux not Linux. You could have done both GCC and VC on Windows for more fair ... -
Atomic Smart Pointers
rerdaviesMaybe I'm missing something. It seem to me that a better way to describe the problem is that shared_ptr's ... -
C++ Core Guidelines: Rules for Concurrency and Parallelism
Carythanks for your share, it is a big help for me. -
C++ Core Guidelines: Passing Smart Pointers
Robertoat the end of 36 " To be honest, you should use a pointer (Widget*) or a reference (Widget&) as a ...
Read more...