std::basic_string< E, TAllocator, TStorage > Template-Klassenreferenz

#include <basic_string.hpp>

Klassendiagramm für std::basic_string< E, TAllocator, TStorage >:

Zusammengehörigkeiten von std::basic_string< E, TAllocator, TStorage >:

Öffentliche Typen
using	value_type = typename TStorage::value_type
using	size_type = typename TStorage::size_type
using	const_iterator = typename TStorage::const_iterator
using	allocator_type = typename TStorage::allocator_type
using	self_type = basic_string< E, TAllocator, TStorage >

Öffentliche Methoden
	basic_string (const allocator_type &allocator=allocator_type())
	basic_string (const value_type *str, const allocator_type &allocator=allocator_type())
	basic_string (size_type len, const allocator_type &allocator=allocator_type())
	basic_string (const value_type *str, size_type len, const allocator_type &allocator=allocator_type())
	basic_string (const basic_string &str, const allocator_type &allocator=allocator_type())
	~basic_string ()
size_type	capacity () const
basic_string &	operator<< (const value_type *str)
basic_string &	operator<< (const value_type ch)
basic_string &	operator<< (const basic_string &str)
value_type	operator[] (size_type i) const
basic_string &	operator= (const basic_string &rhs)
basic_string &	operator= (const value_type *str)
basic_string &	assign (const value_type *str, size_type len)
basic_string &	assign (const value_type *str)
basic_string	substr (size_type begin, size_type end) const
basic_string	substr (size_type begin) const
void	append (const value_type *str, size_type len)
void	append (const basic_string &str)
void	append (const value_type *str)
void	append (const value_type ch)
basic_string &	operator+= (const basic_string &rhs)
int	compare (const value_type *str) const
int	compare (const basic_string &rhs) const
const value_type *	c_str () const
const_iterator	begin () const
const_iterator	end () const
size_type	length () const
value_type *	data ()
bool	empty () const
const allocator_type &	get_allocator () const
value_type *	reserve (size_type capacity_hint)
void	clear ()
void	resize (size_type size)
void	make_lower ()
void	make_upper ()
size_type	find_index_of (const value_type ch) const
size_type	find_index_of_last (const value_type ch) const
size_type	find (const value_type *needle) const
size_type	rfind (const value_type *needle) const

Statische öffentliche Attribute
static const size_type	npos = size_type(-1)

Ausführliche Beschreibung

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
class std::basic_string< E, TAllocator, TStorage >

Dokumentation der benutzerdefinierten Datentypen

allocator_type

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

using std::basic_string< E, TAllocator, TStorage >::allocator_type = typename TStorage::allocator_type

const_iterator

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

using std::basic_string< E, TAllocator, TStorage >::const_iterator = typename TStorage::const_iterator

self_type

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

using std::basic_string< E, TAllocator, TStorage >::self_type = basic_string<E, TAllocator, TStorage >

size_type

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

using std::basic_string< E, TAllocator, TStorage >::size_type = typename TStorage::size_type

value_type

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

using std::basic_string< E, TAllocator, TStorage >::value_type = typename TStorage::value_type

Beschreibung der Konstruktoren und Destruktoren

basic_string() [1/5]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

std::basic_string< E, TAllocator, TStorage >::basic_string ( const allocator_type &  allocator = allocator_type() )

inlineexplicit

            : TStorage(allocator)
        {
                
        }

basic_string() [2/5]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

std::basic_string< E, TAllocator, TStorage >::basic_string ( const value_type *  str, const allocator_type &  allocator = allocator_type()  )

inlineexplicit

            : TStorage(str, allocator)
        {
                
        }

basic_string() [3/5]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

std::basic_string< E, TAllocator, TStorage >::basic_string ( size_type  len, const allocator_type &  allocator = allocator_type()  )

inline

            : TStorage(len, allocator)
        {
                
        }

basic_string() [4/5]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

std::basic_string< E, TAllocator, TStorage >::basic_string ( const value_type *  str, size_type  len, const allocator_type &  allocator = allocator_type()  )

inline

            : TStorage(str, len, allocator)
        {
                
        }

basic_string() [5/5]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

std::basic_string< E, TAllocator, TStorage >::basic_string ( const basic_string< E, TAllocator, TStorage > &  str, const allocator_type &  allocator = allocator_type()  )

inline

            : TStorage(str, allocator)
        {
                
        }

~basic_string()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

std::basic_string< E, TAllocator, TStorage >::~basic_string ( )

inline

        {
                
        }

Dokumentation der Elementfunktionen

append() [1/4]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

void std::basic_string< E, TAllocator, TStorage >::append ( const value_type *  str, size_type  len  )

inline

        {
            if( !str || len == 0 || *str == 0 )
                            return;
            TStorage::append(str, len);
        }

append() [2/4]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

void std::basic_string< E, TAllocator, TStorage >::append ( const basic_string< E, TAllocator, TStorage > &  str )

inline

        {
            append(str.c_str(), str.length());
        }

append() [3/4]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

void std::basic_string< E, TAllocator, TStorage >::append ( const value_type *  str )

inline

        {
            append(str, strlen(str));
        }

append() [4/4]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

void std::basic_string< E, TAllocator, TStorage >::append ( const value_type  ch )

inline

        {
            append(&ch, 1);
        }

assign() [1/2]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string& std::basic_string< E, TAllocator, TStorage >::assign ( const value_type *  str, size_type  len  )

inline

        {
                    TStorage::assign(str, len);
                    assert(invariant());
                    return *this;
        }

assign() [2/2]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string& std::basic_string< E, TAllocator, TStorage >::assign ( const value_type *  str )

inline

        {
                    return assign(str, strlen(str));
        }

begin()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

const_iterator std::basic_string< E, TAllocator, TStorage >::begin ( ) const

inline

        { 
            assert(invariant()); return c_str(); 
        }

c_str()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

const value_type* std::basic_string< E, TAllocator, TStorage >::c_str ( ) const

inline

        {
                    assert(invariant());
                    return TStorage::c_str();
        }

capacity()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

size_type std::basic_string< E, TAllocator, TStorage >::capacity ( ) const

inline

        { 
            return TStorage::capacity(); 
        }

clear()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

void std::basic_string< E, TAllocator, TStorage >::clear ( )

inline

        {
                TStorage::clear();
        }

compare() [1/2]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

int std::basic_string< E, TAllocator, TStorage >::compare ( const value_type *  str ) const

inline

        {
                    const size_type thisLen = length();
                    const size_type strLen = strlen(str);
                    if (thisLen < strLen)
                    return -1;
                    if (thisLen > strLen)
                    return 1;

                    return strcompare(c_str(), str, thisLen);
        }

compare() [2/2]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

int std::basic_string< E, TAllocator, TStorage >::compare ( const basic_string< E, TAllocator, TStorage > &  rhs ) const

inline

        {
                    const size_type thisLen = length();
                    const size_type rhsLen = rhs.length();
                    if (thisLen < rhsLen)
                            return -1;
                    if (thisLen > rhsLen)
                            return 1;

                    return strcompare(c_str(), rhs.c_str(), thisLen);
        }

data()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

value_type* std::basic_string< E, TAllocator, TStorage >::data ( )

inline

                {
                    return TStorage::get_data();
                }

empty()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

bool std::basic_string< E, TAllocator, TStorage >::empty ( ) const

inline

        { 
            return length() == 0; 
        }

end()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

const_iterator std::basic_string< E, TAllocator, TStorage >::end ( ) const

inline

        { 
            assert(invariant()); return c_str() + length(); 
        }

find()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

size_type std::basic_string< E, TAllocator, TStorage >::find ( const value_type *  needle ) const

inline

        {       
            const value_type* s(c_str());    
            size_type si(0);
            while(*s)
            {
                const value_type* n = needle;
                if( *s == *n ) //first character matches
                {
                    const value_type* x = s; 
                    size_type match = 0;
                    while(*x && *n) 
                    {
                        if( *n == *x )
                            ++match;
                        ++n;
                        ++x;
                    }
                    if( match == strlen(needle) )
                        return si;
                }
                ++s;
                ++si;
            }
            return basic_string::npos;
        }

find_index_of()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

size_type std::basic_string< E, TAllocator, TStorage >::find_index_of ( const value_type  ch ) const

inline

        {
            size_type retIndex(basic_string::npos);
                    const E* ptr = c_str();
                    size_type currentIndex(0);
                    while (*ptr != value_type(0))
                    {
                            if (*ptr == ch)
                            {
                                    retIndex = currentIndex;
                                    break;
                            }
                            ++ptr;
                            ++currentIndex;
                    }
                    return retIndex;
        }

find_index_of_last()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

size_type std::basic_string< E, TAllocator, TStorage >::find_index_of_last ( const value_type  ch ) const

inline

        {
                    size_type retIndex(basic_string::npos);
                    const value_type* ptr = c_str();
                    size_type currentIndex(0);
                    while (*ptr != value_type(0))
                    {
                            if (*ptr == ch)
                                    retIndex = currentIndex;
                            ++ptr;
                            ++currentIndex;
                    }
                    return retIndex;
        }

get_allocator()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

const allocator_type& std::basic_string< E, TAllocator, TStorage >::get_allocator ( ) const

inline

        { 
            return TStorage::get_allocator; 
        }

length()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

size_type std::basic_string< E, TAllocator, TStorage >::length ( ) const

inline

        {
                return TStorage::length();
        }

make_lower()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

void std::basic_string< E, TAllocator, TStorage >::make_lower ( )

inline

        {
                    const size_type len = length();
                    TStorage::make_unique(len);
                    static const int chDelta = 'a' - 'A';
                    E* data = TStorage::get_data();
                    for (size_type i = 0; i < len; ++i)
                    {
                            if (data[i] < 'a')
                                    data[i] += chDelta;             
                    }
        }

make_upper()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

void std::basic_string< E, TAllocator, TStorage >::make_upper ( )

inline

        {
                    const size_type len = length();
                    TStorage::make_unique(len);
                    static const int chDelta = 'a' - 'A';
                    E* data = TStorage::get_data();
                    for (size_type i = 0; i < len; ++i)
                    {
                            if (data[i] > 'Z')
                                    data[i] -= chDelta;
                    }
        }

operator+=()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string& std::basic_string< E, TAllocator, TStorage >::operator+= ( const basic_string< E, TAllocator, TStorage > &  rhs )

inline

        {
                    append(rhs);
                    return *this;
        }

operator<<() [1/3]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string& std::basic_string< E, TAllocator, TStorage >::operator<< ( const value_type *  str )

inline

        {
            append(str, strlen(str));
            return *this;
        }

operator<<() [2/3]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string& std::basic_string< E, TAllocator, TStorage >::operator<< ( const value_type  ch )

inline

        {
            append(&ch, 1);
            return *this;
        }

operator<<() [3/3]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string& std::basic_string< E, TAllocator, TStorage >::operator<< ( const basic_string< E, TAllocator, TStorage > &  str )

inline

        {
            append(str.c_str(), str.length());
            return *this;
        }

operator=() [1/2]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string& std::basic_string< E, TAllocator, TStorage >::operator= ( const basic_string< E, TAllocator, TStorage > &  rhs )

inline

        {
                    assert(rhs.invariant());
                    if (this != &rhs) 
                    {
                            TStorage::operator=((TStorage&)rhs);
                    }
                    assert(invariant());
                    return *this;
        }

operator=() [2/2]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string& std::basic_string< E, TAllocator, TStorage >::operator= ( const value_type *  str )

inline

        {
                    return assign(str);
        }

operator[]()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

value_type std::basic_string< E, TAllocator, TStorage >::operator[] ( size_type  i ) const

inline

        {
                    assert(i < length());
                    assert(invariant());
                    return c_str()[i];
        }

reserve()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

value_type* std::basic_string< E, TAllocator, TStorage >::reserve ( size_type  capacity_hint )

inline

        {
                return TStorage::reserve(capacity_hint);
        }

resize()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

void std::basic_string< E, TAllocator, TStorage >::resize ( size_type  size )

inline

        {
                TStorage::resize(size);
        }

rfind()

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

size_type std::basic_string< E, TAllocator, TStorage >::rfind ( const value_type *  needle ) const

inline

        {   
                    const value_type* s(c_str() + length());
                    size_type si(length()+1); 

                    while(--si >= 0) 
                    {
                            if( *s-- == *needle ) 
                            {
                                    const value_type* x = c_str() + si; 
                                    const value_type* n = needle;
                                    size_type match = 0;
                                    while(*x && *n) 
                                    {
                                            if( *n == *x )
                                                    ++match;
                                            ++n;
                                            ++x;
                                    }
                                    if( match == strlen(needle) )
                                            return si;
                            }
                    }
                    return basic_string::npos;
        }

substr() [1/2]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string std::basic_string< E, TAllocator, TStorage >::substr ( size_type  begin, size_type  end  ) const

inline

        {
                    assert(end >= begin && end <= length() && begin >= 0);
                    return basic_string(c_str() + begin, end - begin);
        }

substr() [2/2]

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string std::basic_string< E, TAllocator, TStorage >::substr ( size_type  begin ) const

inline

        {
            return substr(begin, length());
        }

Dokumentation der Datenelemente

npos

template<typename E, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

const size_type std::basic_string< E, TAllocator, TStorage >::npos = size_type(-1)

static

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/basic_string.hpp