qi::Atomic provides support for atomic values, similarly to boost::atomic but with simpler methods.

Detailed Description

qi::Atomic comes with some macros to do one-time initializations in a thread-safe manner.

Atomic Operations

An atomic variable allows some operations to be atomic in a multithreaded environment.

#include <qi/atomic.hpp>

qi::Atomic<int> var = 0;

void myFunction()
  if (var.setIfEquals(0, 1))
    std::cout << "Set to one!";

int main()


This program will always print “Set to one!” once, since only one setIfEquals can succeed. All methods in qi::Atomic are atomic and thus threadsafe, they all provide a total ordering of operations.

Two macros are defined in this file:


qi::Atomic Class Reference



#include <qi/atomic.hpp>

Public Members

std::atomic<T> _value

Public Functions

Atomic(T value)
Atomic(const Atomic& other)
T operator++()
T operator--()
T operator++(int)
T operator--(int)
Atomic<T>& operator=(T value)
Atomic<T>& operator=(const Atomic<T>& value)
bool setIfEquals(T testValue, T setValue)
T swap(T value)
T operator*() const
T load() const

Detailed Description

Atomic operations on integrals.

This class allows to do operations on an integral value from multiple threads, with the guarantee that each operation will not lead to a data race.

This is a simplification layer over the standard atomic type. If you understand the standard atomic, it might be preferable to use it.

Members Documentation

std::atomic<T> qi::Atomic<T>::_value

Function Documentation

qi::Atomic<T>::Atomic(T value)


  • value – The default value of the atomic.

Atomic constructor setting value to its parameter.

qi::Atomic<T>::Atomic(const Atomic& other)
T qi::Atomic<T>::operator++()

Atomic pre-increment of the value.

T qi::Atomic<T>::operator--()

Atomic pre-decrement of the value.

T qi::Atomic<T>::operator++(int)

Atomic post-increment of the value.

T qi::Atomic<T>::operator--(int)

Atomic post-decrement of the value.

Atomic<T>& qi::Atomic<T>::operator=(T value)
Atomic<T>& qi::Atomic<T>::operator=(const Atomic<T>& value)
bool qi::Atomic<T>::setIfEquals(T testValue, T setValue)


Returns:true if swap was performed

If value is testValue, replace it with setValue.

T qi::Atomic<T>::swap(T value)


Returns:the previously held value

Swap the atomic value with value.

T qi::Atomic<T>::operator*() const

Return the contained valu Deprecated since 2.5.0

T qi::Atomic<T>::load() const