What are some examples of using std::atomic in C++?

Can you give me some examples of using std::atomic in C++?

Sure! std::atomic is used for atomic operations in C++. Here's a simple example:

#include <atomic>
#include <iostream>

int main() {
    std::atomic<int> counter(0);
    counter++; // Atomically increments the counter
    std::cout << "Counter: " << counter.load() << std::endl;
    return 0;
}

What does the load() function do in this context?

The load() function retrieves the current value of the atomic variable without modifying it. It's a thread-safe way to access the value.

Can you show me a more complex example with multiple threads?

Absolutely! Here's an example with multiple threads incrementing a shared atomic counter:

#include <atomic>
#include <thread>
#include <vector>
#include <iostream>

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000; ++i) {
        counter++;
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment);
    }
    for (auto& th : threads) {
        th.join();
    }
    std::cout << "Final Counter: " << counter.load() << std::endl;
    return 0;
}

What happens if I don't use std::atomic?

If you don't use std::atomic, you may encounter data races when multiple threads access and modify the same variable simultaneously, leading to undefined behavior.