Back to .md Directory

ARCHITECTURE.md

C++ language bookmarks

+ [CPP C++ Papyrus](https://github.com/caiorss/C-Cpp-Notes)

May 2, 2026

0 downloads

0 views

ai

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_lock std::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<U> other; };
};

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

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

allocator<T>::rebind<U> 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<I>::type accumulate(I beg, I end, typename range_value<I>::type unit, Op op)
{
    typename range_value<I>::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) <chrono> 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<T>?
  - Clang refuses to compile libstdc++'s <filesystem> 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 <mutex>
```
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));
    });
};
```

Related Documents

ARCHITECTURE.md

Design Document: BharatSeva AI

BharatSeva AI is a multi-agent orchestration system built on AWS using Amazon Bedrock Agents with Claude 3.5 Sonnet as the foundation model. The system deploys 10 AI agents (1 Master Orchestrator + 9 Specialist Agents) to assist India's informal sector workers in navigating government schemes across three domains: PM Vishwakarma (artisan credit), PMFBY (crop insurance), and BOCW (construction worker welfare).

Prachet-Dev-Singh

ARCHITECTURE.md

OpenClaw Enterprise Transformation Plan

Transform OpenClaw from a single-user personal AI assistant into a **dual-mode platform** that is simultaneously:

ARCHITECTURE.md

Qwen Image and Edit: Open-sourcing and Local GGUF Generations with Lightning

Daniel Sandner, for article on https://sandner.art/

ARCHITECTURE.md

Qwen3-TTS — Model Reference

Models: `Qwen/Qwen3-TTS-12Hz-0.6B-CustomVoice` and `Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice`

gabriele-mastrapasqua