STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Macros | Functions
basic_string.tcc File Reference
#include <bits/cxxabi_forced.h>

Macros

#define _BASIC_STRING_TCC   1
 

Functions

namespace std _GLIBCXX_VISIBILITY (default)
 

Detailed Description

This is an internal header file, included by other library headers. Do not attempt to use it directly. {string}

Macro Definition Documentation

#define _BASIC_STRING_TCC   1

Function Documentation

namespace std _GLIBCXX_VISIBILITY ( default  )
45 {
46 _GLIBCXX_BEGIN_NAMESPACE_VERSION
47 
48  template<typename _CharT, typename _Traits, typename _Alloc>
49  const typename basic_string<_CharT, _Traits, _Alloc>::size_type
50  basic_string<_CharT, _Traits, _Alloc>::
51  _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
52 
53  template<typename _CharT, typename _Traits, typename _Alloc>
54  const _CharT
55  basic_string<_CharT, _Traits, _Alloc>::
56  _Rep::_S_terminal = _CharT();
57 
58  template<typename _CharT, typename _Traits, typename _Alloc>
59  const typename basic_string<_CharT, _Traits, _Alloc>::size_type
60  basic_string<_CharT, _Traits, _Alloc>::npos;
61 
62  // Linker sets _S_empty_rep_storage to all 0s (one reference, empty string)
63  // at static init time (before static ctors are run).
64  template<typename _CharT, typename _Traits, typename _Alloc>
65  typename basic_string<_CharT, _Traits, _Alloc>::size_type
66  basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
67  (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
68  sizeof(size_type)];
69 
70  // NB: This is the special case for Input Iterators, used in
71  // istreambuf_iterators, etc.
72  // Input Iterators have a cost structure very different from
73  // pointers, calling for a different coding style.
74  template<typename _CharT, typename _Traits, typename _Alloc>
75  template<typename _InIterator>
76  _CharT*
77  basic_string<_CharT, _Traits, _Alloc>::
78  _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
79  input_iterator_tag)
80  {
81 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
82  if (__beg == __end && __a == _Alloc())
83  return _S_empty_rep()._M_refdata();
84 #endif
85  // Avoid reallocation for common case.
86  _CharT __buf[128];
87  size_type __len = 0;
88  while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
89  {
90  __buf[__len++] = *__beg;
91  ++__beg;
92  }
93  _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
94  _M_copy(__r->_M_refdata(), __buf, __len);
95  __try
96  {
97  while (__beg != __end)
98  {
99  if (__len == __r->_M_capacity)
100  {
101  // Allocate more space.
102  _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
103  _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
104  __r->_M_destroy(__a);
105  __r = __another;
106  }
107  __r->_M_refdata()[__len++] = *__beg;
108  ++__beg;
109  }
110  }
111  __catch(...)
112  {
113  __r->_M_destroy(__a);
114  __throw_exception_again;
115  }
116  __r->_M_set_length_and_sharable(__len);
117  return __r->_M_refdata();
118  }
119 
120  template<typename _CharT, typename _Traits, typename _Alloc>
121  template <typename _InIterator>
122  _CharT*
123  basic_string<_CharT, _Traits, _Alloc>::
124  _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
125  forward_iterator_tag)
126  {
127 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
128  if (__beg == __end && __a == _Alloc())
129  return _S_empty_rep()._M_refdata();
130 #endif
131  // NB: Not required, but considered best practice.
132  if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
133  __throw_logic_error(__N("basic_string::_S_construct null not valid"));
134 
135  const size_type __dnew = static_cast<size_type>(std::distance(__beg,
136  __end));
137  // Check for out_of_range and length_error exceptions.
138  _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
139  __try
140  { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
141  __catch(...)
142  {
143  __r->_M_destroy(__a);
144  __throw_exception_again;
145  }
146  __r->_M_set_length_and_sharable(__dnew);
147  return __r->_M_refdata();
148  }
149 
150  template<typename _CharT, typename _Traits, typename _Alloc>
151  _CharT*
152  basic_string<_CharT, _Traits, _Alloc>::
153  _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
154  {
155 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
156  if (__n == 0 && __a == _Alloc())
157  return _S_empty_rep()._M_refdata();
158 #endif
159  // Check for out_of_range and length_error exceptions.
160  _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
161  if (__n)
162  _M_assign(__r->_M_refdata(), __n, __c);
163 
164  __r->_M_set_length_and_sharable(__n);
165  return __r->_M_refdata();
166  }
167 
168  template<typename _CharT, typename _Traits, typename _Alloc>
169  basic_string<_CharT, _Traits, _Alloc>::
170  basic_string(const basic_string& __str)
171  : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
172  __str.get_allocator()),
173  __str.get_allocator())
174  { }
175 
176  template<typename _CharT, typename _Traits, typename _Alloc>
177  basic_string<_CharT, _Traits, _Alloc>::
178  basic_string(const _Alloc& __a)
179  : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
180  { }
181 
182  template<typename _CharT, typename _Traits, typename _Alloc>
183  basic_string<_CharT, _Traits, _Alloc>::
184  basic_string(const basic_string& __str, size_type __pos, size_type __n)
185  : _M_dataplus(_S_construct(__str._M_data()
186  + __str._M_check(__pos,
187  "basic_string::basic_string"),
188  __str._M_data() + __str._M_limit(__pos, __n)
189  + __pos, _Alloc()), _Alloc())
190  { }
191 
192  template<typename _CharT, typename _Traits, typename _Alloc>
193  basic_string<_CharT, _Traits, _Alloc>::
194  basic_string(const basic_string& __str, size_type __pos,
195  size_type __n, const _Alloc& __a)
196  : _M_dataplus(_S_construct(__str._M_data()
197  + __str._M_check(__pos,
198  "basic_string::basic_string"),
199  __str._M_data() + __str._M_limit(__pos, __n)
200  + __pos, __a), __a)
201  { }
202 
203  // TBD: DPG annotate
204  template<typename _CharT, typename _Traits, typename _Alloc>
205  basic_string<_CharT, _Traits, _Alloc>::
206  basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
207  : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
208  { }
209 
210  // TBD: DPG annotate
211  template<typename _CharT, typename _Traits, typename _Alloc>
212  basic_string<_CharT, _Traits, _Alloc>::
213  basic_string(const _CharT* __s, const _Alloc& __a)
214  : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
215  __s + npos, __a), __a)
216  { }
217 
218  template<typename _CharT, typename _Traits, typename _Alloc>
219  basic_string<_CharT, _Traits, _Alloc>::
220  basic_string(size_type __n, _CharT __c, const _Alloc& __a)
221  : _M_dataplus(_S_construct(__n, __c, __a), __a)
222  { }
223 
224  // TBD: DPG annotate
225  template<typename _CharT, typename _Traits, typename _Alloc>
226  template<typename _InputIterator>
227  basic_string<_CharT, _Traits, _Alloc>::
228  basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
229  : _M_dataplus(_S_construct(__beg, __end, __a), __a)
230  { }
231 
232 #if __cplusplus >= 201103L
233  template<typename _CharT, typename _Traits, typename _Alloc>
234  basic_string<_CharT, _Traits, _Alloc>::
235  basic_string(initializer_list<_CharT> __l, const _Alloc& __a)
236  : _M_dataplus(_S_construct(__l.begin(), __l.end(), __a), __a)
237  { }
238 #endif
239 
240  template<typename _CharT, typename _Traits, typename _Alloc>
241  basic_string<_CharT, _Traits, _Alloc>&
242  basic_string<_CharT, _Traits, _Alloc>::
243  assign(const basic_string& __str)
244  {
245  if (_M_rep() != __str._M_rep())
246  {
247  // XXX MT
248  const allocator_type __a = this->get_allocator();
249  _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
250  _M_rep()->_M_dispose(__a);
251  _M_data(__tmp);
252  }
253  return *this;
254  }
255 
256  template<typename _CharT, typename _Traits, typename _Alloc>
257  basic_string<_CharT, _Traits, _Alloc>&
258  basic_string<_CharT, _Traits, _Alloc>::
259  assign(const _CharT* __s, size_type __n)
260  {
261  __glibcxx_requires_string_len(__s, __n);
262  _M_check_length(this->size(), __n, "basic_string::assign");
263  if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
264  return _M_replace_safe(size_type(0), this->size(), __s, __n);
265  else
266  {
267  // Work in-place.
268  const size_type __pos = __s - _M_data();
269  if (__pos >= __n)
270  _M_copy(_M_data(), __s, __n);
271  else if (__pos)
272  _M_move(_M_data(), __s, __n);
273  _M_rep()->_M_set_length_and_sharable(__n);
274  return *this;
275  }
276  }
277 
278  template<typename _CharT, typename _Traits, typename _Alloc>
279  basic_string<_CharT, _Traits, _Alloc>&
280  basic_string<_CharT, _Traits, _Alloc>::
281  append(size_type __n, _CharT __c)
282  {
283  if (__n)
284  {
285  _M_check_length(size_type(0), __n, "basic_string::append");
286  const size_type __len = __n + this->size();
287  if (__len > this->capacity() || _M_rep()->_M_is_shared())
288  this->reserve(__len);
289  _M_assign(_M_data() + this->size(), __n, __c);
290  _M_rep()->_M_set_length_and_sharable(__len);
291  }
292  return *this;
293  }
294 
295  template<typename _CharT, typename _Traits, typename _Alloc>
296  basic_string<_CharT, _Traits, _Alloc>&
297  basic_string<_CharT, _Traits, _Alloc>::
298  append(const _CharT* __s, size_type __n)
299  {
300  __glibcxx_requires_string_len(__s, __n);
301  if (__n)
302  {
303  _M_check_length(size_type(0), __n, "basic_string::append");
304  const size_type __len = __n + this->size();
305  if (__len > this->capacity() || _M_rep()->_M_is_shared())
306  {
307  if (_M_disjunct(__s))
308  this->reserve(__len);
309  else
310  {
311  const size_type __off = __s - _M_data();
312  this->reserve(__len);
313  __s = _M_data() + __off;
314  }
315  }
316  _M_copy(_M_data() + this->size(), __s, __n);
317  _M_rep()->_M_set_length_and_sharable(__len);
318  }
319  return *this;
320  }
321 
322  template<typename _CharT, typename _Traits, typename _Alloc>
323  basic_string<_CharT, _Traits, _Alloc>&
324  basic_string<_CharT, _Traits, _Alloc>::
325  append(const basic_string& __str)
326  {
327  const size_type __size = __str.size();
328  if (__size)
329  {
330  const size_type __len = __size + this->size();
331  if (__len > this->capacity() || _M_rep()->_M_is_shared())
332  this->reserve(__len);
333  _M_copy(_M_data() + this->size(), __str._M_data(), __size);
334  _M_rep()->_M_set_length_and_sharable(__len);
335  }
336  return *this;
337  }
338 
339  template<typename _CharT, typename _Traits, typename _Alloc>
340  basic_string<_CharT, _Traits, _Alloc>&
341  basic_string<_CharT, _Traits, _Alloc>::
342  append(const basic_string& __str, size_type __pos, size_type __n)
343  {
344  __str._M_check(__pos, "basic_string::append");
345  __n = __str._M_limit(__pos, __n);
346  if (__n)
347  {
348  const size_type __len = __n + this->size();
349  if (__len > this->capacity() || _M_rep()->_M_is_shared())
350  this->reserve(__len);
351  _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
352  _M_rep()->_M_set_length_and_sharable(__len);
353  }
354  return *this;
355  }
356 
357  template<typename _CharT, typename _Traits, typename _Alloc>
358  basic_string<_CharT, _Traits, _Alloc>&
359  basic_string<_CharT, _Traits, _Alloc>::
360  insert(size_type __pos, const _CharT* __s, size_type __n)
361  {
362  __glibcxx_requires_string_len(__s, __n);
363  _M_check(__pos, "basic_string::insert");
364  _M_check_length(size_type(0), __n, "basic_string::insert");
365  if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
366  return _M_replace_safe(__pos, size_type(0), __s, __n);
367  else
368  {
369  // Work in-place.
370  const size_type __off = __s - _M_data();
371  _M_mutate(__pos, 0, __n);
372  __s = _M_data() + __off;
373  _CharT* __p = _M_data() + __pos;
374  if (__s + __n <= __p)
375  _M_copy(__p, __s, __n);
376  else if (__s >= __p)
377  _M_copy(__p, __s + __n, __n);
378  else
379  {
380  const size_type __nleft = __p - __s;
381  _M_copy(__p, __s, __nleft);
382  _M_copy(__p + __nleft, __p + __n, __n - __nleft);
383  }
384  return *this;
385  }
386  }
387 
388  template<typename _CharT, typename _Traits, typename _Alloc>
389  typename basic_string<_CharT, _Traits, _Alloc>::iterator
390  basic_string<_CharT, _Traits, _Alloc>::
391  erase(iterator __first, iterator __last)
392  {
393  _GLIBCXX_DEBUG_PEDASSERT(__first >= _M_ibegin() && __first <= __last
394  && __last <= _M_iend());
395 
396  // NB: This isn't just an optimization (bail out early when
397  // there is nothing to do, really), it's also a correctness
398  // issue vs MT, see libstdc++/40518.
399  const size_type __size = __last - __first;
400  if (__size)
401  {
402  const size_type __pos = __first - _M_ibegin();
403  _M_mutate(__pos, __size, size_type(0));
404  _M_rep()->_M_set_leaked();
405  return iterator(_M_data() + __pos);
406  }
407  else
408  return __first;
409  }
410 
411  template<typename _CharT, typename _Traits, typename _Alloc>
412  basic_string<_CharT, _Traits, _Alloc>&
413  basic_string<_CharT, _Traits, _Alloc>::
414  replace(size_type __pos, size_type __n1, const _CharT* __s,
415  size_type __n2)
416  {
417  __glibcxx_requires_string_len(__s, __n2);
418  _M_check(__pos, "basic_string::replace");
419  __n1 = _M_limit(__pos, __n1);
420  _M_check_length(__n1, __n2, "basic_string::replace");
421  bool __left;
422  if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
423  return _M_replace_safe(__pos, __n1, __s, __n2);
424  else if ((__left = __s + __n2 <= _M_data() + __pos)
425  || _M_data() + __pos + __n1 <= __s)
426  {
427  // Work in-place: non-overlapping case.
428  size_type __off = __s - _M_data();
429  __left ? __off : (__off += __n2 - __n1);
430  _M_mutate(__pos, __n1, __n2);
431  _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
432  return *this;
433  }
434  else
435  {
436  // Todo: overlapping case.
437  const basic_string __tmp(__s, __n2);
438  return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
439  }
440  }
441 
442  template<typename _CharT, typename _Traits, typename _Alloc>
443  void
444  basic_string<_CharT, _Traits, _Alloc>::_Rep::
445  _M_destroy(const _Alloc& __a) throw ()
446  {
447  const size_type __size = sizeof(_Rep_base) +
448  (this->_M_capacity + 1) * sizeof(_CharT);
449  _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
450  }
451 
452  template<typename _CharT, typename _Traits, typename _Alloc>
453  void
454  basic_string<_CharT, _Traits, _Alloc>::
455  _M_leak_hard()
456  {
457 #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
458  if (_M_rep() == &_S_empty_rep())
459  return;
460 #endif
461  if (_M_rep()->_M_is_shared())
462  _M_mutate(0, 0, 0);
463  _M_rep()->_M_set_leaked();
464  }
465 
466  template<typename _CharT, typename _Traits, typename _Alloc>
467  void
468  basic_string<_CharT, _Traits, _Alloc>::
469  _M_mutate(size_type __pos, size_type __len1, size_type __len2)
470  {
471  const size_type __old_size = this->size();
472  const size_type __new_size = __old_size + __len2 - __len1;
473  const size_type __how_much = __old_size - __pos - __len1;
474 
475  if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
476  {
477  // Must reallocate.
478  const allocator_type __a = get_allocator();
479  _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
480 
481  if (__pos)
482  _M_copy(__r->_M_refdata(), _M_data(), __pos);
483  if (__how_much)
484  _M_copy(__r->_M_refdata() + __pos + __len2,
485  _M_data() + __pos + __len1, __how_much);
486 
487  _M_rep()->_M_dispose(__a);
488  _M_data(__r->_M_refdata());
489  }
490  else if (__how_much && __len1 != __len2)
491  {
492  // Work in-place.
493  _M_move(_M_data() + __pos + __len2,
494  _M_data() + __pos + __len1, __how_much);
495  }
496  _M_rep()->_M_set_length_and_sharable(__new_size);
497  }
498 
499  template<typename _CharT, typename _Traits, typename _Alloc>
500  void
501  basic_string<_CharT, _Traits, _Alloc>::
502  reserve(size_type __res)
503  {
504  if (__res != this->capacity() || _M_rep()->_M_is_shared())
505  {
506  // Make sure we don't shrink below the current size
507  if (__res < this->size())
508  __res = this->size();
509  const allocator_type __a = get_allocator();
510  _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
511  _M_rep()->_M_dispose(__a);
512  _M_data(__tmp);
513  }
514  }
515 
516  template<typename _CharT, typename _Traits, typename _Alloc>
517  void
518  basic_string<_CharT, _Traits, _Alloc>::
519  swap(basic_string& __s)
520  {
521  if (_M_rep()->_M_is_leaked())
522  _M_rep()->_M_set_sharable();
523  if (__s._M_rep()->_M_is_leaked())
524  __s._M_rep()->_M_set_sharable();
525  if (this->get_allocator() == __s.get_allocator())
526  {
527  _CharT* __tmp = _M_data();
528  _M_data(__s._M_data());
529  __s._M_data(__tmp);
530  }
531  // The code below can usually be optimized away.
532  else
533  {
534  const basic_string __tmp1(_M_ibegin(), _M_iend(),
535  __s.get_allocator());
536  const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
537  this->get_allocator());
538  *this = __tmp2;
539  __s = __tmp1;
540  }
541  }
542 
543  template<typename _CharT, typename _Traits, typename _Alloc>
544  typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
545  basic_string<_CharT, _Traits, _Alloc>::_Rep::
546  _S_create(size_type __capacity, size_type __old_capacity,
547  const _Alloc& __alloc)
548  {
549  // _GLIBCXX_RESOLVE_LIB_DEFECTS
550  // 83. String::npos vs. string::max_size()
551  if (__capacity > _S_max_size)
552  __throw_length_error(__N("basic_string::_S_create"));
553 
554  // The standard places no restriction on allocating more memory
555  // than is strictly needed within this layer at the moment or as
556  // requested by an explicit application call to reserve().
557 
558  // Many malloc implementations perform quite poorly when an
559  // application attempts to allocate memory in a stepwise fashion
560  // growing each allocation size by only 1 char. Additionally,
561  // it makes little sense to allocate less linear memory than the
562  // natural blocking size of the malloc implementation.
563  // Unfortunately, we would need a somewhat low-level calculation
564  // with tuned parameters to get this perfect for any particular
565  // malloc implementation. Fortunately, generalizations about
566  // common features seen among implementations seems to suffice.
567 
568  // __pagesize need not match the actual VM page size for good
569  // results in practice, thus we pick a common value on the low
570  // side. __malloc_header_size is an estimate of the amount of
571  // overhead per memory allocation (in practice seen N * sizeof
572  // (void*) where N is 0, 2 or 4). According to folklore,
573  // picking this value on the high side is better than
574  // low-balling it (especially when this algorithm is used with
575  // malloc implementations that allocate memory blocks rounded up
576  // to a size which is a power of 2).
577  const size_type __pagesize = 4096;
578  const size_type __malloc_header_size = 4 * sizeof(void*);
579 
580  // The below implements an exponential growth policy, necessary to
581  // meet amortized linear time requirements of the library: see
582  // http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html.
583  // It's active for allocations requiring an amount of memory above
584  // system pagesize. This is consistent with the requirements of the
585  // standard: http://gcc.gnu.org/ml/libstdc++/2001-07/msg00130.html
586  if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
587  __capacity = 2 * __old_capacity;
588 
589  // NB: Need an array of char_type[__capacity], plus a terminating
590  // null char_type() element, plus enough for the _Rep data structure.
591  // Whew. Seemingly so needy, yet so elemental.
592  size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
593 
594  const size_type __adj_size = __size + __malloc_header_size;
595  if (__adj_size > __pagesize && __capacity > __old_capacity)
596  {
597  const size_type __extra = __pagesize - __adj_size % __pagesize;
598  __capacity += __extra / sizeof(_CharT);
599  // Never allocate a string bigger than _S_max_size.
600  if (__capacity > _S_max_size)
601  __capacity = _S_max_size;
602  __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
603  }
604 
605  // NB: Might throw, but no worries about a leak, mate: _Rep()
606  // does not throw.
607  void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
608  _Rep *__p = new (__place) _Rep;
609  __p->_M_capacity = __capacity;
610  // ABI compatibility - 3.4.x set in _S_create both
611  // _M_refcount and _M_length. All callers of _S_create
612  // in basic_string.tcc then set just _M_length.
613  // In 4.0.x and later both _M_refcount and _M_length
614  // are initialized in the callers, unfortunately we can
615  // have 3.4.x compiled code with _S_create callers inlined
616  // calling 4.0.x+ _S_create.
617  __p->_M_set_sharable();
618  return __p;
619  }
620 
621  template<typename _CharT, typename _Traits, typename _Alloc>
622  _CharT*
623  basic_string<_CharT, _Traits, _Alloc>::_Rep::
624  _M_clone(const _Alloc& __alloc, size_type __res)
625  {
626  // Requested capacity of the clone.
627  const size_type __requested_cap = this->_M_length + __res;
628  _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
629  __alloc);
630  if (this->_M_length)
631  _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
632 
633  __r->_M_set_length_and_sharable(this->_M_length);
634  return __r->_M_refdata();
635  }
636 
637  template<typename _CharT, typename _Traits, typename _Alloc>
638  void
639  basic_string<_CharT, _Traits, _Alloc>::
640  resize(size_type __n, _CharT __c)
641  {
642  const size_type __size = this->size();
643  _M_check_length(__size, __n, "basic_string::resize");
644  if (__size < __n)
645  this->append(__n - __size, __c);
646  else if (__n < __size)
647  this->erase(__n);
648  // else nothing (in particular, avoid calling _M_mutate() unnecessarily.)
649  }
650 
651  template<typename _CharT, typename _Traits, typename _Alloc>
652  template<typename _InputIterator>
653  basic_string<_CharT, _Traits, _Alloc>&
654  basic_string<_CharT, _Traits, _Alloc>::
655  _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
656  _InputIterator __k2, __false_type)
657  {
658  const basic_string __s(__k1, __k2);
659  const size_type __n1 = __i2 - __i1;
660  _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
661  return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
662  __s.size());
663  }
664 
665  template<typename _CharT, typename _Traits, typename _Alloc>
666  basic_string<_CharT, _Traits, _Alloc>&
667  basic_string<_CharT, _Traits, _Alloc>::
668  _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
669  _CharT __c)
670  {
671  _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
672  _M_mutate(__pos1, __n1, __n2);
673  if (__n2)
674  _M_assign(_M_data() + __pos1, __n2, __c);
675  return *this;
676  }
677 
678  template<typename _CharT, typename _Traits, typename _Alloc>
679  basic_string<_CharT, _Traits, _Alloc>&
680  basic_string<_CharT, _Traits, _Alloc>::
681  _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
682  size_type __n2)
683  {
684  _M_mutate(__pos1, __n1, __n2);
685  if (__n2)
686  _M_copy(_M_data() + __pos1, __s, __n2);
687  return *this;
688  }
689 
690  template<typename _CharT, typename _Traits, typename _Alloc>
691  basic_string<_CharT, _Traits, _Alloc>
692  operator+(const _CharT* __lhs,
693  const basic_string<_CharT, _Traits, _Alloc>& __rhs)
694  {
695  __glibcxx_requires_string(__lhs);
696  typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
697  typedef typename __string_type::size_type __size_type;
698  const __size_type __len = _Traits::length(__lhs);
699  __string_type __str;
700  __str.reserve(__len + __rhs.size());
701  __str.append(__lhs, __len);
702  __str.append(__rhs);
703  return __str;
704  }
705 
706  template<typename _CharT, typename _Traits, typename _Alloc>
707  basic_string<_CharT, _Traits, _Alloc>
708  operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
709  {
710  typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
711  typedef typename __string_type::size_type __size_type;
712  __string_type __str;
713  const __size_type __len = __rhs.size();
714  __str.reserve(__len + 1);
715  __str.append(__size_type(1), __lhs);
716  __str.append(__rhs);
717  return __str;
718  }
719 
720  template<typename _CharT, typename _Traits, typename _Alloc>
721  typename basic_string<_CharT, _Traits, _Alloc>::size_type
722  basic_string<_CharT, _Traits, _Alloc>::
723  copy(_CharT* __s, size_type __n, size_type __pos) const
724  {
725  _M_check(__pos, "basic_string::copy");
726  __n = _M_limit(__pos, __n);
727  __glibcxx_requires_string_len(__s, __n);
728  if (__n)
729  _M_copy(__s, _M_data() + __pos, __n);
730  // 21.3.5.7 par 3: do not append null. (good.)
731  return __n;
732  }
733 
734  template<typename _CharT, typename _Traits, typename _Alloc>
735  typename basic_string<_CharT, _Traits, _Alloc>::size_type
736  basic_string<_CharT, _Traits, _Alloc>::
737  find(const _CharT* __s, size_type __pos, size_type __n) const
738  {
739  __glibcxx_requires_string_len(__s, __n);
740  const size_type __size = this->size();
741  const _CharT* __data = _M_data();
742 
743  if (__n == 0)
744  return __pos <= __size ? __pos : npos;
745 
746  if (__n <= __size)
747  {
748  for (; __pos <= __size - __n; ++__pos)
749  if (traits_type::eq(__data[__pos], __s[0])
750  && traits_type::compare(__data + __pos + 1,
751  __s + 1, __n - 1) == 0)
752  return __pos;
753  }
754  return npos;
755  }
756 
757  template<typename _CharT, typename _Traits, typename _Alloc>
758  typename basic_string<_CharT, _Traits, _Alloc>::size_type
759  basic_string<_CharT, _Traits, _Alloc>::
760  find(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
761  {
762  size_type __ret = npos;
763  const size_type __size = this->size();
764  if (__pos < __size)
765  {
766  const _CharT* __data = _M_data();
767  const size_type __n = __size - __pos;
768  const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
769  if (__p)
770  __ret = __p - __data;
771  }
772  return __ret;
773  }
774 
775  template<typename _CharT, typename _Traits, typename _Alloc>
776  typename basic_string<_CharT, _Traits, _Alloc>::size_type
777  basic_string<_CharT, _Traits, _Alloc>::
778  rfind(const _CharT* __s, size_type __pos, size_type __n) const
779  {
780  __glibcxx_requires_string_len(__s, __n);
781  const size_type __size = this->size();
782  if (__n <= __size)
783  {
784  __pos = std::min(size_type(__size - __n), __pos);
785  const _CharT* __data = _M_data();
786  do
787  {
788  if (traits_type::compare(__data + __pos, __s, __n) == 0)
789  return __pos;
790  }
791  while (__pos-- > 0);
792  }
793  return npos;
794  }
795 
796  template<typename _CharT, typename _Traits, typename _Alloc>
797  typename basic_string<_CharT, _Traits, _Alloc>::size_type
798  basic_string<_CharT, _Traits, _Alloc>::
799  rfind(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
800  {
801  size_type __size = this->size();
802  if (__size)
803  {
804  if (--__size > __pos)
805  __size = __pos;
806  for (++__size; __size-- > 0; )
807  if (traits_type::eq(_M_data()[__size], __c))
808  return __size;
809  }
810  return npos;
811  }
812 
813  template<typename _CharT, typename _Traits, typename _Alloc>
814  typename basic_string<_CharT, _Traits, _Alloc>::size_type
815  basic_string<_CharT, _Traits, _Alloc>::
816  find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
817  {
818  __glibcxx_requires_string_len(__s, __n);
819  for (; __n && __pos < this->size(); ++__pos)
820  {
821  const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
822  if (__p)
823  return __pos;
824  }
825  return npos;
826  }
827 
828  template<typename _CharT, typename _Traits, typename _Alloc>
829  typename basic_string<_CharT, _Traits, _Alloc>::size_type
830  basic_string<_CharT, _Traits, _Alloc>::
831  find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
832  {
833  __glibcxx_requires_string_len(__s, __n);
834  size_type __size = this->size();
835  if (__size && __n)
836  {
837  if (--__size > __pos)
838  __size = __pos;
839  do
840  {
841  if (traits_type::find(__s, __n, _M_data()[__size]))
842  return __size;
843  }
844  while (__size-- != 0);
845  }
846  return npos;
847  }
848 
849  template<typename _CharT, typename _Traits, typename _Alloc>
850  typename basic_string<_CharT, _Traits, _Alloc>::size_type
851  basic_string<_CharT, _Traits, _Alloc>::
852  find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
853  {
854  __glibcxx_requires_string_len(__s, __n);
855  for (; __pos < this->size(); ++__pos)
856  if (!traits_type::find(__s, __n, _M_data()[__pos]))
857  return __pos;
858  return npos;
859  }
860 
861  template<typename _CharT, typename _Traits, typename _Alloc>
862  typename basic_string<_CharT, _Traits, _Alloc>::size_type
863  basic_string<_CharT, _Traits, _Alloc>::
864  find_first_not_of(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
865  {
866  for (; __pos < this->size(); ++__pos)
867  if (!traits_type::eq(_M_data()[__pos], __c))
868  return __pos;
869  return npos;
870  }
871 
872  template<typename _CharT, typename _Traits, typename _Alloc>
873  typename basic_string<_CharT, _Traits, _Alloc>::size_type
874  basic_string<_CharT, _Traits, _Alloc>::
875  find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
876  {
877  __glibcxx_requires_string_len(__s, __n);
878  size_type __size = this->size();
879  if (__size)
880  {
881  if (--__size > __pos)
882  __size = __pos;
883  do
884  {
885  if (!traits_type::find(__s, __n, _M_data()[__size]))
886  return __size;
887  }
888  while (__size--);
889  }
890  return npos;
891  }
892 
893  template<typename _CharT, typename _Traits, typename _Alloc>
894  typename basic_string<_CharT, _Traits, _Alloc>::size_type
895  basic_string<_CharT, _Traits, _Alloc>::
896  find_last_not_of(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
897  {
898  size_type __size = this->size();
899  if (__size)
900  {
901  if (--__size > __pos)
902  __size = __pos;
903  do
904  {
905  if (!traits_type::eq(_M_data()[__size], __c))
906  return __size;
907  }
908  while (__size--);
909  }
910  return npos;
911  }
912 
913  template<typename _CharT, typename _Traits, typename _Alloc>
914  int
915  basic_string<_CharT, _Traits, _Alloc>::
916  compare(size_type __pos, size_type __n, const basic_string& __str) const
917  {
918  _M_check(__pos, "basic_string::compare");
919  __n = _M_limit(__pos, __n);
920  const size_type __osize = __str.size();
921  const size_type __len = std::min(__n, __osize);
922  int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
923  if (!__r)
924  __r = _S_compare(__n, __osize);
925  return __r;
926  }
927 
928  template<typename _CharT, typename _Traits, typename _Alloc>
929  int
930  basic_string<_CharT, _Traits, _Alloc>::
931  compare(size_type __pos1, size_type __n1, const basic_string& __str,
932  size_type __pos2, size_type __n2) const
933  {
934  _M_check(__pos1, "basic_string::compare");
935  __str._M_check(__pos2, "basic_string::compare");
936  __n1 = _M_limit(__pos1, __n1);
937  __n2 = __str._M_limit(__pos2, __n2);
938  const size_type __len = std::min(__n1, __n2);
939  int __r = traits_type::compare(_M_data() + __pos1,
940  __str.data() + __pos2, __len);
941  if (!__r)
942  __r = _S_compare(__n1, __n2);
943  return __r;
944  }
945 
946  template<typename _CharT, typename _Traits, typename _Alloc>
947  int
948  basic_string<_CharT, _Traits, _Alloc>::
949  compare(const _CharT* __s) const
950  {
951  __glibcxx_requires_string(__s);
952  const size_type __size = this->size();
953  const size_type __osize = traits_type::length(__s);
954  const size_type __len = std::min(__size, __osize);
955  int __r = traits_type::compare(_M_data(), __s, __len);
956  if (!__r)
957  __r = _S_compare(__size, __osize);
958  return __r;
959  }
960 
961  template<typename _CharT, typename _Traits, typename _Alloc>
962  int
963  basic_string <_CharT, _Traits, _Alloc>::
964  compare(size_type __pos, size_type __n1, const _CharT* __s) const
965  {
966  __glibcxx_requires_string(__s);
967  _M_check(__pos, "basic_string::compare");
968  __n1 = _M_limit(__pos, __n1);
969  const size_type __osize = traits_type::length(__s);
970  const size_type __len = std::min(__n1, __osize);
971  int __r = traits_type::compare(_M_data() + __pos, __s, __len);
972  if (!__r)
973  __r = _S_compare(__n1, __osize);
974  return __r;
975  }
976 
977  template<typename _CharT, typename _Traits, typename _Alloc>
978  int
979  basic_string <_CharT, _Traits, _Alloc>::
980  compare(size_type __pos, size_type __n1, const _CharT* __s,
981  size_type __n2) const
982  {
983  __glibcxx_requires_string_len(__s, __n2);
984  _M_check(__pos, "basic_string::compare");
985  __n1 = _M_limit(__pos, __n1);
986  const size_type __len = std::min(__n1, __n2);
987  int __r = traits_type::compare(_M_data() + __pos, __s, __len);
988  if (!__r)
989  __r = _S_compare(__n1, __n2);
990  return __r;
991  }
992 
993  // 21.3.7.9 basic_string::getline and operators
994  template<typename _CharT, typename _Traits, typename _Alloc>
995  basic_istream<_CharT, _Traits>&
996  operator>>(basic_istream<_CharT, _Traits>& __in,
997  basic_string<_CharT, _Traits, _Alloc>& __str)
998  {
999  typedef basic_istream<_CharT, _Traits> __istream_type;
1000  typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
1001  typedef typename __istream_type::ios_base __ios_base;
1002  typedef typename __istream_type::int_type __int_type;
1003  typedef typename __string_type::size_type __size_type;
1004  typedef ctype<_CharT> __ctype_type;
1005  typedef typename __ctype_type::ctype_base __ctype_base;
1006 
1007  __size_type __extracted = 0;
1008  typename __ios_base::iostate __err = __ios_base::goodbit;
1009  typename __istream_type::sentry __cerb(__in, false);
1010  if (__cerb)
1011  {
1012  __try
1013  {
1014  // Avoid reallocation for common case.
1015  __str.erase();
1016  _CharT __buf[128];
1017  __size_type __len = 0;
1018  const streamsize __w = __in.width();
1019  const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
1020  : __str.max_size();
1021  const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1022  const __int_type __eof = _Traits::eof();
1023  __int_type __c = __in.rdbuf()->sgetc();
1024 
1025  while (__extracted < __n
1026  && !_Traits::eq_int_type(__c, __eof)
1027  && !__ct.is(__ctype_base::space,
1028  _Traits::to_char_type(__c)))
1029  {
1030  if (__len == sizeof(__buf) / sizeof(_CharT))
1031  {
1032  __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
1033  __len = 0;
1034  }
1035  __buf[__len++] = _Traits::to_char_type(__c);
1036  ++__extracted;
1037  __c = __in.rdbuf()->snextc();
1038  }
1039  __str.append(__buf, __len);
1040 
1041  if (_Traits::eq_int_type(__c, __eof))
1042  __err |= __ios_base::eofbit;
1043  __in.width(0);
1044  }
1045  __catch(__cxxabiv1::__forced_unwind&)
1046  {
1047  __in._M_setstate(__ios_base::badbit);
1048  __throw_exception_again;
1049  }
1050  __catch(...)
1051  {
1052  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1053  // 91. Description of operator>> and getline() for string<>
1054  // might cause endless loop
1055  __in._M_setstate(__ios_base::badbit);
1056  }
1057  }
1058  // 211. operator>>(istream&, string&) doesn't set failbit
1059  if (!__extracted)
1060  __err |= __ios_base::failbit;
1061  if (__err)
1062  __in.setstate(__err);
1063  return __in;
1064  }
1065 
1066  template<typename _CharT, typename _Traits, typename _Alloc>
1067  basic_istream<_CharT, _Traits>&
1068  getline(basic_istream<_CharT, _Traits>& __in,
1069  basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
1070  {
1071  typedef basic_istream<_CharT, _Traits> __istream_type;
1072  typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
1073  typedef typename __istream_type::ios_base __ios_base;
1074  typedef typename __istream_type::int_type __int_type;
1075  typedef typename __string_type::size_type __size_type;
1076 
1077  __size_type __extracted = 0;
1078  const __size_type __n = __str.max_size();
1079  typename __ios_base::iostate __err = __ios_base::goodbit;
1080  typename __istream_type::sentry __cerb(__in, true);
1081  if (__cerb)
1082  {
1083  __try
1084  {
1085  __str.erase();
1086  const __int_type __idelim = _Traits::to_int_type(__delim);
1087  const __int_type __eof = _Traits::eof();
1088  __int_type __c = __in.rdbuf()->sgetc();
1089 
1090  while (__extracted < __n
1091  && !_Traits::eq_int_type(__c, __eof)
1092  && !_Traits::eq_int_type(__c, __idelim))
1093  {
1094  __str += _Traits::to_char_type(__c);
1095  ++__extracted;
1096  __c = __in.rdbuf()->snextc();
1097  }
1098 
1099  if (_Traits::eq_int_type(__c, __eof))
1100  __err |= __ios_base::eofbit;
1101  else if (_Traits::eq_int_type(__c, __idelim))
1102  {
1103  ++__extracted;
1104  __in.rdbuf()->sbumpc();
1105  }
1106  else
1107  __err |= __ios_base::failbit;
1108  }
1109  __catch(__cxxabiv1::__forced_unwind&)
1110  {
1111  __in._M_setstate(__ios_base::badbit);
1112  __throw_exception_again;
1113  }
1114  __catch(...)
1115  {
1116  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1117  // 91. Description of operator>> and getline() for string<>
1118  // might cause endless loop
1119  __in._M_setstate(__ios_base::badbit);
1120  }
1121  }
1122  if (!__extracted)
1123  __err |= __ios_base::failbit;
1124  if (__err)
1125  __in.setstate(__err);
1126  return __in;
1127  }
1128 
1129  // Inhibit implicit instantiations for required instantiations,
1130  // which are defined via explicit instantiations elsewhere.
1131 #if _GLIBCXX_EXTERN_TEMPLATE > 0
1132  extern template class basic_string<char>;
1133  extern template
1134  basic_istream<char>&
1135  operator>>(basic_istream<char>&, string&);
1136  extern template
1137  basic_ostream<char>&
1138  operator<<(basic_ostream<char>&, const string&);
1139  extern template
1140  basic_istream<char>&
1141  getline(basic_istream<char>&, string&, char);
1142  extern template
1143  basic_istream<char>&
1144  getline(basic_istream<char>&, string&);
1145 
1146 #ifdef _GLIBCXX_USE_WCHAR_T
1147  extern template class basic_string<wchar_t>;
1148  extern template
1149  basic_istream<wchar_t>&
1150  operator>>(basic_istream<wchar_t>&, wstring&);
1151  extern template
1152  basic_ostream<wchar_t>&
1153  operator<<(basic_ostream<wchar_t>&, const wstring&);
1154  extern template
1155  basic_istream<wchar_t>&
1156  getline(basic_istream<wchar_t>&, wstring&, wchar_t);
1157  extern template
1158  basic_istream<wchar_t>&
1159  getline(basic_istream<wchar_t>&, wstring&);
1160 #endif
1161 #endif
1162 
1163 _GLIBCXX_END_NAMESPACE_VERSION
1164 } // namespace std
__gnu_profile::__size
std::size_t __size(__stack_t __stack)
Definition: profiler_node.h:68
__try
#define __try
Definition: exception_defines.h:35
__throw_exception_again
#define __throw_exception_again
Definition: exception_defines.h:37
__glibcxx_requires_string
#define __glibcxx_requires_string(_String)
Definition: debug.h:78
__gnu_parallel::min
const _Tp & min(const _Tp &__a, const _Tp &__b)
Equivalent to std::min.
Definition: base.h:144
__gnu_debug::operator>>
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, basic_string< _CharT, _Traits, _Allocator > &__str)
Definition: string:1122
__glibcxx_requires_string_len
#define __glibcxx_requires_string_len(_String, _Len)
Definition: debug.h:79
__gnu_debug::operator+
_Safe_iterator< _Iterator, _Sequence > operator+(typename _Safe_iterator< _Iterator, _Sequence >::difference_type __n, const _Safe_iterator< _Iterator, _Sequence > &__i)
Definition: safe_iterator.h:712
_GLIBCXX_DEBUG_PEDASSERT
#define _GLIBCXX_DEBUG_PEDASSERT(_Condition)
Definition: debug.h:62
__gnu_debug::getline
std::basic_istream< _CharT, _Traits > & getline(std::basic_istream< _CharT, _Traits > &__is, basic_string< _CharT, _Traits, _Allocator > &__str, _CharT __delim)
Definition: string:1132
__catch
#define __catch(X)
Definition: exception_defines.h:36
basic_string
Definition: basic_string.h:45
std::__exception_ptr::swap
void swap(exception_ptr &__lhs, exception_ptr &__rhs)
Definition: exception_ptr.h:160
Generated on Sat Jul 22 2017 14:41:11 for STLdoc by   doxygen 1.8.6