Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/header/stacktrace"

From cppreference.com
< cpp‎ | header
m (Add std::stacktrace type alias)
m (fix typo)
 
(6 intermediate revisions by 5 users not shown)
Line 1: Line 1:
 
{{cpp/header/title|stacktrace|notes={{mark c++23}}}}
 
{{cpp/header/title|stacktrace|notes={{mark c++23}}}}
 
{{cpp/header/navbar}}
 
{{cpp/header/navbar}}
−
This header is part of the [[cpp/utility|general utility]] library.
+
This header is part of the [[cpp/error|diagnostics]] library.
  
 
{{dsc begin}}<!--
 
{{dsc begin}}<!--
−
{{dsc h1 | Includes}}
+
{{dsc h1|Includes}}
−
{{dsc inc | cpp/header/dsc compare}}
+
{{dsc inc|cpp/header/dsc compare}}
 
-->
 
-->
−
{{dsc h1 | Classes}}
+
{{dsc h1|Classes}}
−
{{dsc inc | cpp/utility/dsc stacktrace_entry}}
+
{{dsc inc|cpp/utility/dsc stacktrace_entry}}
−
{{dsc inc | cpp/utility/dsc basic_stacktrace}}
+
{{dsc inc|cpp/utility/dsc basic_stacktrace}}
−
{{dsc | {{ltt|cpp/utility/basic_stacktrace|std::stacktrace}} | {{c|std::basic_stacktrace<std::allocator<std::stacktrace_entry>>}} {{mark typedef}} }}
+
{{dsc inc|cpp/utility/stacktrace_entry/dsc hash}}
−
{{dsc inc | cpp/utility/stacktrace_entry/dsc hash}}
+
{{dsc inc|cpp/utility/basic_stacktrace/dsc hash}}
−
{{dsc inc | cpp/utility/basic_stacktrace/dsc hash}}
+
{{dsc h2|Forward declarations}}
−
{{dsc h2 | Forward declarations}}
+
{{dsc header|functional}}
−
{{dsc header | functional}}
+
{{dsc inc|cpp/utility/dsc hash}}
−
{{dsc inc | cpp/utility/dsc hash}}
+
{{dsc end}}
  
−
{{dsc h1 | Functions}}
+
{{dsc begin}}
−
{{dsc inc | cpp/utility/basic_stacktrace/dsc swap2}}
+
{{dsc h2|Type aliases}}
−
{{dsc inc | cpp/utility/stacktrace_entry/dsc to_string}}
+
{{dsc hitem|Alias|Type}}
−
{{dsc inc | cpp/utility/basic_stacktrace/dsc to_string}}
+
{{dsc|{{ttb|std::stacktrace}}|{{co|std::basic_stacktrace<std::allocator<std::stacktrace_entry>>}}}}
−
{{dsc inc | cpp/utility/stacktrace_entry/dsc operator ltlt}}
+
{{dsc|{{ttb|std::pmr::stacktrace}}|{{c/core|std::pmr::basic_stacktrace<}}<br>  {{nbspt|4}}{{c/core|std::pmr::polymorphic_allocator<std::stacktrace_entry>>}}}}
−
{{dsc inc | cpp/utility/basic_stacktrace/dsc operator ltlt}}
+
{{dsc end}}
 +
 
 +
{{dsc begin}}
 +
{{dsc h1|Functions}}
 +
{{dsc inc|cpp/utility/basic_stacktrace/dsc swap2}}
 +
{{dsc inc|cpp/utility/stacktrace_entry/dsc to_string}}
 +
{{dsc inc|cpp/utility/basic_stacktrace/dsc to_string}}
 +
{{dsc inc|cpp/utility/stacktrace_entry/dsc operator ltlt}}
 +
{{dsc inc|cpp/utility/basic_stacktrace/dsc operator ltlt}}
 
{{dsc end}}
 
{{dsc end}}
  
 
===Synopsis===
 
===Synopsis===
−
{{source|1=
+
{{cpp/synopsis/stacktrace}}
−
namespace std {
+
−
  // class stacktrace_entry
+
−
  class stacktrace_entry;
+
−
 
+
−
  // class template basic_stacktrace
+
−
  template<class Allocator>
+
−
    class basic_stacktrace;
+
−
 
+
−
  // basic_stacktrace typedef names
+
−
  using stacktrace = basic_stacktrace<allocator<stacktrace_entry>>;
+
−
 
+
−
  // non-member functions
+
−
  template<class Allocator>
+
−
    void swap(basic_stacktrace<Allocator>& a, basic_stacktrace<Allocator>& b)
+
−
      noexcept(noexcept(a.swap(b)));
+
−
 
+
−
  string to_string(const stacktrace_entry& f);
+
−
 
+
−
  template<class Allocator>
+
−
    string to_string(const basic_stacktrace<Allocator>& st);
+
−
 
+
−
  template<class CharT, class traits>
+
−
    basic_ostream<CharT, traits>&
+
−
      operator<<(basic_ostream<CharT, traits>& os, const stacktrace_entry& f);
+
−
 
+
−
  template<class CharT, class Traits, class Allocator>
+
−
    basic_ostream<CharT, traits>&
+
−
      operator<<(basic_ostream<CharT, Traits>& os, const basic_stacktrace<Allocator>& st);
+
−
 
+
−
  namespace pmr {
+
−
    using stacktrace = std::basic_stacktrace<polymorphic_allocator<stacktrace_entry>>;
+
−
  }
+
−
 
+
−
  // hash support
+
−
  template<class T> struct hash;
+
−
  template<> struct hash<stacktrace_entry>;
+
−
  template<class Allocator> struct hash<basic_stacktrace<Allocator>>;
+
−
}
+
−
}}
+
−
 
+
−
====Class {{lc|std::stacktrace_entry}}====
+
−
{{source|1=
+
−
namespace std {
+
−
  class stacktrace_entry {
+
−
  public:
+
−
    using native_handle_type = /* implementation-defined */;
+
−
 
+
−
    // constructors
+
−
    constexpr stacktrace_entry() noexcept;
+
−
    constexpr stacktrace_entry(const stacktrace_entry& other) noexcept;
+
−
    constexpr stacktrace_entry& operator=(const stacktrace_entry& other) noexcept;
+
−
 
+
−
    ~stacktrace_entry();
+
−
 
+
−
    // observers
+
−
    constexpr native_handle_type native_handle() const noexcept;
+
−
    constexpr explicit operator bool() const noexcept;
+
−
 
+
−
    // query
+
−
    string description() const;
+
−
    string source_file() const;
+
−
    uint_least32_t source_line() const;
+
−
 
+
−
    // comparison
+
−
    friend constexpr bool operator==(const stacktrace_entry& x,
+
−
                                    const stacktrace_entry& y) noexcept;
+
−
    friend constexpr strong_ordering operator<=>(const stacktrace_entry& x,
+
−
                                                const stacktrace_entry& y) noexcept;
+
−
  };
+
−
}
+
−
}}
+
−
 
+
−
====Class template {{lc|std::basic_stacktrace}}====
+
−
{{source|1=
+
−
namespace std {
+
−
  template<class Allocator>
+
−
  class basic_stacktrace {
+
−
  public:
+
−
    using value_type = stacktrace_entry;
+
−
    using const_reference = const value_type&;
+
−
    using reference = value_type&;
+
−
    using const_iterator = /* implementation-defined */;
+
−
    using iterator = const_iterator;
+
−
    using reverse_iterator = std::reverse_iterator<iterator>;
+
−
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
−
    using difference_type = /* implementation-defined */;
+
−
    using size_type = /* implementation-defined */;
+
−
    using allocator_type = Allocator;
+
−
 
+
−
    // creation and assignment
+
−
    static basic_stacktrace
+
−
      current(const allocator_type& alloc = allocator_type()) noexcept;
+
−
    static basic_stacktrace
+
−
      current(size_type skip, const allocator_type& alloc = allocator_type()) noexcept;
+
−
    static basic_stacktrace
+
−
      current(size_type skip, size_type max_depth,
+
−
              const allocator_type& alloc = allocator_type()) noexcept;
+
−
 
+
−
    basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>);
+
−
    explicit basic_stacktrace(const allocator_type& alloc) noexcept;
+
−
 
+
−
    basic_stacktrace(const basic_stacktrace& other);
+
−
    basic_stacktrace(basic_stacktrace&& other) noexcept;
+
−
    basic_stacktrace(const basic_stacktrace& other, const allocator_type& alloc);
+
−
    basic_stacktrace(basic_stacktrace&& other, const allocator_type& alloc);
+
−
    basic_stacktrace& operator=(const basic_stacktrace& other);
+
−
    basic_stacktrace& operator=(basic_stacktrace&& other) noexcept(
+
−
        allocator_traits<Allocator>::propagate_on_container_move_assignment::value {{!!}}
+
−
        allocator_traits<Allocator>::is_always_equal::value);
+
−
 
+
−
    ~basic_stacktrace();
+
−
 
+
−
    // observers
+
−
    allocator_type get_allocator() const noexcept;
+
−
 
+
−
    const_iterator begin() const noexcept;
+
−
    const_iterator end() const noexcept;
+
−
    const_reverse_iterator rbegin() const noexcept;
+
−
    const_reverse_iterator rend() const noexcept;
+
−
 
+
−
    const_iterator cbegin() const noexcept;
+
−
    const_iterator cend() const noexcept;
+
−
    const_reverse_iterator crbegin() const noexcept;
+
−
    const_reverse_iterator crend() const noexcept;
+
−
 
+
−
    [[nodiscard]] bool empty() const noexcept;
+
−
    size_type size() const noexcept;
+
−
    size_type max_size() const noexcept;
+
−
 
+
−
    const_reference operator[](size_type) const;
+
−
    const_reference at(size_type) const;
+
−
 
+
−
    // comparisons
+
−
    template<class Allocator2>
+
−
    friend bool operator==(const basic_stacktrace& x,
+
−
                          const basic_stacktrace<Allocator2>& y) noexcept;
+
−
    template<class Allocator2>
+
−
    friend strong_ordering operator<=>(const basic_stacktrace& x,
+
−
                                      const basic_stacktrace<Allocator2>& y) noexcept;
+
−
 
+
−
    // modifiers
+
−
    void swap(basic_stacktrace& other)
+
−
      noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value {{!!}}
+
−
        allocator_traits<Allocator>::is_always_equal::value);
+
−
 
+
−
  private:
+
−
    vector<value_type, allocator_type> frames_;        // exposition only
+
−
  };
+
−
}
+
−
}}
+
  
 
{{langlinks|es|ja|ru|zh}}
 
{{langlinks|es|ja|ru|zh}}

Latest revision as of 09:17, 1 May 2024

 
C++
 
Standard library headers
 

This header is part of the diagnostics library.

Contents

Classes

(C++23)
 representation of an evaluation in a stacktrace
(class) [edit]
(C++23)
 approximate representation of an invocation sequence consists of stacktrace entries
(class template) [edit]
(C++23)
 hash support for std::stacktrace_entry
(class template specialization) [edit]
(C++23)
 hash support for std::basic_stacktrace
(class template specialization) [edit]
Forward declarations
Defined in header <functional>
(C++11)
 hash function object
(class template) [edit]
Type aliases
Alias Type
std::stacktrace std::basic_stacktrace<std::allocator<std::stacktrace_entry>>
std::pmr::stacktrace std::pmr::basic_stacktrace<
    std::pmr::polymorphic_allocator<std::stacktrace_entry>>

Functions

(C++23)
 specializes the std::swap algorithm
(function template) [edit]
(C++23)
 returns a string with a description of the stacktrace_entry
(function) [edit]
(C++23)
 returns a string with a description of the basic_stacktrace
(function template) [edit]
(C++23)
 performs stream output of stacktrace_entry
(function template) [edit]
(C++23)
 performs stream output of basic_stracktrace
(function template) [edit]

[edit] Synopsis

namespace std {
  // class stacktrace_entry
  class stacktrace_entry;
 
  // class template basic_stacktrace
  template<class Allocator>
    class basic_stacktrace;
 
  // basic_stacktrace typedef names
  using stacktrace = basic_stacktrace<allocator<stacktrace_entry>>;
 
  // non-member functions
  template<class Allocator>
    void swap(basic_stacktrace<Allocator>& a, basic_stacktrace<Allocator>& b)
      noexcept(noexcept(a.swap(b)));
 
  string to_string(const stacktrace_entry& f);
 
  template<class Allocator>
    string to_string(const basic_stacktrace<Allocator>& st);
 
  ostream& operator<<(ostream& os, const stacktrace_entry& f);
 
  template<class Allocator>
    ostream& operator<<(ostream& os, const basic_stacktrace<Allocator>& st);
 
  namespace pmr {
    using stacktrace = std::basic_stacktrace<polymorphic_allocator<stacktrace_entry>>;
  }
 
  // hash support
  template<class T> struct hash;
  template<> struct hash<stacktrace_entry>;
  template<class Allocator> struct hash<basic_stacktrace<Allocator>>;
}

[edit] Class std::stacktrace_entry

namespace std {
  class stacktrace_entry {
  public:
    using native_handle_type = /* implementation-defined */;
 
    // constructors
    constexpr stacktrace_entry() noexcept;
    constexpr stacktrace_entry(const stacktrace_entry& other) noexcept;
    constexpr stacktrace_entry& operator=(const stacktrace_entry& other) noexcept;
 
    ~stacktrace_entry();
 
    // observers
    constexpr native_handle_type native_handle() const noexcept;
    constexpr explicit operator bool() const noexcept;
 
    // query
    string description() const;
    string source_file() const;
    uint_least32_t source_line() const;
 
    // comparison
    friend constexpr bool operator==(const stacktrace_entry& x,
                                     const stacktrace_entry& y) noexcept;
    friend constexpr strong_ordering operator<=>(const stacktrace_entry& x,
                                                 const stacktrace_entry& y) noexcept;
  };
}

[edit] Class template std::basic_stacktrace

namespace std {
  template<class Allocator>
  class basic_stacktrace {
  public:
    using value_type = stacktrace_entry;
    using const_reference = const value_type&;
    using reference = value_type&;
    using const_iterator = /* implementation-defined */;
    using iterator = const_iterator;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    using difference_type = /* implementation-defined */;
    using size_type = /* implementation-defined */;
    using allocator_type = Allocator;
 
    // creation and assignment
    static basic_stacktrace
      current(const allocator_type& alloc = allocator_type()) noexcept;
    static basic_stacktrace
      current(size_type skip, const allocator_type& alloc = allocator_type()) noexcept;
    static basic_stacktrace
      current(size_type skip, size_type max_depth,
              const allocator_type& alloc = allocator_type()) noexcept;
 
    basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>);
    explicit basic_stacktrace(const allocator_type& alloc) noexcept;
 
    basic_stacktrace(const basic_stacktrace& other);
    basic_stacktrace(basic_stacktrace&& other) noexcept;
    basic_stacktrace(const basic_stacktrace& other, const allocator_type& alloc);
    basic_stacktrace(basic_stacktrace&& other, const allocator_type& alloc);
    basic_stacktrace& operator=(const basic_stacktrace& other);
    basic_stacktrace& operator=(basic_stacktrace&& other) noexcept(
        allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
        allocator_traits<Allocator>::is_always_equal::value);
 
    ~basic_stacktrace();
 
    // observers
    allocator_type get_allocator() const noexcept;
 
    const_iterator begin() const noexcept;
    const_iterator end() const noexcept;
    const_reverse_iterator rbegin() const noexcept;
    const_reverse_iterator rend() const noexcept;
 
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
    const_reverse_iterator crbegin() const noexcept;
    const_reverse_iterator crend() const noexcept;
 
    bool empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
 
    const_reference operator[](size_type) const;
    const_reference at(size_type) const;
 
    // comparisons
    template<class Allocator2>
    friend bool operator==(const basic_stacktrace& x,
                           const basic_stacktrace<Allocator2>& y) noexcept;
    template<class Allocator2>
    friend strong_ordering operator<=>(const basic_stacktrace& x,
                                       const basic_stacktrace<Allocator2>& y) noexcept;
 
    // modifiers
    void swap(basic_stacktrace& other)
      noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
        allocator_traits<Allocator>::is_always_equal::value);
 
  private:
    vector<value_type, allocator_type> frames_;         // exposition only
  };
}
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/stacktrace&oldid=171445"