C++ language bookmarks

C++ links
- CPP C++ Papyrus
 - CPP / C++ - Template Metaprogramming - Generic Programming
- C++ Ecosystem: Compilers, IDEs, Tools, Testing and More
 - and meson, missed from the above review
```
-ldflag=-Wl,--allow-multiple-definition

...
mylib = shared_library(..., dependencies: [liblog,], ... link_args: '-Wl,--allow-multiple-definition')
```
 - C project build with meson: Correct way to handle 3rd party local libraries
- Build Systems For C++
 - build2 | C/C++ Build Toolchain
 - The build2 packaging
 - Complete C++20 Modules Support with GCC
 
 C++20 Modules Examples
- several GNU make tips
 - Makefile: Default Value of Variable that is set but has null value
 - defining default values in makefile
- CMake
 - CMake Cookbook
 - An Introduction to Modern CMake
 - CGold: The Hitchhiker’s Guide to the CMake
 - CMake cheat sheet
 - greenfield : start new project with C++/CMake
 - vim-cmake-boilerplate
 - Vim: Setting up a Build System and Code Completion for C and C++
 - CMake cannot find GoogleTest required library in Ubuntu
 - CMake by Example
 - Modern CMake and sub-modules
 - How do I explicitly specify an out-of-tree source in CMake?
 - Define preprocessor macro through CMake?
 tl;dr
```
add_compile_definitions(OPENCV_VERSION=${OpenCV_VERSION})
add_compile_definitions(OPENCV_VERSION=${OpenCV_VERSION} WITH_OPENCV2)
target_compile_definitions(my_target PRIVATE FOO=1 BAR=1)
```
 - How to copy contents of a directory into build directory after make with CMake?
```
add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
 COMMAND ${CMAKE_COMMAND} -E copy_directory
 ${CMAKE_SOURCE_DIR}/config $<TARGET_FILE_DIR:${PROJECT_NAME}>/config)
```
```
 cmake -DCMAKE_CXX_COMPILER:FILEPATH=C:\Game Dev\Tools\MingW-
```
 - Test Fixtures With CMake/CTest
 - pybind11Config.cmake helpers
 - CMake FindPython3
 - Использование Eigen в проектах CMake
- Doxygen
- CppCon 2017: Rong Lu "C++ Development with Visual Studio Code"
- C++ Development with Visual Studio Code
 - 11 Best Programming Fonts
 - Keyboard shortcut for Visual c# block comment in Visual Studio 2015? tl;dr
```
keyboard shortcut for single line(//....) commenting Ctrl + K + C and uncommenting Ctrl + K + U . 
```
- Thoughts about Software Development with an eye on the world of modern C++ Programming
- Is C++ fast?
 - Flavors of SIMD
C
- 9 интересных трюков на Си, с которыми вы раньше не сталкивались
- How do I create a custom file system in C?
C++
- Feature freeze C++20. Coroutines, Modules и прочее
- C++ Best Practices
free modern C++ book: Discovering Modern C++
- CppCon
 - C++ Atomics, From Basic to Advanced by Fedor Pikus
 - Building C++ Modules by Boris Kolpackov
 - Concurrency, Parallelism and Coroutines - Anthony Williams
 - CUDA Kernels with C++ by Michael Gopshtein
- C++ TUTORIAL - TEMPLATES - 2018
- C++11 async tutorial
- C++ Lifetime safety, inspired by Rust
- C++17 features list
 - C++17 in details: Standard Library Utilities
 - C++17 in details: Parallel Algorithms
 - Value Categories in C++17
 - Категории выражений в C++
 - C++17 Guaranteed Copy Elision
 - Simplify code with 'if constexpr' in C++17
 - Constexpr if alternative
 - C++17 Fold expressions
 - Reduce: From functional programming to C++17 Fold expressions - Nikos Athanasiou - Meeting C++ 2016
 - «Скользкие» места C++17
 - simplify C++
 - Top 10 dumb mistakes to avoid with C++ 11 smart pointers
 - Stanford C++ Style Guide
 - Stanford C++ Style Guide
- Trending C++ github repositories
- Optimized C++ book
- C++17 High Performance
- Valery Lesin. C++ In-Depth, 2014
 - Лекция 3. Move семантика и Rvalue reference
- The C++ Standards Library for Concurrency and Parallelism http://stellar-group.org/libraries/hpx
 - HPX (High Performance ParalleX) is a general purpose C++ runtime system for parallel and distributed applications of any scale
 - HPX — рантайм-система для параллельных и распределенных вычислений
- Modern C++ for fun and profit
 - free C++ books
 - MODERN C++ FOR C PROGRAMMERS: PART 4
- using extern template (C++11)
 - tl;dr
 - use case in Flexible Collision Library
 - don't confuse with export templates
- Is pass-by-value a reasonable default in C++11?
- Noexcept and copy, move constructors
- SFINAE
 - SFINAE
 - C++ SFINAE examples?
- C++ samples
 - Introduction To valarray
 - C++ valarray vs. vector
 - Atomic Basics
 - Подборка ресурсов с примерами кода на разных языках
- enum to string in modern C++11 / C++14 and future C++17 / C++20
 - enum to string in modern C++11 / C++14 and future C++17 / C++20
 - Enum to string в современном C ++ и будущем C ++ 17 / C ++ 20
 - How to perform tuple arithmetic in C++ (c++11/c++17)?
- CRTP demystifyed
 - The Curiously Recurring Template Pattern (CRTP)
 - What the Curiously Recurring Template Pattern can bring to your code
 - An Implementation Helper For The Curiously Recurring Template Pattern
 - The “Extract Interface” refactoring, at compile time
- C++ and multithreading
 - Memory Model
 - C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
 - Top 20 C++ multithreading mistakes and how to avoid them
 tl;dr
 1. Not using join() to wait for background threads before terminating an application.
 2. Trying to join() a thread that has been previously detached.
 3. Not realizing that std::thread::join() blocks the calling thread.
 4. Thinking that thread function arguments are pass by reference by default.
 tl;dr use std::ref() for passing by reference.
 5. Not protecting shared data or shared resources with a critical section (eg. mutex).
 6. Forgetting to release locks after a critical section.
 7. Not keeping critical sections as compact and small as possible.
 8. Not acquiring multiple locks in the same order.
 9. Trying to acquire a std::mutex twice.
 10. Using mutexes when std::atomic types will suffice.
 11. Creating and Destroying a lot of threads directly when using a thread pool is available.
 12. Not handling exceptions in background threads.
 13. Using threads to simulate Asyn jobs when std::async will do.
 14. Not using std::launch::async if asynchronicity is desired.
 15. Calling .get() on a std::future in a time sensitive code path.
 16. Not realizing that an exception thrown inside an async task is propagated when std::future::get() is invoked.
 17. Using std::async when you need granular control over thread execution.
 18. Creating many more "Runnable" threads than available cores.
 19. Using volatile keyword for synchronization.
 20. Using a Lock Free architecture unless absolutely needed
 - lucid and terse multithread intro
 - Multithreading in C++11/14 – Part 1
 - Multithreading in C++11/14 – Part 2
 - Multithreading in C++11/14 – Part 12
 - Locking and Conditional Variables
 - C++11 Multithreading Part 7: Condition Variables Explained
 - C++11-concurrency-tutorial-advanced-locking-and-condition-variables
 - C++11 concurrency: condition variables
 - Потоки, блокировки и условные переменные в C++11 [Часть 2]
 - std::unique_lockstd::mutex or std::lock_guardstd::mutex?
 - std::unique_lock vs. от std::lock_guard?
 - tl;dr almost the same, but lock_guard has less functionality, locks only once and more preferrable; use lock_guard unless you need unlocling, for condition_variables that wait()ing from sleep.
 - http://preshing.com/20130618/atomic-vs-non-atomic-operations/
 - Comparison: Lockless programming with atomics in C++ 11 vs. mutex and RW-locks
 - THE INFINITE LOOP: The ticket spinlock
 - a reference spinlock implementation
 - Difference between Mutex, Semaphore & Spin Locks
 - Разработка → Конкурентность: Параллелизм
 - What is the equivalent of boost::upgrade_to_unique_lock in STL?
 - Охранные классы в boost::thread
 - code review: Yet another event dispatcher in c++11
 - A simple proof-of-concept for C++11 event dispatching
- C++11 FAQ rom the author of C++
- C++11 Tidbits: Template Aliases
 - Why is allocator::rebind necessary when we have template template parameters?
 - tl;dr instead of
```
template<typename T>
class allocator {
 //...

 template<typename U>
 struct rebind { typedef allocator other; };
};

allocator<T>::rebind::other x; // sample usage
```
 can be rewritten
```
template<typename T>
class allocator {
 //...

 template<typename U>
 using rebind = allocator;
};

allocator<T>::rebind x; // sample usage
```
 - why rebind
```
template <typename T, typename A = std::allocator<T>>
class list {
 struct node {
 T value;
 node* next;
 node* prev;
 };
 using allocator = typename A::template rebind<node>::other;
};
```
- Variable template
 - tl;dr
```
template<class T>
constexpr T pi = T(3.1415926535897932385); // variable template
 
template<class T>
T circular_area(T r) // function template
{
 return pi<T> * r * r; // pi<T> is a variable template instantiation
}
```
- accumulate rehab
 - tl;dr
```
// classical
template<class InputIt, class T, class BinaryOperation>
constexpr // since C++20
T accumulate(InputIt first, InputIt last, T init, 
 BinaryOperation op)
{
 for (; first != last; ++first) {
 init = op(std::move(init), *first); // std::move since C++20
 }
 return init;
}

// a variation
template<typename T> struct range_value {
using type = typename T::value_type;
};

template<typename T> struct range_value<T*> {
using type = T;
};

template <typename I, typename Op>
typename range_value::type accumulate(I beg, I end, typename range_value::type unit, Op op)
{
 typename range_value::type acc{unit};
 for (auto it = beg; it != end; ++it) {
 acc = op(acc, *it);
 }
 return acc;
}

int main()
{
 std::list l{1, 2, 3, 4};
 std::vector v{1, 2, 3, 4};
 float c_array[] = {1.1f, 2.2f, 3.3f, 4.4f};

 auto sl = accumulate(std::begin(l), std::end(l), 1, std::multiplies<>{});
 auto cl = accumulate(std::begin(c_array), std::end(c_array), 0, std::plus<>{});

 auto sv = accumulate(v.begin(), v.end(), 0, std::plus<>{});
}
```
- is_swappable
 - tl;dr
```
namespace dispatch {

using std::swap;

template<class T, class voider = void_t<>>
struct has_member_swap : std::false_type { };

template<class T>
struct has_member_swap<T,
 void_t<decltype(noexcept(swap(std::declval<T&>(), std::declval<T&>()))), typename std::enable_if_t<!std::is_array<T>::value>>
> : std::integral_constant<bool,
 std::is_move_assignable<T>::value &&
 std::is_move_constructible<T>::value
> { };

template<class T>
struct has_member_swap<T, typename std::enable_if_t<std::is_array<T>::value>> : has_member_swap<std::remove_all_extents_t<T>> { };
}
```
- What Every C++ Developer Should Know to (Correctly) Define Global Constants
- East const but constexpr West - Dan Saks - code::dive 2018
- Why const Doesn't Make C Code Faster
- Impossibly fast delegate in C++11
- Разработка → RAII + С++ variadic templates = win
- C++ convert integer to string at compile time
- String representation of time_t?
- Is there any RAII file handle already implemented?
- Perfect forwarding and universal references in C++
- Nobody Understands C++
 - Nobody Understands C++: Part 5: Template Code Bloat
- The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++
- Поразрядная сортировка с человеческим лицом Radix sort in C++
- http://habrahabr.ru/company/infopulse/blog/274549/
- Советы о том, как писать на С в 2016 году
- The C++ scientist
- Algorithms in C++
- Fast function to parse strings into double floating-point values
- C++20: Python's map Function
- HowardHinnant.github.io World-class C++ expert
 - Everything You Ever Wanted To Know About Move Semantics
 - A date and time library based on the C++11 (and beyond) header
- GoF patterns in modern C++
 - Effective GoF Patterns with C++11 and Boost—Tobias Darm
- selected stackoverflow questions
 - What is the usefulness of enable_shared_from_this?
 - std::enable_shared_from_this
 - How and why one would use Boost signals2?
 - Is boost::signals2 overkill for simple applications?
 tl;dr almost 100x performance penalty over plain function call
 - Conversion of Qt Signals to Boost Signals2
 - Messaging and Signaling in C++
 - Making Boost.Signals2 More OOP‐Friendly
 - Protected вызов сигналов в Boost.Signals2
 - Should I use std::function or a function pointer in C++?
 - C++11 variadic std::function parameter
 - Difference in make_shared and normal shared_ptr in C++
 - Usage of std::forward vs std::move
 - C++ Move Semantics Considered Harmful (Rust is better)
 - Advantages of using forward
 - How does std::forward work?
 - Why is std::forward useless in this context
 - throwing exceptions out of a destructor
 - summary: Throwing an exception out of a destructor is dangerous. If another exception is already propagating the application will terminate.
 - "More Effective C++" Item 11: Prevent exceptions from leaving destructors
 - What does the explicit keyword in C++ mean?
 - dubbed from above link
```
// Suppose you have a class String:

class String {
public:
 String(int n); // allocate n bytes to the String object
 String(const char *p); // initializes object with char *p
};
// Now if you try

String mystring = 'x';
// the char 'x' will be implicitly converted to int and then will call the String(int) constructor.
// But this is not what the user might have intended. So to prevent such conditions, we shall define the constructor as explicit:

class String {
public:
 explicit String (int n); //allocate n bytes
 String(const char *p); // initialize sobject with string p
};
```
 - explicit in C++17 & C++20
 - Implicit conversion of stream to bool
 - C++ convert from 1 char to string?
 - tl;dr
```
char c = 42; std::cout << string(1, c) << std::endl;
```
 - how to pre-allocate memory for a std::string object?
 - tl;dr
```
// New Test -- the fastest
std::string s4;

clock_t start4 = clock();
file.seekg(0, std::ios::end);
s4.resize(file.tellg());
file.seekg(0, std::ios::beg);

file.read(&s4[0], s4.length());
clock_t stop4 = clock();
```
 - how to pre-allocate memory for a std::string object?
 - How to automatically convert strongly typed enum into int?
 - Can a C++ lambda constructor argument capture the constructed variable?
 - Секреты auto и decltype
 - generic variadic lambdas
 - TL;DR
```
auto get_item = [&ifs](auto& item) {
 std::string line;
 std::getline(ifs, line);
 std::istringstream iss(line);
 iss >> item;
};
...
get_items(std::ref(params.thorus_params.xfirst), std::ref(params.thorus_params.yfirst));
```
 - how to get only keys of values from map
 - boost::adaptors::map_keys
```
#include <boost/range/adaptor/map.hpp>
#include <boost/range/algorithm/copy.hpp>
#include <boost/assign.hpp>
#include <boost/algorithm/string/join.hpp>
#include <algorithm>
#include <iostream>
#include <map>
#include <vector>

int main()
{
 std::map<std::string, std::string> m;
 m["hello"] = "world";
 m["goodbye"] = "now";

 std::vector<std::string> o;
// boost::copy(m | boost::adaptors::map_keys, std::back_inserter(o));
 boost::copy(m | boost::adaptors::map_values, std::back_inserter(o));
 std::cout << boost::algorithm::join(o, ", ") << std::endl;
}
```
 - boost.histogram bare-bone installation
```
git clone https://github.com/boostorg/histogram.git
git clone https://github.com/boostorg/mp11.git
git clone https://github.com/boostorg/callable_traits.git
git clone https://github.com/boostorg/assert.git
git clone https://github.com/boostorg/throw_exception.git
git clone https://github.com/boostorg/core.git
git clone https://github.com/boostorg/config.git
git clone https://github.com/boostorg/variant2.git
```
 - Python bindings for the C++14 Boost::Histogram library
 - Boost-histogram is a Python package providing Python bindings for Boost.Histogram
 - issues to Boost-histogram
 - Boosting the Accuracy of Differentially Private Histograms Through Consistency
 - Improving Accuracy and Robustness of Self-Tuning Histograms by Subspace Clustering
 - Improving Accuracy and Robustness of Self-Tuning Histograms by Subspace Clustering
 - cheat-sheet for callbacks in C++
 - Callback functions in c++
 - Using std::make_unique with custom deleter on a derived class?
 - tl;dr you cannot indicate a custom deleter with the make_* helper functions for smart pointers (neither with make_unique, nor with make_shared). use to explicitly construct your pointer as it follows:
 std::unique_ptr<T, D> ptr{new T{)};
 If the deleter is not default constructible, you can do this:
 std::unique_ptr<T, D> ptr{new T{}, d};
 - std::unique_ptr for class data member ABI (Pimpl idiom)
 - Move constructor involving const unique_ptr
 - Why am I getting compile error “use of deleted function 'std::unique_ptr …”
 tl;dr The chief feature of std::unqiue_ptr is that it cannot be copied. That's by design, and the name tells you as much. take std::unique_ptr<..> const& -- no copy is needed.
 - unique_ptr, shared_ptr, weak_ptr, or reference_wrapper for class relationships
 - Using weak_ptr for circular references
 - std::call_once()
 - std::call_once, std::once_flag
 - std::call_once vs std::mutex for thread-safe initialization
 - Why is this pointer needed when calling std::call_once()?
 - std::call_once safe for non atomic variables?
 - Is std::call_once a blocking call?
 - Some tips on iterators
 - Common Knowledge: Output Iterator Adapters
 - A smart iterator for inserting into a sorted container in C++
 - C++ specialization
 - Function Templates Partial Specialization in C++
 - C++ Template specialization for subclasses with abstract base class
 - c++ template specialization for base class
 tl;dr look partial_specialization.cpp
 template <typename M> struct SetTarget { SetTarget(M* t): target(t) {} M* target; }; template <typename M, typename T, bool = std::is_base_of<OperationMessage, T>::value> struct SetId : public SetTarget<M> { SetId(M* t) : SetTarget<M>(t) {} void operator()(T) { std::cout << "SetId with -1\n"; SetTarget<M>::target->setId(-1); } }; // partial specialization template <typename M, typename T> struct SetId<M, T, true> : SetTarget<M> { SetId(M* t) : SetTarget<M>(t) {} void operator()(T msg) { std::cout << "SetId with msg.getSequence()\n"; SetTarget<M>::target->setId(msg.getSequence()); } };
 - selected boost tips
 - boost property tree
 - boost property tree 5 minutes tutorial
 - 3 ways of getting data from propert tree
 tl;dr
 auto dump_vector = [](std::string const& name, auto const& v) { std::cout << name << " : { "; for (auto val : v) { std::cout << val << ", "; } std::cout << "}\n"; }; auto vec = xml_data.get("A.E.S.coeffs", std::vector<float>()); dump_vector("coeffs", vec);
 - TinyXML-2
 - Christian Aichinger's thoughts : boost::make_iterator_range
 - Overview of C++ Variable Initialization
 - A method to list all files in directory and sub-directories using boost and c++
 - GitGist : vivithemage/boost_list_directory.cpp
 #include <iostream> #include <string> #include <vector> #include <boost/filesystem.hpp> #include <boost/range.hpp> std::vector<std::string> get_file_list(std::string const& path) { std::vector<std::string> files; if (!path.empty()) { boost::filesystem::path dir = "."; boost::filesystem::recursive_directory_iterator it(dir), end; for (auto& entry : boost::make_iterator_range(it, end)) if (boost::filesystem::is_regular(entry)) files.push_back(entry.path().native()); } return files; } int main(int argc, char** argv) { if (argc > 1) { auto file_list = get_file_list(argv[1]); for (auto const& f : file_list) { std::cout << "- " << f << std::endl; } } }
 - non-trivial designated initializers not supported
 - No matching function std::forward with lambdas
 - Lambda expressions as class template parameters
 - Passing capturing lambda as function pointer
 - Capture unique_ptr in lambda function
 - Recursive lambda functions in C++11
 - Can I use std::vector as a template parameter or does it need to be std::vector?
 - Clang refuses to compile libstdc++'s header
 - How can I create directory tree in C++/Linux?
 - C++ Copy directory recursive under unix
 - Hash Functions for C++ Unordered Containers
 - About size_t and ptrdiff_t
- REST API
 - REST APIs in C++
 - What is a good open source C++11 web/HTTP server library for building an application server ?
- XML, HTML and network libraries in C++
 - A Cheat Sheet for HTTP Libraries in C++
 - Boost asio docs
 - Benchmark. Analyzing and Testing Current HTML Parsers TL;DR HTML5Ever is written in Rust:) MyHTML is the fastest; Gumbo is produced by Google
 - Parsing HTML with C++: Revisited
 - Getting directory listing over http
 - Downloading flv from youtube using curlpp on top of curl - video not playing
- How do I terminate a thread in C++11?
 - How to terminate a C++ std::thread?
 - terminate_cpp_thread : kill thread
- What's the difference between “mutex” and “lock”?
- Потоки, блокировки и условные переменные в C++11 [Часть 2]
- C++11 threads, affinity and hyperthreading
- C++11 and semaphores
 - C++0x has no semaphores? How to synchronize threads?
 - Semaphores C++11 when Multithreading
 - why do I need std::condition_variable?
- intrusive prt vs. std::shared_ptr
 - Boost intrusive_ptr and its usage in C++ programming
 - Archives for posts with tag: intrusive_ptr
 - intrusive_ptr против shared_ptr. Что лучше.
- Double-Checked Locking is Fixed In C++11
 - Several C++ singleton implementations
```
class smartSingleton
{
 private:
 static std::mutex _mutex;
 
 smartSingleton();
 smartSingleton(const smartSingleton& rs);
 smartSingleton& operator = (const smartSingleton& rs);
 
 public:
 ~smartSingleton();
 
 static std::shared_ptr& getInstance() {
 static std::shared_ptr instance = nullptr;

 if (!instance) {
 std::lock_guard lock(_mutex);

 if (!instance) {
 instance.reset(new smartSingleton());
 }
 }
 
 return instance;
 }
 
 void demo() { std::cout << "smart pointers # next - your code ..." << std::endl; }
};
```
 - How to implement multithread safe singleton in C++11 without using
```
class Singleton
{
public:
static Singleton & Instance()
{
 // Since it's a static variable, if the class has already been created,
 // It won't be created again.
 // And it **is** thread-safe in C++11.

 static Singleton myInstance;

 // Return a reference to our instance.
 return myInstance;
}

// delete copy and move constructors and assign operators
Singleton(Singleton const&) = delete; // Copy construct
Singleton(Singleton&&) = delete; // Move construct
Singleton& operator=(Singleton const&) = delete; // Copy assign
Singleton& operator=(Singleton &&) = delete; // Move assign

// Any other public methods

protected:
Singleton()
{
 // Constructor code goes here.
}

~Singleton()
{
 // Destructor code goes here.
}

 // And any other protected methods.
}
```
 - Retiring the Singleton PatternConcrete suggestions for what to use instead
 - Retiring the Singleton Pattern - Peter Muldoon - Meeting C++ 2019
 - C++: Rounding up to the nearest multiple of a number
 tl;dr If multiple is a power of 2 (faster in ~3.7 times http://quick-bench.com/sgPEZV9AUDqtx2uujRSa3-eTE80)
```
int roundUp(int numToRound, int multiple) 
{
 assert(multiple && ((multiple & (multiple - 1)) == 0));
 return (numToRound + multiple - 1) & -multiple;
}
```
 - Progress Bar
 - How to display a progress indicator in pure C/C++ (cout/printf)? tl;dr more neat and nice solution
```
void printProgressNice (float percentage, int wid = 60)
{
 const char PBFILLER[] = "█";
 int val = (int) (percentage * 100);
 int lpad = (int) (percentage * wid);
 int rpad = wid - lpad;
 printf("\r%3d%%[", val);
 while (lpad--)
 printf("%s", PBFILLER);
 while (rpad--)
 putchar(' ');
 printf("]");
 fflush(stdout);
}
```
 - Make better CLI progress bars with Unicode block characters
 - How to repeat a string a variable number of times in C++?
 - К тридцатилетию первого C++ компилятора: ищем ошибки в Cfront
 - Is C++21 the Next Standard?
 - CppCon 2020
 - Plenary: Performance Matters - Emery Berger - CppCon 2020
 - CppCon 2020 Presentation Materials
 struct to_string_t { std::string_view s; operator int() const; // int from_string(std::string_view s); operator bool() const; // bool from_string(std::string_view s); }; int i = to_string_t{"7"}; bool b = to_string_t{"true"};
 - cpponsea-slides 2022
 - Marius Feilhauer - Compile- and Run-Time Dependency Injection
 - Compile- and Run-Time Dependency Injection - Marius Feilhauer - C++ on Sea 2022
 - selected C++ projects
 - misc
 - ModernCppStarter
 - ModernCppStarter
 - Modern C++ Tutorial: C++11/14/17/20 On the Fly
 - Reading TAR files in C++
 - Error codes are far slower than exceptions
 - Single header implementation of std::expected with functional-style extensions
 - C++ Result
 - Book: A Complete Guide to Standard C++ Algorithms
 - vtable implementation with multiple inheritance
 - Python-Like enumerate() In C++17
 - Python's enumerate for C++
 
 wandbox
 - Find position of element in C++11 range-based for loop?
 tl;dr
 std::vector<std::string> strings{10, "Hello"}; int main(){ strings[5] = "World"; for(auto const& el: strings| boost::adaptors::indexed(0)) std::cout << el.index() << ": " << el.value() << std::endl; }
 - Bits of semi-finished C++ code
 - How to find out if there is any non ASCII character in a string with a file path
 tl;dr
```
auto isASCII = [](const std::string& s) -> bool
{
 return !std::any_of(s.begin(), s.end(), [](char c) {
 return !isascii(static_cast<unsigned char>(c));
 });
};
```

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

cpp.md

cpp.md

C++ language bookmarks

Files

cpp.md

Latest commit

History

cpp.md

File metadata and controls

C++ language bookmarks