tones of updates

Author: behnamasadi

CMakeLists.txt

@@ -24,7 +24,7 @@ message("CMAKE_CXX_COMPILER_VERSION: " ${CMAKE_CXX_COMPILER_VERSION})
 
 add_executable(pointers src/pointers/pointers.cpp)
 
-#add_executable(string  src/string.cpp )
+add_executable(string  src/string.cpp )
 
 add_executable(exception_handling src/exception_handling.cpp)
 
@@ -280,6 +280,7 @@ add_executable(circular_dependency src/class/circular_dependency/circular_depend
 
 add_executable(core_dump src/core_dump.cpp)
 
+#add_executable(packaged_task src/packaged_task.cpp)
 
 if(${CMAKE_GNU_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION} GREATER_EQUAL 13)
     add_executable(printing_with_format src/printing_with_format.cpp)
@@ -353,6 +354,7 @@ if(testing_enabled)
 endif()
 
 
+option(SANITIZE "Add sanitizer flags" OFF)
 
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
@@ -362,18 +364,21 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 
     add_executable(align src/align.cpp)
 
-
-    set(CMAKE_CXX_FLAGS "-fsanitize=address ${CMAKE_CXX_FLAGS}")
-    set(CMAKE_CXX_FLAGS "-fno-omit-frame-pointer ${CMAKE_CXX_FLAGS}")
     add_executable(signals src/signals.cpp)
     add_executable(system_call src/system_call.cpp)
 
     # add_executable(date_time src/date_time.cpp)
-
     add_executable(fork src/fork.cpp)
 
 endif()
 
+if(SANITIZE)
+    set(CMAKE_CXX_FLAGS "-fsanitize=address ${CMAKE_CXX_FLAGS}")
+    set(CMAKE_CXX_FLAGS "-fno-omit-frame-pointer ${CMAKE_CXX_FLAGS}")
+endif(SANITIZE)
+
+
+
 add_executable(any src/any.cpp)
 
 

README.md

@@ -137,11 +137,23 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
    * [Assert](docs/assert.md)   
    * [Atomic operations and Atomic Types](docs/atomic.md)    
    * [Asynchronous programming](docs/asynchronous_programming.md)    
+     - [std::launch::async, std::future](docs/asynchronous_programming.md#std--launch--async--std--future)
+     - [Parallelization with ascync](docs/asynchronous_programming.md#parallelization-with-ascync)
+     - [Parallelization with std::packaged_task](docs/asynchronous_programming.md#parallelization-with-std--packaged-task)
    * [Attribute specifier sequence [[ attribute-list ]] ](docs/attribute_specifier_sequence.md)  
    * [Basic IO Operation, Streams, Reading/Writing Files, Formatting Output, cin, scanf, gets, getline, printf](docs/basic_IO_operation.md)  
    * [Bitset, Bit field, Bitwise Operations](docs/bitset_bit_field_bitwise_operations.md)  
-   * [Callbacks](docs/callbacks.md)  
-   * [Callable Objects, std::function, std::bind, Lambda](docs/callable_objects_function_bind_lambda.md)  
+   * [Callable Objects, Callbacks](docs/callable_callbacks.md)  
+     - [1. Function Pointers](docs/callable_callbacks.md#1-function-pointers)
+     - [2. Functor (Function Objects)](docs/callable_callbacks.md#2-functor--function-objects-)
+     - [3. std::function, std::placeholders, and std::bind](docs/callable_callbacks.md#3-std--function--std--placeholders--and-std--bind)
+     - [4. Lambda Functions](docs/callable_callbacks.md#4-lambda-functions)
+     - [5. Member Function Pointers](docs/callable_callbacks.md#5-member-function-pointers)
+     - [6. Signals and Slots](docs/callable_callbacks.md#6-signals-and-slots)
+     - [7. std::invoke](docs/callable_callbacks.md#7-std--invoke)
+     - [8. Packaged Tasks](docs/callable_callbacks.md#8-packaged-tasks)
+     - [9. Coroutines](docs/callable_callbacks.md#9-coroutines)
+     - [10. Auto-generated operator() from a Captureless Lambda](docs/callable_callbacks.md#10-auto-generated-operator---from-a-captureless-lambda)
    * [Clock, Date, Time](docs/date_time.md)   
    * [Conditional Compilation From CMakeLists](docs/conditional_compilation.md)  
    * [Containers](docs/containers.md)  
@@ -158,6 +170,7 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
    * [Dynamic Memory Allocation in C](docs/dynamic_memory_allocation.md)  
    * [Enum](docs/enum.md)  
    * [Error Handling](docs/error_handling.md)  
+   * [Error Code](docs/error_code.md)     
    * [Exception Handling, noexcept](docs/exception_handling.md)  
    * [Extern Variables, Extern Functions](docs/extern.md)  
    * [File System](docs/filesystem.md)  
@@ -166,7 +179,6 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
    * [Functions, Extern Function, Function Objects, Function Pointer, Inline Functions](docs/functions.md)  
    * [Hash Functions, Hash Data Structure (Hash Table)](docs/hash_function_hash_table.md)    
    * [Heap and Stack, Memory Layout of C Programs](docs/heap_and_stack_memory_layout_of_C_programs.md)  
-   * [Invoke](docs/std_invoke.md)   
    * [Iterator, for_each loop, range-for loop, Loop optimization](docs/iterator_loop.md)  
    * [Lambda](docs/lambda.md)  
    * [Literals](docs/literals.md)  
@@ -178,6 +190,7 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
    * [Numeral Systems in C++ Decimal, Binary, Octal, Hexadecimal](docs/numeral_system.md)   
    * [Optional](docs/optional.md)
    * [Parameter Pack Expansion ...](docs/parameter_pack_expansion_(...).md)  
+   * [Packaged Task](docs/packaged_task.md)  
    * [Register Keyword](docs/register.md)  
    * [Regex](docs/regex.md)  
    * [Pseudo-random Number Generation, Distributions](docs/random_number.md)

docs/asynchronous_programming.md

@@ -1,5 +1,8 @@
+# Asynchronous Calls
 In C++, asynchronous programming can be achieved using various mechanisms such as threads, `std::async`, `std::future`, and `std::promise`. One common way to create asynchronous calls is through `std::async` which runs a function asynchronously (potentially in a new thread) and returns a `std::future` that will hold the result of that function call once it completes.
 
+
+## std::launch::async, std::future
 Here is an example demonstrating an asynchronous call in C++ using `std::async`:
 
 ```c++
@@ -101,3 +104,118 @@ Explanation:
 - After the first lambda has finished its work and has waited for the second lambda, the main thread continues and waits for the first asynchronous task to complete by calling `work_future.get()`.
 
 By capturing by value, we ensure that each lambda has its own independent copy of the parameters, which is usually the safest way to pass parameters to asynchronous calls to avoid any potential data races or undefined behavior due to accessing shared data from multiple threads.
+
+
+
+
+## Parallelization with ascync
+
+
+```cpp
+#include <iostream>
+#include <vector>
+#include <numeric>
+#include <future>
+#include <thread>
+#include <iterator>
+
+// Function to sum a chunk of the vector
+template <typename Iterator>
+long long sum_chunk(Iterator begin, Iterator end) {
+    return std::accumulate(begin, end, 0LL);
+}
+
+int main() {
+    // Example vector
+    std::vector<int> vec(1000000, 1);  // Vector of 1 million elements, each initialized to 1
+
+    // Determine the number of chunks based on hardware concurrency
+    unsigned int num_chunks = std::thread::hardware_concurrency();
+    if (num_chunks == 0) num_chunks = 2; // Fallback in case hardware_concurrency returns 0
+
+    std::vector<std::future<long long>> futures;
+    size_t chunk_size = vec.size() / num_chunks;
+    auto begin = vec.begin();
+
+    // Launch async tasks for each chunk
+    for (unsigned int i = 0; i < num_chunks; ++i) {
+        auto end = (i == num_chunks - 1) ? vec.end() : std::next(begin, chunk_size);
+        futures.push_back(std::async(std::launch::async, sum_chunk<std::vector<int>::iterator>, begin, end));
+        begin = end;
+    }
+
+    // Collect the results from each chunk
+    long long total_sum = 0;
+    for (auto& future : futures) {
+        total_sum += future.get();
+    }
+
+    std::cout << "Total sum: " << total_sum << std::endl;
+
+    return 0;
+}
+```
+
+
+## Parallelization with std::packaged_task
+
+```cpp
+#include <iostream>
+#include <vector>
+#include <numeric>
+#include <thread>
+#include <future>
+#include <iterator>
+#include <functional>
+
+// Function to sum a chunk of the vector
+template <typename Iterator>
+long long sum_chunk(Iterator begin, Iterator end) {
+    return std::accumulate(begin, end, 0LL);
+}
+
+int main() {
+    // Example vector
+    std::vector<int> vec(1000000, 1);  // Vector of 1 million elements, each initialized to 1
+
+    // Determine the number of chunks based on hardware concurrency
+    unsigned int num_chunks = std::thread::hardware_concurrency();
+    if (num_chunks == 0) num_chunks = 2; // Fallback in case hardware_concurrency returns 0
+
+    std::vector<std::future<long long>> futures;
+    std::vector<std::thread> threads;
+    size_t chunk_size = vec.size() / num_chunks;
+    auto begin = vec.begin();
+
+    // Launch tasks for each chunk using std::packaged_task
+    for (unsigned int i = 0; i < num_chunks; ++i) {
+        auto end = (i == num_chunks - 1) ? vec.end() : std::next(begin, chunk_size);
+        
+        std::packaged_task<long long(std::vector<int>::iterator, std::vector<int>::iterator)> task(sum_chunk<std::vector<int>::iterator>);
+        futures.push_back(task.get_future());
+        
+        // Move the task to a new thread and execute it
+        threads.emplace_back(std::move(task), begin, end);
+        
+        begin = end;
+    }
+
+    // Collect the results from each chunk
+    long long total_sum = 0;
+    for (auto& future : futures) {
+        total_sum += future.get();
+    }
+
+    // Join all threads
+    for (auto& thread : threads) {
+        thread.join();
+    }
+
+    std::cout << "Total sum: " << total_sum << std::endl;
+
+    return 0;
+}
+
+```
+
+