template<typename T> struct atomic
{
  public:

    bool is_lock_free () { ... }

    T operator= (T i) { store (i); return (i); }
    void store (T i, memory_order m = memory_order_seq_cst) { ... }
    T load (memory_order m = memory_order_seq_cst) { ... }

    T operator++ () { ... }
    T operator-- () { ... }
    T fetch_add (T i, memory_order m = memory_order_seq_cst) { ... }
    T fetch_sub (T i, memory_order m = memory_order_seq_cst) { ... }

    T exchange (T i, memory_order m = memory_order_seq_cst) { ... }
    bool compare_exchange_weak (T& e, T i, memory_order succ, memory_order fail) { ... }
    bool compare_exchange_strong (T& e, T i, memory_order succ, memory_order fail) { ... }

    ...
}

enum memory_order
{
  memory_order_relaxed, // No ordering constraints
  memory_order_consume, // Load will be consume operation (no reordering of dependent data accesses)
  memory_order_acquire, // Load will be acquire operation (no reordering of arbitrary data accesses)
  memory_order_release, // Store will be release operation
  memory_order_acq_rel, // Load-modify-store will be acquire and release operation
  memory_order_seq_cst  // Any operation will be totally ordered acquire and release operation
};