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

Can you provide 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>

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

void increment() {
    counter++;
}

int main() {
    increment();
    std::cout << "Counter: " << counter.load() << std::endl;
    return 0;
}

This code safely increments a counter in a multi-threaded environment.

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 shared variables simultaneously. This can lead to undefined behavior, where the final value of the variable may not be what you expect.

Can you show me a more complex example?

Absolutely! Here's a more complex example using std::atomic with multiple threads:

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

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

void add_to_total(int value) {
    for (int i = 0; i < 1000; ++i) {
        total += value;
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(add_to_total, i);
    }
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "Total: " << total.load() << std::endl;
    return 0;
}

This example creates multiple threads that safely add to a shared total.

Are there any performance considerations with std::atomic?

Yes, while std::atomic provides thread safety, it can introduce some overhead compared to non-atomic operations. The performance impact depends on the architecture and the specific operations being performed. It's important to balance safety and performance based on your application's needs.