# stdatomic

***

**1. Incrementing a shared counter**

```c
#include <stdatomic.h>

int main() {
    _Atomic int counter = 0;
    atomic_fetch_add(&counter, 1);  // Increment the counter by 1
    return 0;
}
```

**2. Checking if a value is equal to a certain value**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value = 42;
    if (atomic_load(&value) == 42) {
        // Do something
    }
    return 0;
}
```

**3. Updating a shared value conditionally**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value = 0;
    atomic_exchange(&value, 1);  // Set the value to 1 if it is currently 0
    return 0;
}
```

**4. Atomically adding two values**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value1 = 1;
    _Atomic int value2 = 2;
    atomic_fetch_add(&value1, value2);  // Add value2 to value1
    return 0;
}
```

**5. Atomically subtracting two values**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value1 = 10;
    _Atomic int value2 = 5;
    atomic_fetch_sub(&value1, value2);  // Subtract value2 from value1
    return 0;
}
```

**6. Atomically multiplying two values**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value1 = 2;
    _Atomic int value2 = 3;
    atomic_fetch_mul(&value1, value2);  // Multiply value1 by value2
    return 0;
}
```

**7. Atomically dividing two values**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value1 = 10;
    _Atomic int value2 = 5;
    atomic_fetch_div(&value1, value2);  // Divide value1 by value2
    return 0;
}
```

**8. Atomically bitwise ANDing two values**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value1 = 0x0F;
    _Atomic int value2 = 0x0A;
    atomic_fetch_and(&value1, value2);  // Perform a bitwise AND on value1 and value2
    return 0;
}
```

**9. Atomically bitwise ORing two values**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value1 = 0x0F;
    _Atomic int value2 = 0x0A;
    atomic_fetch_or(&value1, value2);  // Perform a bitwise OR on value1 and value2
    return 0;
}
```

**10. Atomically bitwise XORing two values**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value1 = 0x0F;
    _Atomic int value2 = 0x0A;
    atomic_fetch_xor(&value1, value2);  // Perform a bitwise XOR on value1 and value2
    return 0;
}
```

**11. Atomically storing a value**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value = 0;
    atomic_store(&value, 42);  // Store the value 42 in the atomic variable
    return 0;
}
```

**12. Atomically loading a value**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value = 42;
    int loaded_value = atomic_load(&value);  // Load the value from the atomic variable
    return 0;
}
```

**13. Atomically exchanging two values**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value1 = 10;
    _Atomic int value2 = 20;
    atomic_exchange(&value1, value2);  // Exchange the values of value1 and value2
    return 0;
}
```

**14. Atomically comparing and exchanging two values**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value1 = 10;
    _Atomic int value2 = 20;
    if (atomic_compare_exchange_strong(&value1, &value2, 30)) {
        // The exchange was successful
    }
    return 0;
}
```

**15. Atomically fetching the old value and setting a new value**

```c
#include <stdatomic.h>

int main() {
    _Atomic int value1 = 10;
    int old_value = atomic_fetch_set(&value1, 20);  // Fetch the old value and set the new value
    return 0;
}
```

**16. Atomically adding a value to a pointer**

```c
#include <stdatomic.h>

int main() {
    int *ptr = malloc(sizeof(int));
    *ptr = 10;
    atomic_fetch_add((_Atomic int **)&ptr, 1);  // Increment the pointer by 1
    return

```