Namespaces
Variants

Standard library header <spanstream> (C++23)

From cppreference.net
C++
Standard library headers

Cet en-tête fait partie de la bibliothèque d'Entrée/Sortie .

Table des matières

Classes

(C++23)
implémente un périphérique de tampon de caractères brut fixe
(modèle de classe)
(C++23)
implémente les opérations d'entrée sur tampon de caractères fixe
(modèle de classe)
(C++23)
implémente les opérations de sortie sur tampon de caractères fixe
(modèle de classe)
(C++23)
implémente les opérations d'entrée/sortie sur tampon de caractères fixe
(modèle de classe)
spanbuf (C++23) std:: basic_spanbuf < char >
(typedef)
wspanbuf (C++23) std:: basic_spanbuf < wchar_t >
(typedef)
ispanstream (C++23) std:: basic_ispanstream < char >
(typedef)
wispanstream (C++23) std:: basic_ispanstream < wchar_t >
(typedef)
ospanstream (C++23) std:: basic_ospanstream < char >
(typedef)
wospanstream (C++23) std:: basic_ospanstream < wchar_t >
(typedef)
spanstream (C++23) std:: basic_spanstream < char >
(typedef)
wspanstream (C++23) std:: basic_spanstream < wchar_t >
(typedef)

Fonctions

(C++23)
spécialise l'algorithme std::swap
(modèle de fonction)
(C++23)
spécialise l'algorithme std::swap
(modèle de fonction)
(C++23)
spécialise l'algorithme std::swap
(modèle de fonction)
(C++23)
spécialise l'algorithme std::swap
(modèle de fonction)

Synopsis 

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_spanbuf;
  using spanbuf = basic_spanbuf<char>;
  using wspanbuf = basic_spanbuf<wchar_t>;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_ispanstream;
  using ispanstream = basic_ispanstream<char>;
  using wispanstream = basic_ispanstream<wchar_t>;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_ospanstream;
  using ospanstream = basic_ospanstream<char>;
  using wospanstream = basic_ospanstream<wchar_t>;
  template<class CharT, class Traits = char_traits<CharT>>
    class basic_spanstream;
  using spanstream = basic_spanstream<char>;
  using wspanstream = basic_spanstream<wchar_t>;
}
Je constate que le contenu fourni est exclusivement du code C++ dans des balises ` 
`. Conformément à vos instructions :
- Aucune balise HTML ou attribut n'a été traduit
- Le code C++ dans les balises `
` est conservé intact
- Les termes spécifiques au C++ (namespace, template, class, using, etc.) sont préservés
- La mise en forme originale est maintenue
Le code ne contenant aucun texte traduisible en dehors des éléments de code protégés, aucun changement n'a été apporté au contenu.

Modèle de classe std::basic_spanbuf 

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
  class basic_spanbuf
    : public basic_streambuf<CharT, Traits> {
  public:
    using char_type      = CharT;
    using int_type       = typename Traits::int_type;
    using pos_type       = typename Traits::pos_type;
    using off_type       = typename Traits::off_type;
    using traits_type    = Traits;
    // constructeurs
    basic_spanbuf() : basic_spanbuf(ios_base::in | ios_base::out) {}
    explicit basic_spanbuf(ios_base::openmode which)
      : basic_spanbuf(std::span<CharT>(), which) {}
    explicit basic_spanbuf(
      std::span<CharT> s,
      ios_base::openmode which = ios_base::in | ios_base::out);
    basic_spanbuf(const basic_spanbuf&) = delete;
    basic_spanbuf(basic_spanbuf&& rhs);
    // assignation et échange
    basic_spanbuf& operator=(const basic_spanbuf&) = delete;
    basic_spanbuf& operator=(basic_spanbuf&& rhs);
    void swap(basic_spanbuf& rhs);
    // get et set
    std::span<CharT> span() const noexcept;
    void span(std::span<CharT> s) noexcept;
    protected:
    // fonctions virtuelles redéfinies
    basic_streambuf<CharT, Traits>* setbuf(CharT*, streamsize) override;
    pos_type seekoff(off_type off, ios_base::seekdir way,
                     ios_base::openmode which
                       = ios_base::in | ios_base::out) override;
    pos_type seekpos(pos_type sp,
                     ios_base::openmode which
                       = ios_base::in | ios_base::out) override;
  private:
    ios_base::openmode mode; // exposition uniquement
    std::span<CharT> buf; // exposition uniquement
  };
  template<class CharT, class Traits>
    void swap(basic_spanbuf<CharT, Traits>& x,
              basic_spanbuf<CharT, Traits>& y);
}

Modèle de classe std::basic_ispanstream 

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
  class basic_ispanstream
    : public basic_istream<CharT, Traits> {
  public:
    using char_type      = CharT;
    using int_type       = typename Traits::int_type;
    using pos_type       = typename Traits::pos_type;
    using off_type       = typename Traits::off_type;
    using traits_type    = Traits;
    // constructeurs
    explicit basic_ispanstream(
      std::span<CharT> s,
      ios_base::openmode which = ios_base::in);
    basic_ispanstream(const basic_ispanstream&) = delete;
    basic_ispanstream(basic_ispanstream&& rhs);
    template<class ROS>
    explicit basic_ispanstream(ROS&& s);
    // assignation et échange
    basic_ispanstream& operator=(const basic_ispanstream&) = delete;
    basic_ispanstream& operator=(basic_ispanstream&& rhs);
    void swap(basic_ispanstream& rhs);
    // membres
    basic_spanbuf<CharT, Traits>* rdbuf() const noexcept;
    std::span<const CharT> span() const noexcept;
    void span(std::span<CharT> s) noexcept;
    template<class ROS>
    void span(ROS&& s) noexcept;
  private:
    basic_spanbuf<CharT, Traits> sb; // exposition uniquement
  };
  template<class CharT, class Traits>
    void swap(basic_ispanstream<CharT, Traits>& x,
              basic_ispanstream<CharT, Traits>& y);
}

Modèle de classe std::basic_ospanstream 

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
  class basic_ospanstream
    : public basic_ostream<CharT, Traits> {
  public:
    using char_type      = CharT;
    using int_type       = typename Traits::int_type;
    using pos_type       = typename Traits::pos_type;
    using off_type       = typename Traits::off_type;
    using traits_type    = Traits;
    // constructeurs
    explicit basic_ospanstream(
      std::span<CharT> s,
      ios_base::openmode which = ios_base::out);
    basic_ospanstream(const basic_ospanstream&) = delete;
    basic_ospanstream(basic_ospanstream&& rhs);
    // assignation et échange
    basic_ospanstream& operator=(const basic_ospanstream&) = delete;
    basic_ospanstream& operator=(basic_ospanstream&& rhs);
    void swap(basic_ospanstream& rhs);
    // membres
    basic_spanbuf<CharT, Traits>* rdbuf() const noexcept;
    std::span<CharT> span() const noexcept;
    void span(std::span<CharT> s) noexcept;
  private:
    basic_spanbuf<CharT, Traits> sb; // exposition uniquement
  };
  template<class CharT, class Traits>
    void swap(basic_ospanstream<CharT, Traits>& x,
              basic_ospanstream<CharT, Traits>& y);
}

Modèle de classe std::basic_spanstream 

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
  class basic_spanstream
    : public basic_iostream<CharT, Traits> {
  public:
    using char_type     = CharT;
    using int_type      = typename Traits::int_type;
    using pos_type      = typename Traits::pos_type;
    using off_type      = typename Traits::off_type;
    using traits_type   = Traits;
    // constructeurs
    explicit basic_spanstream(
      std::span<CharT> s,
      ios_base::openmode which = ios_base::out | ios_base::in);
    basic_spanstream(const basic_spanstream&) = delete;
    basic_spanstream(basic_spanstream&& rhs);
    // assignation et échange
    basic_spanstream& operator=(const basic_spanstream&) = delete;
    basic_spanstream& operator=(basic_spanstream&& rhs);
    void swap(basic_spanstream& rhs);
    // membres
    basic_spanbuf<CharT, Traits>* rdbuf() const noexcept;
    std::span<CharT> span() const noexcept;
    void span(std::span<CharT> s) noexcept;
  private:
    basic_spanbuf<CharT, Traits> sb; // exposition uniquement
  };
  template<class CharT, class Traits>
    void swap(basic_spanstream<CharT, Traits>& x,
              basic_spanstream<CharT, Traits>& y);
}