libstdc++/api/a00005_source.html

// C compatibility header <stdatomic.h> -*- C++ -*-


// Copyright The GNU Toolchain Authors.

//

// This file is part of the GNU ISO C++ Library.  This library is free

// software; you can redistribute it and/or modify it under the

// terms of the GNU General Public License as published by the

// Free Software Foundation; either version 3, or (at your option)

// any later version.


// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.


// Under Section 7 of GPL version 3, you are granted additional

// permissions described in the GCC Runtime Library Exception, version

// 3.1, as published by the Free Software Foundation.


// You should have received a copy of the GNU General Public License and

// a copy of the GCC Runtime Library Exception along with this program;

// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

// <http://www.gnu.org/licenses/>.


/** @file include/stdatomic.h

 *  This is a Standard C++ Library header.

 */


#ifndef _GLIBCXX_STDATOMIC_H

#define _GLIBCXX_STDATOMIC_H


#if __cplusplus > 202002L

#include <atomic>


#define __cpp_lib_stdatomic_h 202011L


#define _Atomic(_Tp) std::atomic<_Tp>


using std::memory_order;

using std::memory_order_relaxed;

using std::memory_order_consume;

using std::memory_order_acquire;

using std::memory_order_release;

using std::memory_order_acq_rel;

using std::memory_order_seq_cst;

using std::atomic_flag;

using std::atomic_bool;

using std::atomic_char;

using std::atomic_schar;

using std::atomic_uchar;

using std::atomic_short;

using std::atomic_ushort;

using std::atomic_int;

using std::atomic_uint;

using std::atomic_long;

using std::atomic_ulong;

using std::atomic_llong;

using std::atomic_ullong;

#ifdef _GLIBCXX_USE_CHAR8_T

using std::atomic_char8_t;

#endif

using std::atomic_char16_t;

using std::atomic_char32_t;

using std::atomic_wchar_t;

#ifdef _GLIBCXX_USE_C99_STDINT_TR1

using std::atomic_int8_t;

using std::atomic_uint8_t;

using std::atomic_int16_t;

using std::atomic_uint16_t;

using std::atomic_int32_t;

using std::atomic_uint32_t;

using std::atomic_int64_t;

using std::atomic_uint64_t;

using std::atomic_int_least8_t;

using std::atomic_uint_least8_t;

using std::atomic_int_least16_t;

using std::atomic_uint_least16_t;

using std::atomic_int_least32_t;

using std::atomic_uint_least32_t;

using std::atomic_int_least64_t;

using std::atomic_uint_least64_t;

using std::atomic_int_fast8_t;

using std::atomic_uint_fast8_t;

using std::atomic_int_fast16_t;

using std::atomic_uint_fast16_t;

using std::atomic_int_fast32_t;

using std::atomic_uint_fast32_t;

using std::atomic_int_fast64_t;

using std::atomic_uint_fast64_t;

#endif

using std::atomic_intptr_t;

using std::atomic_uintptr_t;

using std::atomic_size_t;

using std::atomic_ptrdiff_t;

#ifdef _GLIBCXX_USE_C99_STDINT_TR1

using std::atomic_intmax_t;

using std::atomic_uintmax_t;

#endif

using std::atomic_is_lock_free;

using std::atomic_load;

using std::atomic_load_explicit;

using std::atomic_store;

using std::atomic_store_explicit;

using std::atomic_exchange;

using std::atomic_exchange_explicit;

using std::atomic_compare_exchange_strong;

using std::atomic_compare_exchange_strong_explicit;

using std::atomic_compare_exchange_weak;

using std::atomic_compare_exchange_weak_explicit;

using std::atomic_fetch_add;

using std::atomic_fetch_add_explicit;

using std::atomic_fetch_sub;

using std::atomic_fetch_sub_explicit;

using std::atomic_fetch_or;

using std::atomic_fetch_or_explicit;

using std::atomic_fetch_xor;

using std::atomic_fetch_xor_explicit;

using std::atomic_fetch_and;

using std::atomic_fetch_and_explicit;

using std::atomic_flag_test_and_set;

using std::atomic_flag_test_and_set_explicit;

using std::atomic_flag_clear;

using std::atomic_flag_clear_explicit;

using std::atomic_thread_fence;

using std::atomic_signal_fence;


#elif defined __clang__

# include_next <stdatomic.h>

#endif // C++23

#endif // _GLIBCXX_STDATOMIC_H

atomic

std::memory_order
memory_order
Enumeration for memory_order.
Definition: atomic_base.h:62

std::atomic
Generic atomic type, primary class template.
Definition: atomic:197

std::atomic< bool >
atomic<bool>
Definition: atomic:63

std::atomic< char >
Explicit specialization for char.
Definition: atomic:710

std::atomic< signed char >
Explicit specialization for signed char.
Definition: atomic:733

std::atomic< unsigned char >
Explicit specialization for unsigned char.
Definition: atomic:756

std::atomic< short >
Explicit specialization for short.
Definition: atomic:779

std::atomic< unsigned short >
Explicit specialization for unsigned short.
Definition: atomic:802

std::atomic< int >
Explicit specialization for int.
Definition: atomic:825

std::atomic< unsigned int >
Explicit specialization for unsigned int.
Definition: atomic:848

std::atomic< long >
Explicit specialization for long.
Definition: atomic:871

std::atomic< unsigned long >
Explicit specialization for unsigned long.
Definition: atomic:894

std::atomic< long long >
Explicit specialization for long long.
Definition: atomic:917

std::atomic< unsigned long long >
Explicit specialization for unsigned long long.
Definition: atomic:940

std::atomic< wchar_t >
Explicit specialization for wchar_t.
Definition: atomic:963

std::atomic< char16_t >
Explicit specialization for char16_t.
Definition: atomic:1012

std::atomic< char32_t >
Explicit specialization for char32_t.
Definition: atomic:1036

std::atomic_flag
atomic_flag
Definition: atomic_base.h:197