libstdc++: __gnu_cxx::__rc_string_base< _CharT, _Traits, _Alloc (original) (raw)

#include <[rc_string_base.h](a01214%5Fsource.html)>

Inherits __gnu_cxx::__vstring_utility< _CharT, _Traits, _Alloc >.

Public Types
typedef _Util_Base::_CharT_alloc_type	_CharT_alloc_type

typedef __vstring_utility< _CharT, _Traits, _Alloc >	_Util_Base

typedef _Alloc	allocator_type

typedef _CharT_alloc_type::size_type	size_type

typedef _Traits	traits_type

typedef _Traits::char_type	value_type

Public Member Functions
	__rc_string_base (__rc_string_base &&__rcs)

template<typename _InputIterator >
	__rc_string_base (_InputIterator __beg, _InputIterator __end, const _Alloc &__a)

	__rc_string_base (const __rc_string_base &__rcs)

	__rc_string_base (const _Alloc &__a)

	__rc_string_base (size_type __n, _CharT __c, const _Alloc &__a)

void	_M_assign (const __rc_string_base &__rcs)

size_type	_M_capacity () const

void	_M_clear ()

bool	_M_compare (const __rc_string_base &) const

bool	_M_compare (const __rc_string_base &__rcs) const

bool	_M_compare (const __rc_string_base &__rcs) const

_CharT *	_M_data () const

void	_M_erase (size_type __pos, size_type __n)

allocator_type &	_M_get_allocator ()

const allocator_type &	_M_get_allocator () const

bool	_M_is_shared () const

void	_M_leak ()

size_type	_M_length () const

size_type	_M_max_size () const

void	_M_mutate (size_type __pos, size_type __len1, const _CharT *__s, size_type __len2)

void	_M_reserve (size_type __res)

void	_M_set_leaked ()

void	_M_set_length (size_type __n)

void	_M_swap (__rc_string_base &__rcs)

template<typename _InIterator >
_CharT *	_S_construct (_InIterator __beg, _InIterator __end, const _Alloc &__a, std::forward_iterator_tag)

Protected Types
typedef __gnu_cxx::__normal_iterator< const_pointer, __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, __rc_string_base > >	__const_rc_iterator

typedef __gnu_cxx::__normal_iterator< const_pointer, __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, __sso_string_base > >	__const_sso_iterator

typedef __gnu_cxx::__normal_iterator< pointer, __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, __rc_string_base > >	__rc_iterator

typedef __gnu_cxx::__normal_iterator< pointer, __gnu_cxx::__versa_string< _CharT, _Traits, _Alloc, __sso_string_base > >	__sso_iterator

typedef __alloc_traits< _CharT_alloc_type >	_CharT_alloc_traits

typedef _CharT_alloc_traits::const_pointer	const_pointer

typedef _CharT_alloc_type::difference_type	difference_type

typedef _CharT_alloc_traits::pointer	pointer

Static Protected Member Functions
static void	_S_assign (_CharT *__d, size_type __n, _CharT __c)

static int	_S_compare (size_type __n1, size_type __n2)

static void	_S_copy (_CharT __d, const _CharT __s, size_type __n)

static void	_S_copy_chars (_CharT *__p, __const_rc_iterator __k1, __const_rc_iterator __k2)

static void	_S_copy_chars (_CharT *__p, __const_sso_iterator __k1, __const_sso_iterator __k2)

static void	_S_copy_chars (_CharT *__p, __rc_iterator __k1, __rc_iterator __k2)

static void	_S_copy_chars (_CharT *__p, __sso_iterator __k1, __sso_iterator __k2)

static void	_S_copy_chars (_CharT __p, _CharT __k1, _CharT *__k2)

template<typename _Iterator >
static void	_S_copy_chars (_CharT *__p, _Iterator __k1, _Iterator __k2)

static void	_S_copy_chars (_CharT __p, const _CharT __k1, const _CharT *__k2)

static void	_S_move (_CharT __d, const _CharT __s, size_type __n)

template<typename _CharT, typename _Traits, typename _Alloc>
class __gnu_cxx::__rc_string_base< _CharT, _Traits, _Alloc >

Documentation? What's that? Nathan Myers ncm@c.nosp@m.antr.nosp@m.ip.or.nosp@m.g.

A string looks like this:

[_Rep]

_M_length

_M_dataplus _M_refcount

_M_p ----------------> unnamed array of char_type

Where the _M_p points to the first character in the string, and you cast it to a pointer-to-_Rep and subtract 1 to get a pointer to the header.

This approach has the enormous advantage that a string object requires only one allocation. All the ugliness is confined within a single pair of inline functions, which each compile to a single add instruction: _Rep::_M_refdata(), and __rc_string_base::_M_rep(); and the allocation function which gets a block of raw bytes and with room enough and constructs a _Rep object at the front.

The reason you want _M_data pointing to the character array and not the _Rep is so that the debugger can see the string contents. (Probably we should add a non-inline member to get the _Rep for the debugger to use, so users can check the actual string length.)

Note that the _Rep object is a POD so that you can have a static empty string _Rep object already constructed before static constructors have run. The reference-count encoding is chosen so that a 0 indicates one reference, so you never try to destroy the empty-string _Rep object.

All but the last paragraph is considered pretty conventional for a C++ string implementation.

Definition at line 85 of file rc_string_base.h.