#include #include namespace cs { namespace { constexpr std::size_t __DEFAULT_CAPACITY__ = 16; } // anonymous namespace template < typename Allocator > class allocator_wrapper : public Allocator { public: using value_type = typename Allocator::value_type; using size_type = typename Allocator::size_type; using difference_type = typename Allocator::difference_type; public: inline static size_type get() noexcept { return counter; } inline static void reset() noexcept { counter = 0; } auto allocate( size_type ) -> value_type*; private: inline static size_type counter = 0; }; template < typename Allocator > auto allocator_wrapper< Allocator >::allocate( size_type n ) -> value_type* { ++counter; return Allocator::allocate( n ); } template < typename CharT, typename Traits = std::char_traits< CharT >, typename Allocator = std::allocator< CharT > > class base_string { public: using value_type = CharT; using traits_type = Traits; using allocator_type = Allocator; using allocator_traits = std::allocator_traits< allocator_type >; using reference = value_type&; using const_reference = const value_type&; using pointer = typename allocator_traits::pointer; using const_pointer = typename allocator_traits::const_pointer; using size_type = typename allocator_traits::size_type; using difference_type = typename allocator_traits::difference_type; protected: base_string(); base_string( const allocator_type& ); virtual ~base_string(); void allocate( size_type = __DEFAULT_CAPACITY__ ); void reallocate(); void reallocate( size_type ); void deallocate(); public: inline bool empty() const noexcept { return ( this->m_size == 0 ); } inline size_type size() const noexcept { return this->m_size; } inline size_type length() const noexcept { return this->m_size; } inline size_type capacity() const noexcept { return this->m_capacity; } protected: pointer m_data; size_type m_size; size_type m_capacity; allocator_type m_allocator; }; template < typename CharT, typename Traits, typename Allocator > base_string< CharT, Traits, Allocator >::base_string() : m_data{ nullptr }, m_size{ 0 }, m_capacity{ __DEFAULT_CAPACITY__ }, m_allocator{ allocator_type{} } {} template < typename CharT, typename Traits, typename Allocator > base_string< CharT, Traits, Allocator >::base_string( const allocator_type& allocator ) : m_data{ nullptr }, m_size{ 0 }, m_capacity{ __DEFAULT_CAPACITY__ }, m_allocator{ allocator } {} template < typename CharT, typename Traits, typename Allocator > base_string< CharT, Traits, Allocator >::~base_string() { allocator_traits::deallocate( this->m_allocator, this->m_data, this->m_capacity ); } template < typename CharT, typename Traits, typename Allocator > void base_string< CharT, Traits, Allocator >::allocate( size_type capacity ) { capacity = ( __DEFAULT_CAPACITY__ < capacity ? capacity : __DEFAULT_CAPACITY__ ); this->m_data = allocator_traits::allocate( this->m_allocator, capacity ); this->m_size = 0; this->m_capacity = capacity; } template < typename CharT, typename Traits, typename Allocator > void base_string< CharT, Traits, Allocator >::reallocate() { this->m_capacity <<= 1; pointer __tmp__{ allocator_traits::allocate( this->m_allocator, this->m_capacity ) }; traits_type::move( __tmp__, this->m_data, this->m_size ); allocator_traits::deallocate( this->m_allocator, this->m_data, this->m_capacity ); this->m_data = __tmp__; } template < typename CharT, typename Traits, typename Allocator > void base_string< CharT, Traits, Allocator >::reallocate( size_type new_capacity ) { this->m_capacity = new_capacity; pointer __tmp__{ allocator_traits::allocate( this->m_allocator, this->m_capacity ) }; traits_type::move( __tmp__, this->m_data, this->m_size ); allocator_traits::deallocate( this->m_allocator, this->m_data, this->m_capacity ); this->m_data = __tmp__; } template < typename CharT, typename Traits, typename Allocator > void base_string< CharT, Traits, Allocator >::deallocate() { allocator_traits::deallocate( this->m_allocator, this->m_data, this->m_capacity ); this->m_data = nullptr; this->m_size = 0; this->m_capacity = 0; } template < typename CharT, typename Traits = std::char_traits< CharT >, typename Allocator = std::allocator< CharT > > class copy_string : public base_string< CharT, Traits, Allocator > { public: using value_type = typename base_string< CharT, Traits, Allocator >::value_type; using traits_type = typename base_string< CharT, Traits, Allocator >::traits_type; using allocator_type = typename base_string< CharT, Traits, Allocator >::allocator_type; using allocator_traits = typename base_string< CharT, Traits, Allocator >::allocator_traits; using reference = typename base_string< CharT, Traits, Allocator >::reference; using const_reference = typename base_string< CharT, Traits, Allocator >::const_reference; using pointer = typename base_string< CharT, Traits, Allocator >::pointer; using const_pointer = typename base_string< CharT, Traits, Allocator >::const_pointer; using size_type = typename base_string< CharT, Traits, Allocator >::size_type; using difference_type = typename base_string< CharT, Traits, Allocator >::difference_type; private: template < typename _CharT, typename _Traits, typename _Allocator > friend copy_string< _CharT, _Traits, _Allocator > operator + ( const copy_string< _CharT, _Traits, _Allocator >&, const copy_string< _CharT, _Traits, _Allocator >& ); template < typename _CharT, typename _Traits, typename _Allocator > friend copy_string< _CharT, _Traits, _Allocator > operator + ( const copy_string< _CharT, _Traits, _Allocator >&, typename copy_string< _CharT, _Traits, _Allocator >::const_pointer ); template < typename _CharT, typename _Traits, typename _Allocator > friend copy_string< _CharT, _Traits, _Allocator > operator + ( typename copy_string< _CharT, _Traits, _Allocator >::const_pointer, const copy_string< _CharT, _Traits, _Allocator >& ); template < typename _CharT, typename _Traits, typename _Allocator > friend std::ostream& operator << ( std::ostream&, const copy_string< _CharT, _Traits, _Allocator >& ); public: copy_string(); explicit copy_string( const allocator_type& ); copy_string( size_type, value_type, const allocator_type& = allocator_type() ); copy_string( const copy_string&, size_type, const allocator_type& = allocator_type() ); copy_string( const copy_string&, size_type, size_type, const allocator_type& = allocator_type() ); copy_string( const_pointer, const allocator_type& = allocator_type() ); copy_string( const_pointer, size_type, const allocator_type& = allocator_type() ); copy_string( const copy_string& ); copy_string( const copy_string&, const allocator_type& ); copy_string( copy_string&& ) = delete; copy_string( copy_string&&, const allocator_type& ) = delete; copy_string& operator = ( const_pointer ); copy_string& operator = ( const copy_string& ); copy_string& operator = ( copy_string&& ) = delete; }; template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >::copy_string() : base_string< CharT, Traits, Allocator >{} { this->allocate(); } template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >::copy_string( const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate(); } template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >::copy_string( size_type count, value_type value, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate( count ); traits_type::assign( this->m_data, count, value ); this->m_size = count; } template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >::copy_string( const copy_string< CharT, Traits, Allocator >& other, size_type position, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate( other.m_capacity ); traits_type::copy( this->m_data, other.m_data + position, other.m_size - position ); this->m_size = other.m_size - position; } template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >::copy_string( const copy_string< CharT, Traits, Allocator >& other, size_type position, size_type count, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate( count ); traits_type::copy( this->m_data, other.m_data + position, count ); this->m_size = count; } template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >::copy_string( const_pointer str, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { size_type new_size{ traits_type::length( str ) }; this->allocate( new_size ); traits_type::copy( this->m_data, str, new_size ); this->m_size = new_size; } template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >::copy_string( const_pointer str, size_type count, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate( count ); traits_type::copy( this->m_data, str, count ); this->m_size = count; } template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >::copy_string( const copy_string< CharT, Traits, Allocator >& other ) : base_string< CharT, Traits, Allocator >{ allocator_traits::select_on_container_copy_construction( other.m_allocator ) } { this->allocate( other.m_capacity ); traits_type::copy( this->m_data, other.m_data, other.m_size ); this->m_size = other.m_size; } template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >::copy_string( const copy_string< CharT, Traits, Allocator >& other, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate( other.m_capacity ); traits_type::copy( this->m_data, other.m_data, other.m_size ); this->m_size = other.m_size; } template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >& copy_string< CharT, Traits, Allocator >::operator = ( const_pointer str ) { size_type new_size{ traits_type::length( str ) }; if ( this->m_capacity < new_size ) { this->reallocate( new_size ); } traits_type::copy( this->m_data, str, new_size ); this->m_size = new_size; return *this; } template < typename CharT, typename Traits, typename Allocator > copy_string< CharT, Traits, Allocator >& copy_string< CharT, Traits, Allocator >::operator = ( const copy_string< CharT, Traits, Allocator >& other ) { if ( this != &other ) { if ( allocator_traits::propagate_on_container_copy_assignment::value ) { this->m_allocator = other.m_allocator; } if ( this->m_capacity < other.m_size ) { this->reallocate( other.m_capacity ); } traits_type::copy( this->m_data, other.m_data, other.m_size ); this->m_size = other.m_size; } return *this; } template < typename _CharT, typename _Traits, typename _Allocator > copy_string< _CharT, _Traits, _Allocator > operator + ( const copy_string< _CharT, _Traits, _Allocator >& left, const copy_string< _CharT, _Traits, _Allocator >& right ) { using string_type = copy_string< _CharT, _Traits, _Allocator >; string_type __tmp__{ left.m_size + right.m_size, 0 }; string_type::traits_type::copy( __tmp__.m_data, left.m_data, left.m_size ); string_type::traits_type::copy( __tmp__.m_data + left.m_size, right.m_data, right.m_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > copy_string< _CharT, _Traits, _Allocator > operator + ( const copy_string< _CharT, _Traits, _Allocator >& left, typename copy_string< _CharT, _Traits, _Allocator >::const_pointer right ) { using string_type = copy_string< _CharT, _Traits, _Allocator >; typename string_type::size_type right_size{ string_type::traits_type::length( right ) }; string_type __tmp__{ left.m_size + right_size, 0 }; string_type::traits_type::copy( __tmp__.m_data, left.m_data, left.m_size ); string_type::traits_type::copy( __tmp__.m_data + left.m_size, right, right_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > copy_string< _CharT, _Traits, _Allocator > operator + ( typename copy_string< _CharT, _Traits, _Allocator >::const_pointer left, const copy_string< _CharT, _Traits, _Allocator >& right ) { using string_type = copy_string< _CharT, _Traits, _Allocator >; typename string_type::size_type left_size{ string_type::traits_type::length( left ) }; string_type __tmp__{ left_size + right.m_size, 0 }; string_type::traits_type::copy( __tmp__.m_data, left, left_size ); string_type::traits_type::copy( __tmp__.m_data + left_size, right.m_data, right.m_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > std::ostream& operator << ( std::ostream& os, const copy_string< _CharT, _Traits, _Allocator >& str ) { for ( typename copy_string< _CharT, _Traits, _Allocator >::size_type i{ 0 }; i < str.m_size; ++i ) { os << str.m_data[ i ]; } return os; } template < typename CharT, typename Traits = std::char_traits< CharT >, typename Allocator = std::allocator< CharT > > class move_string : public base_string< CharT, Traits, Allocator > { public: using value_type = typename base_string< CharT, Traits, Allocator >::value_type; using traits_type = typename base_string< CharT, Traits, Allocator >::traits_type; using allocator_type = typename base_string< CharT, Traits, Allocator >::allocator_type; using allocator_traits = typename base_string< CharT, Traits, Allocator >::allocator_traits; using reference = typename base_string< CharT, Traits, Allocator >::reference; using const_reference = typename base_string< CharT, Traits, Allocator >::const_reference; using pointer = typename base_string< CharT, Traits, Allocator >::pointer; using const_pointer = typename base_string< CharT, Traits, Allocator >::const_pointer; using size_type = typename base_string< CharT, Traits, Allocator >::size_type; using difference_type = typename base_string< CharT, Traits, Allocator >::difference_type; private: template < typename _CharT, typename _Traits, typename _Allocator > friend move_string< _CharT, _Traits, _Allocator > operator + ( move_string< _CharT, _Traits, _Allocator >&, move_string< _CharT, _Traits, _Allocator >& ); template < typename _CharT, typename _Traits, typename _Allocator > friend move_string< _CharT, _Traits, _Allocator > operator + ( move_string< _CharT, _Traits, _Allocator >&, typename move_string< _CharT, _Traits, _Allocator >::const_pointer ); template < typename _CharT, typename _Traits, typename _Allocator > friend move_string< _CharT, _Traits, _Allocator > operator + ( typename move_string< _CharT, _Traits, _Allocator >::const_pointer, move_string< _CharT, _Traits, _Allocator >& ); template < typename _CharT, typename _Traits, typename _Allocator > friend move_string< _CharT, _Traits, _Allocator > operator + ( move_string< _CharT, _Traits, _Allocator >&&, move_string< _CharT, _Traits, _Allocator >&& ); template < typename _CharT, typename _Traits, typename _Allocator > friend move_string< _CharT, _Traits, _Allocator > operator + ( move_string< _CharT, _Traits, _Allocator >&&, move_string< _CharT, _Traits, _Allocator >& ); template < typename _CharT, typename _Traits, typename _Allocator > friend move_string< _CharT, _Traits, _Allocator > operator + ( move_string< _CharT, _Traits, _Allocator >&&, typename move_string< _CharT, _Traits, _Allocator >::const_pointer ); template < typename _CharT, typename _Traits, typename _Allocator > friend move_string< _CharT, _Traits, _Allocator > operator + ( const move_string< _CharT, _Traits, _Allocator >&, move_string< _CharT, _Traits, _Allocator >&& ); template < typename _CharT, typename _Traits, typename _Allocator > friend move_string< _CharT, _Traits, _Allocator > operator + ( typename move_string< _CharT, _Traits, _Allocator >::const_pointer, move_string< _CharT, _Traits, _Allocator >&& ); template < typename _CharT, typename _Traits, typename _Allocator > friend std::ostream& operator << ( std::ostream&, const move_string< _CharT, _Traits, _Allocator >& ); public: move_string(); explicit move_string( const allocator_type& ); move_string( size_type, value_type, const allocator_type& = allocator_type() ); move_string( const move_string&, size_type, const allocator_type& = allocator_type() ); move_string( const move_string&, size_type, size_type, const allocator_type& = allocator_type() ); move_string( const_pointer, const allocator_type& = allocator_type() ); move_string( const_pointer, size_type, const allocator_type& = allocator_type() ); move_string( const move_string& ); move_string( const move_string&, const allocator_type& ); move_string( move_string&& ); move_string( move_string&&, const allocator_type& ); move_string& operator = ( const_pointer ); move_string& operator = ( const move_string& ); move_string& operator = ( move_string&& ); }; template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string() : base_string< CharT, Traits, Allocator >{} { this->allocate(); } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string( const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate(); } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string( size_type count, value_type value, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate( count ); traits_type::assign( this->m_data, count, value ); this->m_size = count; } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string( const move_string< CharT, Traits, Allocator >& other, size_type position, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate( other.m_capacity ); traits_type::copy( this->m_data, other.m_data + position, other.m_size - position ); this->m_size = other.m_size - position; } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string( const move_string< CharT, Traits, Allocator >& other, size_type position, size_type count, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate( count ); traits_type::copy( this->m_data, other.m_data + position, count ); this->m_size = count; } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string( const_pointer str, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { size_type new_size{ traits_type::length( str ) }; this->allocate( new_size ); traits_type::copy( this->m_data, str, new_size ); this->m_size = new_size; } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string( const_pointer str, size_type count, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate( count ); traits_type::copy( this->m_data, str, count ); this->m_size = count; } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string( const move_string< CharT, Traits, Allocator >& other ) : base_string< CharT, Traits, Allocator >{ allocator_traits::select_on_container_copy_construction( other.m_allocator ) } { this->allocate( other.m_capacity ); traits_type::copy( this->m_data, other.m_data, other.m_size ); this->m_size = other.m_size; } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string( const move_string< CharT, Traits, Allocator >& other, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->allocate( other.m_capacity ); traits_type::copy( this->m_data, other.m_data, other.m_size ); this->m_size = other.m_size; } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string( move_string< CharT, Traits, Allocator >&& other ) : base_string< CharT, Traits, Allocator >{ std::exchange( other.m_allocator, allocator_type{} ) } { this->m_data = std::exchange( other.m_data, nullptr ); this->m_size = std::exchange( other.m_size, 0 ); this->m_capacity = std::exchange( other.m_capacity, 0 ); } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >::move_string( move_string< CharT, Traits, Allocator >&& other, const allocator_type& allocator ) : base_string< CharT, Traits, Allocator >{ allocator } { this->m_data = std::exchange( other.m_data, nullptr ); this->m_size = std::exchange( other.m_size, 0 ); this->m_capacity = std::exchange( other.m_capacity, 0 ); } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >& move_string< CharT, Traits, Allocator >::operator = ( const_pointer str ) { size_type new_size{ traits_type::length( str ) }; if ( this->m_capacity < new_size ) { this->reallocate( new_size ); } traits_type::copy( this->m_data, str, new_size ); this->m_size = new_size; return *this; } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >& move_string< CharT, Traits, Allocator >::operator = ( const move_string< CharT, Traits, Allocator >& other ) { if ( this != &other ) { if ( allocator_traits::propagate_on_container_copy_assignment::value ) { this->m_allocator = other.m_allocator; } if ( this->m_capacity < other.m_size ) { this->reallocate( other.m_capacity ); } traits_type::copy( this->m_data, other.m_data, other.m_size ); this->m_size = other.m_size; } return *this; } template < typename CharT, typename Traits, typename Allocator > move_string< CharT, Traits, Allocator >& move_string< CharT, Traits, Allocator >::operator = ( move_string< CharT, Traits, Allocator >&& other ) { if ( this != &other ) { if ( allocator_traits::propagate_on_container_move_assignment::value || this->m_allocator == other.m_allocator ) { this->m_allocator = other.m_allocator; this->m_data = std::exchange( other.m_data, nullptr ); this->m_size = std::exchange( other.m_size, 0 ); this->m_capacity = std::exchange( other.m_capacity, 0 ); } else { if ( this->m_capacity < other.m_size ) { this->reallocate( other.m_capacity ); } traits_type::move( this->m_data, other.m_data, other.m_size ); this->m_size = other.m_size; other.m_data = nullptr; } } return *this; } template < typename _CharT, typename _Traits, typename _Allocator > move_string< _CharT, _Traits, _Allocator > operator + ( move_string< _CharT, _Traits, _Allocator >& left, move_string< _CharT, _Traits, _Allocator >& right ) { using string_type = move_string< _CharT, _Traits, _Allocator >; string_type __tmp__{ left.m_size + right.m_size, 0 }; string_type::traits_type::copy( __tmp__.m_data, left.m_data, left.m_size ); string_type::traits_type::copy( __tmp__.m_data + left.m_size, right.m_data, right.m_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > move_string< _CharT, _Traits, _Allocator > operator + ( move_string< _CharT, _Traits, _Allocator >& left, typename move_string< _CharT, _Traits, _Allocator >::const_pointer right ) { using string_type = move_string< _CharT, _Traits, _Allocator >; typename string_type::size_type right_size{ string_type::traits_type::length( right ) }; string_type __tmp__{ left.m_size + right_size, 0 }; string_type::traits_type::copy( __tmp__.m_data, left.m_data, left.m_size ); string_type::traits_type::copy( __tmp__.m_data + left.m_size, right, right_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > move_string< _CharT, _Traits, _Allocator > operator + ( typename move_string< _CharT, _Traits, _Allocator >::const_pointer left, move_string< _CharT, _Traits, _Allocator >& right ) { using string_type = move_string< _CharT, _Traits, _Allocator >; typename string_type::size_type left_size{ string_type::traits_type::length( left ) }; string_type __tmp__{ left_size + right.m_size, 0 }; string_type::traits_type::copy( __tmp__.m_data, left, left_size ); string_type::traits_type::copy( __tmp__.m_data + left_size, right.m_data, right.m_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > move_string< _CharT, _Traits, _Allocator > operator + ( move_string< _CharT, _Traits, _Allocator >&& left, move_string< _CharT, _Traits, _Allocator >&& right ) { using string_type = move_string< _CharT, _Traits, _Allocator >; if ( !( left.m_capacity < left.m_size + right.m_size ) ) { string_type __tmp__{ std::move( left ) }; string_type::traits_type::move( __tmp__.m_data + __tmp__.m_size, right.m_data, right.m_size ); __tmp__.m_size += right.m_size; return __tmp__; } else if ( !( right.m_capacity < left.m_size + right.m_size ) ) { string_type __tmp__{ std::move( right ) }; string_type::traits_type::move( __tmp__.m_data + left.m_size, __tmp__.m_data, __tmp__.m_size ); string_type::traits_type::move( __tmp__.m_data, left.m_data, left.m_size ); __tmp__.m_size += left.m_size; return __tmp__; } string_type __tmp__{ left.m_size + right.m_size, 0 }; string_type::traits_type::move( __tmp__.m_data, left.m_data, left.m_size ); string_type::traits_type::move( __tmp__.m_data + left.m_size, right.m_data, right.m_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > move_string< _CharT, _Traits, _Allocator > operator + ( move_string< _CharT, _Traits, _Allocator >&& left, move_string< _CharT, _Traits, _Allocator >& right ) { using string_type = move_string< _CharT, _Traits, _Allocator >; if ( !( left.m_capacity < left.m_size + right.m_size ) ) { string_type __tmp__{ std::move( left ) }; string_type::traits_type::copy( __tmp__.m_data + __tmp__.m_size, right.m_data, right.m_size ); __tmp__.m_size += right.m_size; return __tmp__; } string_type __tmp__{ left.m_size + right.m_size, 0 }; string_type::traits_type::move( __tmp__.m_data, left.m_data, left.m_size ); string_type::traits_type::copy( __tmp__.m_data + left.m_size, right.m_data, right.m_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > move_string< _CharT, _Traits, _Allocator > operator + ( move_string< _CharT, _Traits, _Allocator >&& left, typename move_string< _CharT, _Traits, _Allocator >::const_pointer right ) { using string_type = move_string< _CharT, _Traits, _Allocator >; typename string_type::size_type right_size{ string_type::traits_type::length( right ) }; if ( !( left.m_capacity < left.m_size + right_size ) ) { string_type __tmp__{ std::move( left ) }; string_type::traits_type::copy( __tmp__.m_data + __tmp__.m_size, right, right_size ); __tmp__.m_size += right_size; return __tmp__; } string_type __tmp__{ left.m_size + right_size, 0 }; string_type::traits_type::move( __tmp__.m_data, left.m_data, left.m_size ); string_type::traits_type::copy( __tmp__.m_data + left.m_size, right, right_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > move_string< _CharT, _Traits, _Allocator > operator + ( const move_string< _CharT, _Traits, _Allocator >& left, move_string< _CharT, _Traits, _Allocator >&& right ) { using string_type = move_string< _CharT, _Traits, _Allocator >; if ( !( right.m_capacity < left.m_size + right.m_size ) ) { string_type __tmp__{ std::move( right ) }; string_type::traits_type::move( __tmp__.m_data + left.m_size, __tmp__.m_data, __tmp__.m_size ); string_type::traits_type::copy( __tmp__.m_data, left.m_data, left.m_size ); __tmp__.m_size += left.m_size; return __tmp__; } string_type __tmp__{ left.m_size + right.m_size, 0 }; string_type::traits_type::copy( __tmp__.m_data, left.m_data, left.m_size ); string_type::traits_type::move( __tmp__.m_data + left.m_size, right.m_data, right.m_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > move_string< _CharT, _Traits, _Allocator > operator + ( typename move_string< _CharT, _Traits, _Allocator >::const_pointer left, move_string< _CharT, _Traits, _Allocator >&& right ) { using string_type = move_string< _CharT, _Traits, _Allocator >; typename string_type::size_type left_size{ string_type::traits_type::length( left ) }; if ( !( right.m_capacity < left_size + right.m_size ) ) { string_type __tmp__{ std::move( right ) }; string_type::traits_type::move( __tmp__.m_data + left_size, __tmp__.m_data, __tmp__.m_size ); string_type::traits_type::copy( __tmp__.m_data, left, left_size ); __tmp__.m_size += left_size; return __tmp__; } string_type __tmp__{ left_size + right.m_size, 0 }; string_type::traits_type::copy( __tmp__.m_data, left, left_size ); string_type::traits_type::move( __tmp__.m_data + left_size, right.m_data, right.m_size ); return __tmp__; } template < typename _CharT, typename _Traits, typename _Allocator > std::ostream& operator << ( std::ostream& os, const move_string< _CharT, _Traits, _Allocator >& str ) { for ( typename move_string< _CharT, _Traits, _Allocator >::size_type i{ 0 }; i < str.m_size; ++i ) { os << str.m_data[ i ]; } return os; } } // namespace cs cs::copy_string< char, std::char_traits< char >, cs::allocator_wrapper< std::allocator< char > > > operator "" _cs( const char* str, std::size_t len ) { return cs::copy_string< char, std::char_traits< char >, cs::allocator_wrapper< std::allocator< char > > >( str, len ); } cs::move_string< char, std::char_traits< char >, cs::allocator_wrapper< std::allocator< char > > > operator "" _ms( const char* str, std::size_t len ) { return cs::move_string< char, std::char_traits< char >, cs::allocator_wrapper< std::allocator< char > > >( str, len ); } int main( int argc, char** argv ) { using string_allocator = cs::allocator_wrapper< std::allocator< char > >; using cpstring = cs::copy_string< char, std::char_traits< char >, string_allocator >; using mvstring = cs::move_string< char, std::char_traits< char >, string_allocator >; std::cout << "Program with copy_string:\n\n"; std::cout << "cpstring a1{ \"One\"_cs };\n" << "cpstring b1{ \"Two\"_cs };\n" << "cpstring c1{ \"Three\"_cs };\n" << "cpstring d1{ a1 + \"Four\"_cs + b1 + \"Four\"_cs + c1 };\n" << "cpstring e1{ d1 + \"FiveFive\"_cs + d1 };\n" << "cpstring f1{ \"Six\"_cs + \"Six\"_cs + e1 + \"Six\"_cs + \"Six\"_cs };\n" << "cpstring g1{ \"Seven\" + \"Seven\"_cs };\n" << "cpstring h1{ \"Eight\"_cs + \"Eight\" };\n" << "cpstring i1{ \"Nine\" + g1 + \"Nine\"_cs + h1 + \"Nine\" };\n\n"; cpstring a1{ "One"_cs }; cpstring b1{ "Two"_cs }; cpstring c1{ "Three"_cs }; cpstring d1{ a1 + "Four"_cs + b1 + "Four"_cs + c1 }; cpstring e1{ d1 + "FiveFive"_cs + d1 }; cpstring f1{ "Six"_cs + "Six"_cs + e1 + "Six"_cs + "Six"_cs }; cpstring g1{ "Seven" + "Seven"_cs }; cpstring h1{ "Eight"_cs + "Eight" }; cpstring i1{ "Nine" + g1 + "Nine"_cs + h1 + "Nine" }; std::cout << "Number of allocations: " << string_allocator::get() << std::endl; string_allocator::reset(); std::cout << "\nProgram with move_string:\n\n"; std::cout << "mvstring a2{ \"One\"_ms };\n" << "mvstring b2{ \"Two\"_ms };\n" << "mvstring c2{ \"Three\"_ms };\n" << "mvstring d2{ a2 + \"Four\"_ms + b2 + \"Four\"_ms + c2 };\n" << "mvstring e2{ d2 + \"FiveFive\"_ms + d2 };\n" << "mvstring f2{ \"Six\"_ms + \"Six\"_ms + e2 + \"Six\"_ms + \"Six\"_ms };\n" << "mvstring g2{ \"Seven\" + \"Seven\"_ms };\n" << "mvstring h2{ \"Eight\"_ms + \"Eight\" };\n" << "mvstring i2{ \"Nine\" + g2 + \"Nine\"_ms + h2 + \"Nine\" };\n\n"; mvstring a2{ "One"_ms }; mvstring b2{ "Two"_ms }; mvstring c2{ "Three"_ms }; mvstring d2{ a2 + "Four"_ms + b2 + "Four"_ms + c2 }; mvstring e2{ d2 + "FiveFive"_ms + d2 }; mvstring f2{ "Six"_ms + "Six"_ms + e2 + "Six"_ms + "Six"_ms }; mvstring g2{ "Seven" + "Seven"_ms }; mvstring h2{ "Eight"_ms + "Eight" }; mvstring i2{ "Nine" + g2 + "Nine"_ms + h2 + "Nine" }; std::cout << "Number of allocations: " << string_allocator::get() << std::endl; string_allocator::reset(); return EXIT_SUCCESS; }

Performance by Moving