STD::BASIC_REGEX(3cxx)

📦

version 14-20240412 · 19 versions

✨ std::basic_regex< _Ch_type, _Rx_traits > ✨

okay bestie, so this is the manual for std::basic_regex from the C++ standard library (3cxx section, iykyk). it's literally the class template for regular expressions and we're about to get into it 💅

🌸 NAME 🌸

std::basic_regex< _Ch_type, _Rx_traits > — A regular expression. that's it. that's the vibe. 🎀

🦋 SYNOPSIS 🦋

#include <regex>

💜 Public Types

typedef regex_constants::syntax_option_type flag_type — the type for all those grammar flags ✨
typedef traits_type::locale_type locale_type — locale vibes
typedef traits_type::string_type string_type — string vibes
typedef _Rx_traits traits_type — traits, obvi
typedef _Ch_type value_type — the char type, main character energy 👑

🎀 Public Member Functions

basic_regex () noexcept — default constructor, no args needed
template<typename _FwdIter > basic_regex (_FwdIter __first, _FwdIter __last, flag_type __f=ECMAScript) — Constructs a basic regular expression from the range [first, last) interpreted according to the flags in f.
basic_regex (basic_regex &&__rhs) noexcept=default — Move-constructs a basic regular expression. slay, efficient.
basic_regex (const _Ch_type *__p, flag_type __f=ECMAScript) — Constructs a basic regular expression from the sequence [__p, __p + char_traits<_Ch_type>::length(__p)) interpreted according to the flags in __f.
basic_regex (const _Ch_type *__p, std::size_t __len, flag_type __f=ECMAScript) — Constructs a basic regular expression from the sequence [p, p + len) interpreted according to the flags in f.
basic_regex (const basic_regex &__rhs)=default — Copy-constructs a basic regular expression.
template<typename _Ch_traits , typename _Ch_alloc > basic_regex (const std::basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &__s, flag_type __f=ECMAScript) — Constructs a basic regular expression from the string s interpreted according to the flags in f.
basic_regex (initializer_list< _Ch_type > __l, flag_type __f=ECMAScript) — Constructs a basic regular expression from an initializer list. cute and compact 🎀
~basic_regex () — Destroys a basic regular expression. rip bestie 💀
template<typename _InputIterator > basic_regex & assign (_InputIterator __first, _InputIterator __last, flag_type __flags=ECMAScript) — Assigns a new regular expression to a regex object.
basic_regex & assign (basic_regex &&__rhs) noexcept — Move-assigns one regular expression to another.
basic_regex & assign (const _Ch_type *__p, flag_type __flags=ECMAScript) — Assigns a new regular expression to a regex object from a C-style null-terminated string containing a regular expression pattern.
basic_regex & assign (const _Ch_type *__p, size_t __len, flag_type __flags=ECMAScript) — Assigns a new regular expression to a regex object from a C-style string containing a regular expression pattern.
basic_regex & assign (const basic_regex &__rhs) noexcept — Assigns one regular expression to another.
template<typename _Ch_traits , typename _Alloc > basic_regex & assign (const basic_string< _Ch_type, _Ch_traits, _Alloc > &__s, flag_type __flags=ECMAScript) — Assigns a new regular expression to a regex object from a string containing a regular expression pattern.
basic_regex & assign (initializer_list< _Ch_type > __l, flag_type __flags=ECMAScript) — Assigns a new regular expression to a regex object.
flag_type flags () const noexcept — Gets the flags used to construct the regular expression or in the last call to assign().
locale_type getloc () const noexcept — Gets the locale currently imbued in the regular expression object.
locale_type imbue (locale_type __loc) — Imbues the regular expression object with the given locale. giving it the vibes ✨
unsigned int mark_count () const noexcept — Gets the number of marked subexpressions within the regular expression.
basic_regex & operator= (basic_regex &&)=default — Move-assigns one regular expression to another.
basic_regex & operator= (const _Ch_type *__p) — Replaces a regular expression with a new one constructed from a C-style null-terminated string.
basic_regex & operator= (const basic_regex &)=default — Assigns one regular expression to another.
template<typename _Ch_traits , typename _Alloc > basic_regex & operator= (const basic_string< _Ch_type, _Ch_traits, _Alloc > &__s) — Replaces a regular expression with a new one constructed from a string.
basic_regex & operator= (initializer_list< _Ch_type > __l) — Replaces a regular expression with a new one constructed from an initializer list.
void swap (basic_regex &__rhs) noexcept — Swaps the contents of two regular expression objects. trading places, iconic 💅

🌈 Static Public Attributes

Constants

std [28.8.1](1)

static constexpr flag_type icase — case-insensitive flag
static constexpr flag_type nosubs — no subexpressions flag
static constexpr flag_type optimize — optimization flag
static constexpr flag_type collate — collate flag
static constexpr flag_type ECMAScript — the ECMAScript grammar flag (the default, main character energy 👑)
static constexpr flag_type basic — basic POSIX grammar flag
static constexpr flag_type extended — extended POSIX grammar flag
static constexpr flag_type awk — awk grammar flag
static constexpr flag_type grep — grep grammar flag
static constexpr flag_type egrep — egrep grammar flag
static constexpr flag_type multiline — multiline flag ✨

Friends

template<typename _Bp , typename _Ap , typename _Cp , typename _Rp > bool __detail::__regex_algo_impl (_Bp, _Bp, match_results< _Bp, _Ap > &, const basic_regex< _Cp, _Rp > &, regex_constants::match_flag_type, __detail::_RegexExecutorPolicy, bool) — friend function, internal regex algorithm impl
template<typename , typename , typename , bool > class __detail::_Executor — friend class, the executor

(Note that these are not member symbols.)

template<typename _Ch_type , typename _Rx_traits > void swap (basic_regex< _Ch_type, _Rx_traits > &__lhs, basic_regex< _Ch_type, _Rx_traits > &__rhs) noexcept — Swaps the contents of two regular expression objects. the free-function version, we love to see it 🫶

🌟 Detailed Description 🌟

template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>>
    class std::basic_regex< _Ch_type, _Rx_traits >

"A regular expression.

okay so here's the tea bestie: Specializations of this class template represent regular expressions constructed from sequences of character type _Ch_type. Use the std::regex typedef for std::basic_regex<char>. iykyk ✨

A character sequence passed to the constructor will be parsed according to the chosen grammar, and used to create a state machine representing the regular expression. The regex object can then be passed to algorithms such as std::regex_match to match sequences of characters. it's giving compiler energy fr fr 💅

The syntax_option_type flag passed to the constructor selects from one of the supported regular expression grammars. The default is ECMAScript and the others are basic, extended, awk, grep, and egrep, which are variations on POSIX regular expressions. so many options, all iconic 🌈

Since: C++11 🎀

🧚 Constructor & Destructor Documentation 🧚

constructor: `basic_regex ()`

template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
    std::basic_regex< _Ch_type, _Rx_traits >::basic_regex () [inline],
    [noexcept]

Constructs a basic regular expression that does not match any character sequence. it's the empty regex, lowkey useless but highkey valid ✨

constructor: `basic_regex (const _Ch_type *__p, flag_type __f = ECMAScript)`

template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
    std::basic_regex< _Ch_type, _Rx_traits >::basic_regex (const _Ch_type *
    __p, flag_type __f = ECMAScript) [inline],  [explicit]

Constructs a basic regular expression from the sequence [__p, __p + char_traits<_Ch_type>::length(__p)) interpreted according to the flags in __f.

Parameters

__p — A pointer to the start of a C-style null-terminated string containing a regular expression.
__f — Flags indicating the syntax rules and options.

Exceptions

regex_error if __p is not a valid regular expression. so if you mess up, you'll know 😭

constructor: `basic_regex (const _Ch_type *__p, std::size_t __len, flag_type __f = ECMAScript)`

template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
    std::basic_regex< _Ch_type, _Rx_traits >::basic_regex (const _Ch_type *
    __p, std::size_t __len, flag_type __f = ECMAScript) [inline]

Constructs a basic regular expression from the sequence [p, p + len) interpreted according to the flags in f.

Parameters

__p — A pointer to the start of a string containing a regular expression.
__len — The length of the string containing the regular expression.
__f — Flags indicating the syntax rules and options.

Exceptions

regex_error if __p is not a valid regular expression. bestie pls validate 🙈

constructor: `basic_regex (const basic_regex< _Ch_type, _Rx_traits > & __rhs)`

template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
    std::basic_regex< _Ch_type, _Rx_traits >::basic_regex (const
    basic_regex< _Ch_type, _Rx_traits > & __rhs) [default]

Copy-constructs a basic regular expression. twin vibes 🫶

Parameters

__rhs — A regex object.

constructor: `basic_regex (basic_regex< _Ch_type, _Rx_traits > && __rhs)`

template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
    std::basic_regex< _Ch_type, _Rx_traits >::basic_regex (basic_regex<
    _Ch_type, _Rx_traits > && __rhs) [default],  [noexcept]

Move-constructs a basic regular expression. moving on up, no cap 💅

Parameters

__rhs — A regex object.

constructor: `basic_regex (const std::basic_string< _Ch_type, _Ch_traits, _Ch_alloc > & __s, flag_type __f = ECMAScript)`

template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
    template<typename _Ch_traits , typename _Ch_alloc > std::basic_regex<
    _Ch_type, _Rx_traits >::basic_regex (const std::basic_string< _Ch_type,
    _Ch_traits, _Ch_alloc > & __s, flag_type __f = ECMAScript) [inline],
    [explicit]

Constructs a basic regular expression from the string s interpreted according to the flags in f. string girlies rise 🎀

Parameters

__s — A string containing a regular expression.
__f — Flags indicating the syntax rules and options.

Exceptions

regex_error if __s is not a valid regular expression.

constructor: `basic_regex (_FwdIter __first, _FwdIter __last, flag_type __f = ECMAScript)`

template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
    template<typename _FwdIter > std::basic_regex< _Ch_type, _Rx_traits
    >::basic_regex (_FwdIter __first, _FwdIter __last, flag_type __f =
    ECMAScript) [inline]

Constructs a basic regular expression from the range [first, last) interpreted according to the flags in f. iterators bestie, we love a range 🦋

Parameters

__first — The start of a range containing a valid regular expression.
__last — The end of a range containing a valid regular expression.
__f — The format flags of the regular expression.

Exceptions

regex_error if [__first, __last) is not a valid regular expression.

References: std::basic_regex< _Ch_type, _Rx_traits >::assign().

constructor: `basic_regex (initializer_list< _Ch_type > __l, flag_type __f = ECMAScript)`

template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
    std::basic_regex< _Ch_type, _Rx_traits >::basic_regex (initializer_list<
    _Ch_type > __l, flag_type __f = ECMAScript) [inline]

Constructs a basic regular expression from an initializer list. { 'a', 'b', 'c' } type beat ✨

Parameters

__l — The initializer list.
__f — The format flags of the regular expression.

Exceptions

regex_error if __l is not a valid regular expression.

destructor: `~basic_regex ()`

template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
    std::basic_regex< _Ch_type, _Rx_traits >::~basic_regex () [inline]

Destroys a basic regular expression. bye bestie, it was real 💀🫶

💅 MEMBER FUNCTION DOCUMENTATION 💅

Okay so this is the member-function era, and it's giving regex glow-up montage. Every overload of assign(), every operator=, plus the cute little utility functions — all here, bestie. No skips, no cap. ✨

🌸 `assign()` overloads: set the pattern, set the vibe 🌸

🎀 `assign(_InputIterator __first, _InputIterator __last, flag_type __flags = ECMAScript)` — range edition

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       template<typename _InputIterator > basic_regex & std::basic_regex<
       _Ch_type, _Rx_traits >::assign (_InputIterator __first, _InputIterator
       __last, flag_type __flags = ECMAScript) [inline]

Assigns a new regular expression to a regex object. It's a whole range moment, from __first to __last, and your regex object gets the assignment treatment.

Parameters:

__first — The start of a range containing a valid regular expression.
__last — The end of a range containing a valid regular expression.
__flags — Syntax option flags.

Exceptions: regex_error if p does not contain a valid regular expression pattern interpreted according to __flags. If regex_error is thrown, the object remains unchanged.

References: std::basic_regex< _Ch_type, _Rx_traits >::assign().

🌀 `assign(basic_regex< _Ch_type, _Rx_traits > && __rhs)` — move-assign, `noexcept` queen

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       basic_regex & std::basic_regex< _Ch_type, _Rx_traits >::assign
       (basic_regex< _Ch_type, _Rx_traits > && __rhs) [inline],  [noexcept]

Move-assigns one regular expression to another. Very "your pattern is my pattern now" energy. 💅

Parameters:

__rhs — Another regular expression object.

References: std::move().

🎀 `assign(const _Ch_type * __p, flag_type __flags = ECMAScript)` — C-string energy

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       basic_regex & std::basic_regex< _Ch_type, _Rx_traits >::assign (const
       _Ch_type * __p, flag_type __flags = ECMAScript) [inline]

Assigns a new regular expression to a regex object from a C-style null-terminated string containing a regular expression pattern.

Parameters:

__p — A pointer to a C-style null-terminated string containing a regular expression pattern.
__flags — Syntax option flags.

Exceptions: regex_error if __p does not contain a valid regular expression pattern interpreted according to __flags. If regex_error is thrown, *this remains unchanged.

🦋 `assign(const _Ch_type * __p, size_t __len, flag_type __flags = ECMAScript)` — pointer + length combo

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       basic_regex & std::basic_regex< _Ch_type, _Rx_traits >::assign (const
       _Ch_type * __p, size_t __len, flag_type __flags = ECMAScript) [inline]

Assigns a new regular expression to a regex object from a C-style string containing a regular expression pattern. This one lets you say exactly how long the pattern string is — very "I brought receipts" of it all. 🧾

Parameters:

__p — A pointer to a C-style string containing a regular expression pattern.
__len — The length of the regular expression pattern string.
__flags — Syntax option flags.

Exceptions: regex_error if p does not contain a valid regular expression pattern interpreted according to __flags. If regex_error is thrown, *this remains unchanged.

💖 `assign(const basic_regex< _Ch_type, _Rx_traits > & __rhs)` — copy-assign, `noexcept`

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       basic_regex & std::basic_regex< _Ch_type, _Rx_traits >::assign (const
       basic_regex< _Ch_type, _Rx_traits > & __rhs) [inline],  [noexcept]

Assigns one regular expression to another. Copy-paste but make it regex, and make it noexcept. ✨

Parameters:

__rhs — Another regular expression object.

Referenced by std::basic_regex< _Ch_type, _Rx_traits >::basic_regex(), std::basic_regex< _Ch_type, _Rx_traits >::assign(), std::basic_regex< _Ch_type, _Rx_traits >::operator=(), std::basic_regex< _Ch_type, _Rx_traits >::operator=(), and std::basic_regex< _Ch_type, _Rx_traits >::operator=().

🌈 `assign(const basic_string< _Ch_type, _Ch_traits, _Alloc > & __s, flag_type __flags = ECMAScript)` — string assign

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       template<typename _Ch_traits , typename _Alloc > basic_regex &
       std::basic_regex< _Ch_type, _Rx_traits >::assign (const basic_string<
       _Ch_type, _Ch_traits, _Alloc > & __s, flag_type __flags = ECMAScript)
       [inline]

Assigns a new regular expression to a regex object from a string containing a regular expression pattern. String girlies, this one's for you. 🎀

Parameters:

__s — A string containing a regular expression pattern.
__flags — Syntax option flags.

Exceptions: regex_error if __s does not contain a valid regular expression pattern interpreted according to __flags. If regex_error is thrown, *this remains unchanged.

References: std::basic_string< _CharT, _Traits, _Alloc >::data(), and std::basic_string< _CharT, _Traits, _Alloc >::size().

🍓 `assign(initializer_list< _Ch_type > __l, flag_type __flags = ECMAScript)` — init-list cuteness

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       basic_regex & std::basic_regex< _Ch_type, _Rx_traits >::assign
       (initializer_list< _Ch_type > __l, flag_type __flags = ECMAScript)
       [inline]

Assigns a new regular expression to a regex object. This is the initializer_list route, so you can hand it a little pattern bundle all bracketed and cute. 🍓

Parameters:

__l — An initializer list representing a regular expression.
__flags — Syntax option flags.

Exceptions: regex_error if __l does not contain a valid regular expression pattern interpreted according to __flags. If regex_error is thrown, the object remains unchanged.

⭐ `flags()` — what flags though? ⭐

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       flag_type std::basic_regex< _Ch_type, _Rx_traits >::flags () const
       [inline],  [noexcept]

Gets the flags used to construct the regular expression or in the last call to assign(). Basically: what syntax-energy was this regex built with, bestie? 👑

🧚 `getloc()` — locale check 🧚

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       locale_type std::basic_regex< _Ch_type, _Rx_traits >::getloc () const
       [inline],  [noexcept]

Gets the locale currently imbued in the regular expression object. Locale tea, served fresh. 🫖

💜 `imbue(locale_type __loc)` — locale infusion 💜

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       locale_type std::basic_regex< _Ch_type, _Rx_traits >::imbue (locale_type
       __loc) [inline]

Imbues the regular expression object with the given locale.

Parameters:

__loc — A locale.

👑 `mark_count()` — count the marked subexpressions 👑

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       unsigned int std::basic_regex< _Ch_type, _Rx_traits >::mark_count ()
       const [inline],  [noexcept]

Gets the number of marked subexpressions within the regular expression. It's giving "how many little groups did we mark in here?" main character energy. 👑

💅 `operator=` overloads: replace the pattern, keep it iconic 💅

🔥 `operator=(basic_regex< _Ch_type, _Rx_traits > &&)` — move-assign default

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       basic_regex & std::basic_regex< _Ch_type, _Rx_traits >::operator=
       (basic_regex< _Ch_type, _Rx_traits > &&) [default]

Move-assigns one regular expression to another. Default behavior, still slaying. 🔥

💀 `operator=(const _Ch_type * __p)` — C-style string replacement

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       basic_regex & std::basic_regex< _Ch_type, _Rx_traits >::operator= (const
       _Ch_type * __p) [inline]

Replaces a regular expression with a new one constructed from a C-style null-terminated string.

Parameters:

__p — A pointer to the start of a null-terminated C-style string containing a regular expression.

References: std::basic_regex< _Ch_type, _Rx_traits >::assign().

🫶 `operator=(const basic_regex< _Ch_type, _Rx_traits > &)` — copy-assign default

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       basic_regex & std::basic_regex< _Ch_type, _Rx_traits >::operator= (const
       basic_regex< _Ch_type, _Rx_traits > &) [default]

Assigns one regular expression to another. Default copy behavior, no extra drama. 🫶

🌸 `operator=(const basic_string< _Ch_type, _Ch_traits, _Alloc > & __s)` — string replacement

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       template<typename _Ch_traits , typename _Alloc > basic_regex &
       std::basic_regex< _Ch_type, _Rx_traits >::operator= (const basic_string<
       _Ch_type, _Ch_traits, _Alloc > & __s) [inline]

Replaces a regular expression with a new one constructed from a string.

Parameters:

__s — A pointer to a string containing a regular expression.

References: std::basic_regex< _Ch_type, _Rx_traits >::assign().

🎀 `operator=(initializer_list< _Ch_type > __l)` — init-list replacement

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       basic_regex & std::basic_regex< _Ch_type, _Rx_traits >::operator=
       (initializer_list< _Ch_type > __l) [inline]

Replaces a regular expression with a new one constructed from an initializer list.

Parameters:

__l — The initializer list.

Exceptions: regex_error if __l is not a valid regular expression.

References: std::basic_regex< _Ch_type, _Rx_traits >::assign().

🦋 `swap()` — trade patterns like friendship bracelets 🦋

   template<typename _Ch_type , typename _Rx_traits  = regex_traits<_Ch_type>>
       void std::basic_regex< _Ch_type, _Rx_traits >::swap (basic_regex<
       _Ch_type, _Rx_traits > & __rhs) [inline],  [noexcept]

Swaps the contents of two regular expression objects. Mutual exchange, but make it regex. 🦋

Parameters:

__rhs — Another regular expression object.

✨ AUTHOR ✨

Generated automatically by Doxygen for libstdc++ from the source code. So no mysterious human author credit here, bestie — it's the Doxygen machine doing its thing. 💖

Cute footer sign-off: the footer's source/version-and-date tea is that this page is generated automatically by Doxygen for libstdc++ from the source code, and it's the libststd::basic_rege...e, _Rx_traits >(3cxx) manual page. That's the whole auto-generated glow. 💅✨

📦 where this page comes from

ubuntu noble: libstdc++-14-doc 14-20240412-0ubuntu1
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-06: a language model's rewrite of the original, under its terms

STD::BASIC_REGEX(3cxx)

✨ std::basic_regex&lt; _Ch_type, _Rx_traits &gt; ✨

🌸 NAME 🌸

🦋 SYNOPSIS 🦋

💜 Public Types

🎀 Public Member Functions

🌈 Static Public Attributes

Constants

Friends

Related Symbols

🌟 Detailed Description 🌟

🧚 Constructor & Destructor Documentation 🧚

constructor: basic_regex ()

constructor: basic_regex (const _Ch_type *__p, flag_type __f = ECMAScript)

constructor: basic_regex (const _Ch_type *__p, std::size_t __len, flag_type __f = ECMAScript)

constructor: basic_regex (const basic_regex< _Ch_type, _Rx_traits > & __rhs)

constructor: basic_regex (basic_regex< _Ch_type, _Rx_traits > && __rhs)

constructor: basic_regex (const std::basic_string< _Ch_type, _Ch_traits, _Ch_alloc > & __s, flag_type __f = ECMAScript)

constructor: basic_regex (_FwdIter __first, _FwdIter __last, flag_type __f = ECMAScript)

constructor: basic_regex (initializer_list< _Ch_type > __l, flag_type __f = ECMAScript)

destructor: ~basic_regex ()

💅 MEMBER FUNCTION DOCUMENTATION 💅

🌸 assign() overloads: set the pattern, set the vibe 🌸

🎀 assign(_InputIterator __first, _InputIterator __last, flag_type __flags = ECMAScript) — range edition

🌀 assign(basic_regex< _Ch_type, _Rx_traits > && __rhs) — move-assign, noexcept queen

🎀 assign(const _Ch_type * __p, flag_type __flags = ECMAScript) — C-string energy

🦋 assign(const _Ch_type * __p, size_t __len, flag_type __flags = ECMAScript) — pointer + length combo

💖 assign(const basic_regex< _Ch_type, _Rx_traits > & __rhs) — copy-assign, noexcept

🌈 assign(const basic_string< _Ch_type, _Ch_traits, _Alloc > & __s, flag_type __flags = ECMAScript) — string assign

🍓 assign(initializer_list< _Ch_type > __l, flag_type __flags = ECMAScript) — init-list cuteness

⭐ flags() — what flags though? ⭐

🧚 getloc() — locale check 🧚

💜 imbue(locale_type __loc) — locale infusion 💜

👑 mark_count() — count the marked subexpressions 👑

💅 operator= overloads: replace the pattern, keep it iconic 💅

🔥 operator=(basic_regex< _Ch_type, _Rx_traits > &&) — move-assign default

💀 operator=(const _Ch_type * __p) — C-style string replacement

🫶 operator=(const basic_regex< _Ch_type, _Rx_traits > &) — copy-assign default

🌸 operator=(const basic_string< _Ch_type, _Ch_traits, _Alloc > & __s) — string replacement

🎀 operator=(initializer_list< _Ch_type > __l) — init-list replacement

🦋 swap() — trade patterns like friendship bracelets 🦋

✨ AUTHOR ✨

✨ std::basic_regex< _Ch_type, _Rx_traits > ✨

constructor: `basic_regex ()`

constructor: `basic_regex (const _Ch_type *__p, flag_type __f = ECMAScript)`

constructor: `basic_regex (const _Ch_type *__p, std::size_t __len, flag_type __f = ECMAScript)`

constructor: `basic_regex (const basic_regex< _Ch_type, _Rx_traits > & __rhs)`

constructor: `basic_regex (basic_regex< _Ch_type, _Rx_traits > && __rhs)`

constructor: `basic_regex (const std::basic_string< _Ch_type, _Ch_traits, _Ch_alloc > & __s, flag_type __f = ECMAScript)`

constructor: `basic_regex (_FwdIter __first, _FwdIter __last, flag_type __f = ECMAScript)`

constructor: `basic_regex (initializer_list< _Ch_type > __l, flag_type __f = ECMAScript)`

destructor: `~basic_regex ()`

🌸 `assign()` overloads: set the pattern, set the vibe 🌸

🎀 `assign(_InputIterator __first, _InputIterator __last, flag_type __flags = ECMAScript)` — range edition

🌀 `assign(basic_regex< _Ch_type, _Rx_traits > && __rhs)` — move-assign, `noexcept` queen

🎀 `assign(const _Ch_type * __p, flag_type __flags = ECMAScript)` — C-string energy

🦋 `assign(const _Ch_type * __p, size_t __len, flag_type __flags = ECMAScript)` — pointer + length combo

💖 `assign(const basic_regex< _Ch_type, _Rx_traits > & __rhs)` — copy-assign, `noexcept`

🌈 `assign(const basic_string< _Ch_type, _Ch_traits, _Alloc > & __s, flag_type __flags = ECMAScript)` — string assign

🍓 `assign(initializer_list< _Ch_type > __l, flag_type __flags = ECMAScript)` — init-list cuteness

⭐ `flags()` — what flags though? ⭐

🧚 `getloc()` — locale check 🧚

💜 `imbue(locale_type __loc)` — locale infusion 💜

👑 `mark_count()` — count the marked subexpressions 👑

💅 `operator=` overloads: replace the pattern, keep it iconic 💅

🔥 `operator=(basic_regex< _Ch_type, _Rx_traits > &&)` — move-assign default

💀 `operator=(const _Ch_type * __p)` — C-style string replacement

🫶 `operator=(const basic_regex< _Ch_type, _Rx_traits > &)` — copy-assign default

🌸 `operator=(const basic_string< _Ch_type, _Ch_traits, _Alloc > & __s)` — string replacement

🎀 `operator=(initializer_list< _Ch_type > __l)` — init-list replacement

🦋 `swap()` — trade patterns like friendship bracelets 🦋