pre post ++ -- added, pair updated

Author: behnamasadi

.appveyor.yml

@@ -32,7 +32,7 @@ install:
 before_build:
   - mkdir build
   - cd build
-  - cmake -G "Ninja" -A x64 ..
+  - cmake -G "Ninja"  ..
 
 build_script:
   - cmake --build . --config %CONFIGURATION%

README.md

@@ -1,7 +1,7 @@
 # [C++](#)
 
 <!---[![Build Status](https://app.travis-ci.com/behnamasadi/cpp_tutorials.svg?branch=master)](https://app.travis-ci.com/behnamasadi/cpp_tutorials)-->
-[![Build status](https://ci.appveyor.com/api/projects/status/i4omlfovqaswpj41/branch/master?svg=true)](https://ci.appveyor.com/project/behnamasadi/cpp-tutorials/branch/master)
+<!---[![Build status](https://ci.appveyor.com/api/projects/status/i4omlfovqaswpj41/branch/master?svg=true)](https://ci.appveyor.com/project/behnamasadi/cpp-tutorials/branch/master)-->
 ![build workflow](https://github.com/behnamasadi/cpp_tutorials/actions/workflows/docker-build.yml/badge.svg)
 ![alt text](https://img.shields.io/badge/license-BSD-blue.svg)
 
@@ -194,6 +194,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)  
+   * [Post-increment, Pre-increment, Unary plus](docs/post-increment_pre-increment.md)     
    * [Packaged Task](docs/packaged_task.md)  
    * [Register Keyword](docs/register.md)  
    * [Regex](docs/regex.md)  

docs/post-increment_pre-increment.md

@@ -0,0 +1,65 @@
+## Post-increment, Pre-increment
+
+**Understanding num++ and +num:**
+
+- **num++ (Post-increment):** Increments the value of `num` after the expression is evaluated.
+- **+num (Unary plus):** Returns the value of `num` without modifying it.
+
+**Cases where num++ and +num differ and cause different output:**
+
+1. **In expressions involving assignment:**
+   - **Example:**
+     ```c++
+     int num = 5;
+     int result1 = num++; // result1 will be 5, num will be 6
+     int result2 = +num; // result2 will be 6, num will remain 6
+     ```
+   - **Explanation:**
+     - In the first case, `result1` gets the original value of `num` (5), and then `num` is incremented to 6.
+     - In the second case, `result2` simply gets the current value of `num`, which is 6, without modifying it.
+
+2. **In function calls as arguments:**
+   - **Example:**
+     ```c++
+     void printValue(int value) {
+         cout << value << endl;
+     }
+
+     int num = 5;
+     printValue(num++); // Will print 5
+     printValue(+num); // Will print 6
+     ```
+   - **Explanation:**
+     - In the first case, the value of `num` (5) is passed to the function before it's incremented.
+     - In the second case, the value of `num` (6) is passed to the function directly.
+
+3. **In expressions involving logical operators:**
+   - **Example:**
+     ```c++
+     int num = 0;
+     bool result1 = num++ && false; // result1 will be false
+     bool result2 = +num && false; // result2 will be false
+     ```
+   - **Explanation:**
+     - In the first case, `num++` evaluates to 0, which is considered false in a logical context. Since the first operand is false, the entire expression is false.
+     - In the second case, `+num` evaluates to 0, which is still false. However, the evaluation of the second operand (false) is not necessary due to short-circuiting.
+
+4. **In expressions involving the comma operator:**
+   - **Example:**
+     ```c++
+     int num = 5;
+     int result1 = num++, num++; // result1 will be 6
+     int result2 = +num, +num; // result2 will be 6
+     ```
+   - **Explanation:**
+     - In the first case, the first `num++` evaluates to 5, and then the second `num++` evaluates to 6. The result of the comma expression is the value of the second operand, which is 6.
+     - In the second case, both `+num` expressions evaluate to 6, but the result of the comma expression is still the value of the second operand, which is 6.
+
+**Key points to remember:**
+
+- The difference between `num++` and `+num` lies in when the increment occurs.
+- `num++` increments the value after the expression is evaluated, while `+num` does not modify the value.
+- The choice between `num++` and `+num` depends on the desired behavior in the specific context.
+
+By understanding these cases and their implications, you can effectively use `num++` and `+num` in your C++ code to achieve the intended results.
+

docs/set_map_pair_tuple.md

@@ -584,6 +584,131 @@ courses.find(c2)->m_name;
 
 These examples demonstrate how `std::unordered_map` and `std::unordered_set` can be applied to solve practical problems efficiently, leveraging their strengths in situations where speed and unique data management are critical.
 
+
+
+In C++, `std::tie`, `std::pair`, and `std::tuple` are useful features provided by the Standard Library that allow you to handle multiple values together in a convenient and structured way. Here's a breakdown of each and how they can be used in real-world applications:
+
+### 1. `std::pair`
+A `std::pair` is a simple container that holds two values, which may be of different types. It is often used when you want to return two values from a function or associate two related values together.
+
+#### **Example: Using `std::pair` in a real-world application**
+
+Imagine you are building a function that returns the minimum and maximum values from an array of integers. You can use `std::pair` to return both values together:
+
+```cpp
+#include <iostream>
+#include <vector>
+#include <utility> // for std::pair
+
+std::pair<int, int> findMinMax(const std::vector<int>& numbers) {
+    int min = numbers[0];
+    int max = numbers[0];
+
+    for (int number : numbers) {
+        if (number < min) min = number;
+        if (number > max) max = number;
+    }
+
+    return std::make_pair(min, max); // Returning a pair of min and max
+}
+
+int main() {
+    std::vector<int> numbers = {3, 5, 1, 9, 2, 8, -1, 6};
+    std::pair<int, int> minMax = findMinMax(numbers);
+
+    std::cout << "Min: " << minMax.first << ", Max: " << minMax.second << std::endl;
+
+    return 0;
+}
+```
+
+### 2. `std::tuple`
+A `std::tuple` is like an extension of `std::pair` that can hold more than two values of potentially different types. It is useful when you need to return multiple values from a function or group related values together.
+
+#### **Example: Using `std::tuple` in a real-world application**
+
+Suppose you're writing a program to process student records, and you want a function that returns a student's name, age, and GPA. You can use `std::tuple` to return all three values together.
+
+```cpp
+#include <iostream>
+#include <tuple>
+#include <string>
+
+std::tuple<std::string, int, double> getStudentInfo() {
+    std::string name = "John Doe";
+    int age = 20;
+    double gpa = 3.75;
+
+    return std::make_tuple(name, age, gpa); // Returning a tuple of name, age, and GPA
+}
+
+int main() {
+    auto studentInfo = getStudentInfo();
+
+    std::string name;
+    int age;
+    double gpa;
+
+    // Unpacking the tuple using std::tie
+    std::tie(name, age, gpa) = studentInfo;
+
+    std::cout << "Name: " << name << ", Age: " << age << ", GPA: " << gpa << std::endl;
+
+    return 0;
+}
+```
+
+### 3. `std::tie`
+`std::tie` is used to unpack values from a `std::pair` or `std::tuple` into individual variables. This is especially handy when you don't want to deal with the tuple's index-based access.
+
+#### **Example: Using `std::tie` to unpack values**
+
+In the example above, `std::tie` is used to unpack the tuple into individual variables (`name`, `age`, and `gpa`). This makes the code more readable and convenient.
+
+Another example could be unpacking the return value of a function that returns a `std::pair`:
+
+```cpp
+#include <iostream>
+#include <vector>
+#include <tuple>
+#include <string>
+
+std::tuple<std::string, int, double> analyzeText(const std::string& text) {
+    int wordCount = 0;
+    int charCount = text.length();
+    double averageWordLength = charCount;
+
+    // Simple analysis: let's say each word is roughly 5 characters
+    wordCount = charCount / 5;
+    averageWordLength = charCount / static_cast<double>(wordCount);
+
+    return std::make_tuple(text, wordCount, averageWordLength);
+}
+
+int main() {
+    std::string text = "This is a simple example sentence.";
+    std::string analyzedText;
+    int wordCount;
+    double avgWordLength;
+
+    // Unpacking tuple returned from analyzeText
+    std::tie(analyzedText, wordCount, avgWordLength) = analyzeText(text);
+
+    std::cout << "Text: " << analyzedText << "\nWord Count: " << wordCount
+              << "\nAverage Word Length: " << avgWordLength << std::endl;
+
+    return 0;
+}
+```
+
+### Summary
+
+- **`std::pair`**: Useful for storing two related values, often used for returning two values from a function.
+- **`std::tuple`**: Extends `std::pair` by allowing more than two values of different types to be stored together.
+- **`std::tie`**: Simplifies unpacking `std::pair` or `std::tuple` into individual variables, improving code readability.
+
+
+
  
 # tie
 The work of `tie()` is to unpack the tuple values into seperate variables. There are two variants of `tie()`, with and without “ignore” ,