basic_string

最新推荐文章于 2023-08-25 00:08:46 发布
最新推荐文章于 2023-08-25 00:08:46 发布
阅读量795 收藏
点赞数
分类专栏： C/C++ 文章标签： basic string character iterator class insert

basic_string < charT, traits, Alloc >

Category: containers

Description

basic_string 是基于字符序列容器(Sequence)的模板类, 包含了说有序列容器的常用操作，同时也包含了字符串的标准操作，如"查找"和"合并" 。

basic_string 类是通过字符类型和类型的特征( Character Traits )来实例化的。但通常我们不直接使用 basic_string 模板，而是使用 string 和 wstring ， 他们是两个typedef: 

typedef basic_string <char> string;
typedef basic_string<wchar_t> wstring;
basic_string的一些成员函数的参数并不像其他容器一样指定一个特定位置和范围。除了像传统的容器使用迭代器iterator之外，basic_string的许多成员函数用单个的size_type类型值表示位置(例如：一般用begin() + pos 表示位置，basic_string的许多成员函数使用两个参数：pos和n，表示一个区间。此时pos表示区间的开始，'n'表示区间的大小，也就是说，这个区间是[begin() + pos, begin() + pos + n) .

 

值得注意的是，C++标准中没有对basic_string的操作复杂度做详细说明，在SGI的实现中，basic_string和vector的性能差不多: 性能曲线都是恒定的O(1), 只有copy和链接是O(N)的。相比之下，rope 有一个不同的性能曲线：绝大部分操作都是具有log(N)的复杂度。

还要注意的是，C++标准中，basic_string有自己独特的迭代器语法，在swap, reserve, insert, 和 erase操作后，迭代器可能会失效（其他和insert 或 erase函数功能类似的操作也会如此，如:clear, resize, append, replace)。另外，第一次调用non-const成员函数，也包括begin(), operator[], 也有可能导致迭代器无效。(之所以有这些机制，是为了在实现起来更加自由)。不过在SGI的实现版本中，begin(), end(), rbegin(), rend(), operator[], c_str(), 和data()并不会是迭代器无效，迭代器值会在string 内容被明显修改时无效。

Example ： 

int main() { 
        string s(10u, ' ');           // Create a string of ten blanks.
        
        const char* A = "this is a test";
        s += A;
        cout << "s = " << (s + '/n');
        cout << "As a null-terminated sequence: " << s.c_str() << endl;
        cout << "The sixteenth character is " << s[15] << endl;
        
        reverse(s.begin(), s.end());
        s.push_back('/n');
        cout << s;
}
Definition

定义在文件 string.

Template Parameters

参数 描述 缺省
charT string 值的类型: 包含的字符类型 无
traits Character Traits 类型, 封装了基本的字符操作. char_traits < charT >
Alloc string 置配器：用于内部内存分配管理 alloc

Type requirements

除了需要有随机型迭代器的容器和序列容器要求外，还需要：

  • charT 是 POD ("plain 'ol data") 类型.
  • traits 是 Character Traits 类型，缺省类型是 charT

Members

 

 

 

 

Member Where defined Description
value_type Container The type of object, CharT, stored in the string.
pointer Container Pointer to CharT.
reference Container Reference to CharT

const_reference

Container Const reference to CharT
size_type

 

Container An unsigned integral type.
difference_type Container

 

A signed integral type.
static const size_type npos basic_string The largest possible value of type size_type. That is, size_type(-1).

 

iterator Container Iterator used to iterate through a string. A basic_string supplies Random Access Iterators.

 

const_iterator Container Const iterator used to iterate through a string.
reverse_iterator Reversible Container Iterator used to iterate backwards through a string.
const_reverse_iterator

 

Reversible Container Const iterator used to iterate backwards through a string.
iterator begin() Container

 

Returns an iterator pointing to the beginning of the string.
iterator end() Container

 

Returns an iterator pointing to the end of the string.
const_iterator begin() const Container

 

Returns a const_iterator pointing to the beginning of the string.
const_iterator end() const Container

 

Returns a const_iterator pointing to the end of the string.
reverse_iterator rbegin() Reversible Container

 

Returns a reverse_iterator pointing to the beginning of the reversed string.
reverse_iterator rend() Reversible Container

 

Returns a reverse_iterator pointing to the end of the reversed string.
const_reverse_iterator rbegin() const Reversible Container

 

Returns a const_reverse_iterator pointing to the beginning of the reversed string.
const_reverse_iterator rend() const Reversible Container

 

Returns a const_reverse_iterator pointing to the end of the reversed string.
size_type size() const Container

 

Returns the size of the string.
size_type length() const basic_string Synonym for size().

 

size_type max_size() const Container Returns the largest possible size of the string.
size_type capacity() const basic_string See below.
bool empty() const Container true if the string's size is 0.
reference operator[](size_type n)

 

Random Access Container Returns the n'th character.
const_reference operator[](size_type n) const Random Access Container Returns the n'th character.
const charT* c_str() const

basic_string

Returns a pointer to a null-terminated array of characters representing the string's contents.
const charT* data() const basic_string

Returns a pointer to an array of characters (not necessarily null-terminated) representing the string's contents.

basic_string() Container Creates an empty string. 
basic_string(const basic_string& s, 
             size_type pos = 0, size_type n = npos)
Container, basic_string Generalization of the copy constructor.

 

basic_string(const charT*) basic_string Construct a string from a null-terminated character array.

basic_string(const charT* s, size_type n)

basic_string Construct a string from a character array and a length.
basic_string(size_type n, charT c)

Sequence

Create a string with n copies of c. 
template <class InputIterator>

basic_string(InputIterator first, InputIterator last)
Sequence Create a string from a range.
~basic_string() Container The destructor.
basic_string& operator=(const basic_string&) Container The assignment operator
basic_string& operator=(const charT* s)

basic_string

Assign a null-terminated character array to a string.
basic_string& operator=(charT c) basic_string

 

Assign a single character to a string.
void reserve(size_t) basic_string See below.
void swap(basic_string&) Container Swaps the contents of two strings. 
iterator insert(iterator pos,
                const T& x)
Sequence Inserts x before pos.

 

template <class InputIterator>
void insert(iterator pos,
            InputIterator f, InputIterator l)
[1]
Sequence

 

Inserts the range [first, last) before pos. 
void insert(iterator pos, 
            size_type n, const T& x)

 

Sequence Inserts n copies of x before pos.
basic_string& insert(size_type pos, const basic_string& s) basic_string Inserts s before pos.

 

basic_string& insert(size_type pos, 
                     const basic_string& s, 
                     size_type pos1, size_type n)
basic_string

Inserts a substring of s before pos.

basic_string& insert(size_type pos, const charT* s) basic_string

 

Inserts s before pos.
basic_string& insert(size_type pos, const charT* s, size_type n) basic_string Inserts the first n characters of s before pos.
basic_string& insert(size_type pos, size_type n, charT c)

 

basic_string Inserts n copies of c before pos.
basic_string& append(const basic_string& s) basic_string Append s to *this.

 

basic_string& append(const basic_string& s, 
                     size_type pos, size_type n)
basic_string

Append a substring of s to *this.

basic_string& append(const charT* s) basic_string

 

Append s to *this.
basic_string& append(const charT* s, size_type n) basic_string Append the first n characters of s to *this.
basic_string& append(size_type n, charT c) basic_string Append n copies of c to *this.

 

template <class InputIterator>
basic_string& append(InputIterator first, InputIterator last)
basic_string Append a range to *this.
void push_back(charT c) basic_string Append a single character to *this.

 

basic_string& operator+=(const basic_string& s) basic_string Equivalent to append(s).

 

basic_string& operator+=(const charT* s) basic_string Equivalent to append(s)

 

basic_string& operator+=(charT c) basic_string Equivalent to push_back(c)

 

iterator erase(iterator p) Sequence Erases the character at position p
iterator erase(iterator first, iterator last) Sequence Erases the range [first, last)
basic_string& erase(size_type pos = 0, size_type n = npos) basic_string Erases a range.

void clear()

Sequence Erases the entire container.
void resize(size_type n, charT c = charT()) Sequence Appends characters, or erases characters from the end, as necessary to make the string's length exactly n characters.
basic_string& assign(const basic_string&)

 

basic_string Synonym for operator= 
 
basic_string& assign(const basic_string& s, 
                     size_type pos, size_type n)
basic_string Assigns a substring of s to *this

basic_string& assign(const charT* s, size_type n)

basic_string Assigns the first n characters of s to *this.

 

basic_string& assign(const charT* s) basic_string Assigns a null-terminated array of characters to *this.

 

basic_string& assign(size_type n, charT c) Sequence Erases the existing characters and replaces them by n copies of c.

 

template <class InputIterator>
basic_string& assign(InputIterator first, InputIterator last)
Sequence

 

Erases the existing characters and replaces them by [first, last) 
basic_string& replace(size_type pos, size_type n, 
                      const basic_string& s)
basic_string Replaces a substring of *this with the string s. 
basic_string& replace(size_type pos, size_type n, 
                      const basic_string& s, 
                      size_type pos1, size_type n1)
basic_string Replaces a substring of *this with a substring of s.

 

basic_string& replace(size_type pos, size_type n, 
                      const charT* s, size_type n1)
basic_string Replaces a substring of *this with the first n1 characters of s.

 

basic_string& replace(size_type pos, size_type n, 
                      const charT* s)
basic_string Replaces a substring of *this with a null-terminated character array.

 

basic_string& replace(size_type pos, size_type n, 
                      size_type n1, charT c)
basic_string Replaces a substring of *this with n1 copies of c.

 

basic_string& replace(iterator first, iterator last, 
                      const basic_string& s)
basic_string

Replaces a substring of *this with the string s. 

basic_string& replace(iterator first, iterator last, 
                      const charT* s, size_type n)

basic_string

Replaces a substring of *this with the first n characters of s.

 

basic_string& replace(iterator first, iterator last, 
                      const charT* s)
basic_string Replaces a substring of *this with a null-terminated character array. 
basic_string& replace(iterator first, iterator last, 
                      size_type n, charT c)
basic_string Replaces a substring of *this with n copies of c.

 

template <class InputIterator>
basic_string& replace(iterator first, iterator last, 
                      InputIterator f, InputIterator l)
basic_string Replaces a substring of *this with the range [f, l)
size_type copy(charT* buf, size_type n, size_type pos = 0) const basic_string

 

Copies a substring of *this to a buffer.
size_type find(const basic_string& s, size_type pos = 0) const basic_string

 

Searches for s as a substring of *this, beginning at character pos of *this.

size_type find(const charT* s, size_type pos, size_type n) const

basic_string Searches for the first n characters of s as a substring of *this, beginning at character pos of *this.

 

size_type find(const charT* s, size_type pos = 0) const basic_string Searches for a null-terminated character array as a substring of *this, beginning at character pos of *this.

 

size_type find(charT c, size_type pos = 0) const basic_string Searches for the character c, beginning at character position pos.

 

size_type rfind(const basic_string& s, size_type pos = npos) const basic_string Searches backward for s as a substring of *this, beginning at character position min(pos, size())

 

size_type rfind(const charT* s, size_type pos, size_type n) const basic_string Searches backward for the first n characters of s as a substring of *this, beginning at character position min(pos, size())

 

size_type rfind(const charT* s, size_type pos = npos) const basic_string Searches backward for a null-terminated character array as a substring of *this, beginning at character min(pos, size())

 

size_type rfind(charT c, size_type pos = npos) const basic_string Searches backward for the character c, beginning at character position min(pos, size().

 

size_type find_first_of(const basic_string& s, size_type pos = 0) const basic_string Searches within *this, beginning at pos, for the first character that is equal to any character within s.

 

size_type find_first_of(const charT* s, size_type pos, size_type n) const basic_string Searches within *this, beginning at pos, for the first character that is equal to any character within the first n characters of s.

 

size_type find_first_of(const charT* s, size_type pos = 0) const basic_string Searches within *this, beginning at pos, for the first character that is equal to any character within s.

 

size_type find_first_of(charT c, size_type pos = 0) const basic_string Searches within *this, beginning at pos, for the first character that is equal to c.

 

size_type find_first_not_of(const basic_string& s, size_type pos = 0) const basic_string Searches within *this, beginning at pos, for the first character that is not equal to any character within s.

 

size_type find_first_not_of(const charT* s, size_type pos, size_type n) const basic_string Searches within *this, beginning at pos, for the first character that is not equal to any character within the first n characters of s.

 

size_type find_first_not_of(const charT* s, size_type pos = 0) const basic_string Searches within *this, beginning at pos, for the first character that is not equal to any character within s.

 

size_type find_first_not_of(charT c, size_type pos = 0) const basic_string Searches within *this, beginning at pos, for the first character that is not equal to c.

 

size_type find_last_of(const basic_string& s, size_type pos = npos) const basic_string Searches backward within *this, beginning at min(pos, size()), for the first character that is equal to any character within s.

 

size_type find_last_of(const charT* s, size_type pos, size_type n) const basic_string Searches backward within *this, beginning at min(pos, size()), for the first character that is equal to any character within the first n characters of s.

 

size_type find_last_of(const charT* s, size_type pos = npos) const basic_string Searches backward *this, beginning at min(pos, size()), for the first character that is equal to any character within s.

 

size_type find_last_of(charT c, size_type pos = npos) const basic_string Searches backward *this, beginning at min(pos, size()), for the first character that is equal to c.

 

size_type find_last_not_of(const basic_string& s, size_type pos = npos) const basic_string Searches backward within *this, beginning at min(pos, size()), for the first character that is not equal to any character within s.

 

size_type find_last_not_of(const charT* s, size_type pos, size_type n) const basic_string Searches backward within *this, beginning at min(pos, size()), for the first character that is not equal to any character within the first n characters of s.

 

size_type find_last_not_of(const charT* s, size_type pos = npos) const basic_string Searches backward *this, beginning at min(pos, size()), for the first character that is not equal to any character within s.

 

size_type find_last_not_of(charT c, size_type pos = npos) const basic_string Searches backward *this, beginning at min(pos, size()), for the first character that is not equal to c.

 

basic_string substr(size_type pos = 0, size_type n = npos) const basic_string Returns a substring of *this.
int compare(const basic_string& s) const basic_string Three-way lexicographical comparison of s and *this.

 

int compare(size_type pos, size_type n, const basic_string& s) const basic_string Three-way lexicographical comparison of s and a substring of *this.

 

int compare(size_type pos, size_type n, const basic_string& s, size_type pos1, size_type n1) const basic_string Three-way lexicographical comparison of a substring of s and a substring of *this.

 

int compare(const charT* s) const basic_string Three-way lexicographical comparison of s and *this.

 

int compare(size_type pos, size_type n, const charT* s, size_type len = npos) const basic_string Three-way lexicographical comparison of the first min(len, traits::length(s) characters of s and a substring of *this.

 

template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const basic_string<charT, traits, Alloc>& s2)
basic_string String concatenation. A global function, not a member function. 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>

operator+(const charT* s1,
          const basic_string<charT, traits, Alloc>& s2)
basic_string String concatenation. A global function, not a member function. 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const charT* s2)
basic_string

String concatenation. A global function, not a member function. 

template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(charT c,
          const basic_string<charT, traits, Alloc>& s2)

 

basic_string String concatenation. A global function, not a member function. 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>

operator+(const basic_string<charT, traits, Alloc>& s1,
          charT c)
basic_string String concatenation. A global function, not a member function. 
template <class charT, class traits, class Alloc>
bool operator==(const basic_string<charT, traits, Alloc>& s1,
                const basic_string<charT, traits, Alloc>& s2)
Container String equality. A global function, not a member function. 
template <class charT, class traits, class Alloc>
bool operator==(const charT* s1, 
                const basic_string<charT, traits, Alloc>& s2)

basic_string

String equality. A global function, not a member function. 
template <class charT, class traits, class Alloc>
bool operator==(const basic_string<charT, traits, Alloc>& s1,
                const charT* s2)
basic_string String equality. A global function, not a member function. 
template <class charT, class traits, class Alloc>
bool operator!=(const basic_string<charT, traits, Alloc>& s1,
                const basic_string<charT, traits, Alloc>& s2)
Container String inequality. A global function, not a member function. 
template <class charT, class traits, class Alloc>

bool operator!=(const charT* s1, 
                const basic_string<charT, traits, Alloc>& s2)
basic_string String inequality. A global function, not a member function. 
template <class charT, class traits, class Alloc>
bool operator!=(const basic_string<charT, traits, Alloc>& s1,
                const charT* s2)
basic_string String inequality. A global function, not a member function. 
template <class charT, class traits, class Alloc>
bool operator<(const basic_string<charT, traits, Alloc>& s1,
               const basic_string<charT, traits, Alloc>& s2)

Container

String comparison. A global function, not a member function. 
template <class charT, class traits, class Alloc>
bool operator<(const charT* s1, 
               const basic_string<charT, traits, Alloc>& s2)
basic_string String comparison. A global function, not a member function. 
template <class charT, class traits, class Alloc>
bool operator<(const basic_string<charT, traits, Alloc>& s1,
               const charT* s2)
basic_string String comparison. A global function, not a member function. 
template <class charT, class traits, class Alloc>
void swap(basic_string<charT, traits, Alloc>& s1,
          basic_string<charT, traits, Alloc>& s2)
Container Swaps the contents of two strings. 
template <class charT, class traits, class Alloc>

basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
           basic_string<charT, traits, Alloc>& s)
basic_string Reads s from the input stream is 
template <class charT, class traits, class Alloc>
basic_ostream<charT, traits>&

operator<<(basic_istream<charT, traits>& os,
           const basic_string<charT, traits, Alloc>& s)
basic_string Writes s to the output stream os

 

template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Alloc>& s,
        charT delim)
basic_string Reads a string from the input stream is, stopping when it reaches delim 
template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Alloc>& s)
basic_string

 

Reads a single line from the input stream is

New members

These members are not defined in the Random Access Container and Sequence: requirements, but are specific to basic_string.

 

 

 

 

 

 

 

Member Description
static const size_type npos The largest possible value of type size_type. That is, size_type(-1).

 

size_type length() const Equivalent to size().
size_type capacity() const

 

Number of elements for which memory has been allocated. That is, the size to which the string can grow before memory must be reallocated. capacity() is always greater than or equal to size().
const charT* c_str() const Returns a pointer to a null-terminated array of characters representing the string's contents. For any string s it is guaranteed that the first s.size() characters in the array pointed to by s.c_str()

are equal to the character in s, and that s.c_str()[s.size()] is a null character. Note, however, that it not necessarily the first null character. Characters within a string are permitted to be null.

const charT* data() const Returns a pointer to an array of characters, not necessarily null-terminated, representing the string's contents. data()

is permitted, but not required, to be identical to c_str(). The first size() characters of that array are guaranteed to be identical to the characters in *this. The return value of data() is never a null pointer, even if size() is zero.

basic_string(const basic_string& s, size_type pos = 0, size_type n = npos) Constructs a string from a substring of s. The substring begins at character position pos and terminates at character position pos + n or at the end of s, whichever comes first. This constructor throws out_of_range if pos > s.size(). Note that when pos and n

have their default values, this is just a copy constructor.

basic_string(const charT* s) Equivalent to basic_string(s, s + traits::length(s)).

basic_string(const charT* s, size_type n)

Equivalent to basic_string(s, s + n).
basic_string& operator=(const charT* s)

Equivalent to operator=(basic_string(s)).

basic_string& operator=(charT c) Assigns to *this a string whose size is 1 and whose contents is the single character c.

 

void reserve(size_t n) Requests that the string's capacity be changed; the postcondition for this member function is that, after it is called, capacity() >= n. You may request that a string decrease its capacity by calling reserve() with an argument less than the current capacity. (If you call reserve() with an argument less than the string's size, however, the capacity will only be reduced to size(). A string's size can never be greater than its capacity.) reserve() throws length_error if n > max_size().

 

basic_string& insert(size_type pos, const basic_string& s) If pos > size(), throws out_of_range. Otherwise, equivalent to insert(begin() + pos, s.begin(), s.end()).

 

basic_string& insert(size_type pos, 
                     const basic_string& s, 
                     size_type pos1, size_type n)
If pos > size() or pos1 > s.size(), throws out_of_range. Otherwise, equivalent to insert(begin() + pos, s.begin() + pos1, s.begin() + pos1 + min(n, s.size() - pos1)).

 

basic_string& insert(size_type pos, const charT* s) If pos > size(), throws out_of_range. Otherwise, equivalent to insert(begin() + pos, s, s + traits::length(s))

 

basic_string& insert(size_type pos, const charT* s, size_type n) If pos > size(), throws out_of_range. Otherwise, equivalent to insert(begin() + pos, s, s + n).

 

basic_string& insert(size_type pos, size_type n, charT c) If pos > size(), throws out_of_range. Otherwise, equivalent to insert(begin() + pos, n, c).

 

basic_string& append(const basic_string& s) Equivalent to insert(end(), s.begin(), s.end()). 
basic_string& append(const basic_string& s, 
                     size_type pos, size_type n)
If pos > s.size(), throws out_of_range. Otherwise, equivalent to insert(end(), s.begin() + pos, s.begin() + pos + min(n, s.size() - pos)).

 

basic_string& append(const charT* s) Equivalent to insert(end(), s, s + traits::length(s)).

basic_string& append(const charT* s, size_type n)

Equivalent to insert(end(), s, s + n).
basic_string& append(size_type n, charT c)

 

Equivalent to insert(end(), n, c). 
template <class InputIterator>
basic_string& append(InputIterator first, InputIterator last)

 

Equivalent to insert(end(), first, last).
void push_back(charT c) Equivalent to insert(end(), c)
basic_string& operator+=(const basic_string& s) Equivalent to append(s).
basic_string& operator+=(const charT* s) Equivalent to append(s)
basic_string& operator+=(charT c)

 

Equivalent to push_back(c)
basic_string& erase(size_type pos = 0, size_type n = npos) If pos > size(), throws out_of_range. Otherwise, equivalent to erase(begin() + pos, begin() + pos + min(n, size() - pos)).

 

basic_string& assign(const basic_string& s) Synonym for operator= 
basic_string& assign(const basic_string& s, 
                     size_type pos, size_type n)
Equivalent to (but probably faster than) clear() followed by insert(0, s, pos, n).

 

basic_string& assign(const charT* s, size_type n) Equivalent to (but probably faster than) clear() followed by insert(0, s, n).
basic_string& assign(const charT* s) Equivalent to (but probably faster than) clear() followed by insert(0, s). 
basic_string& replace(size_type pos, size_type n, 
                      const basic_string& s)
Equivalent to erase(pos, n) followed by insert(pos, s).

 

basic_string& replace(size_type pos, size_type n, 
                      const basic_string& s, size_type pos1, size_type n1)
Equivalent to erase(pos, n) followed by insert(pos, s, pos1, n1).

 

basic_string& replace(size_type pos, size_type n, 
                      const charT* s, size_type n1)
Equivalent to erase(pos, n) followed by insert(pos, s, n1).

 

basic_string& replace(size_type pos, size_type n, 
                      const charT* s)
Equivalent to erase(pos, n) followed by insert(pos, s).

 

basic_string& replace(size_type pos, size_type n, 
                      size_type n1, charT c)
Equivalent to erase(pos, n) followed by insert(pos, n1, c).

 

basic_string& replace(iterator first, iterator last, 
                      const basic_string& s)
Equivalent to insert(erase(first, last), s.begin(), s.end()). 
basic_string& replace(iterator first, iterator last, 
                      const charT* s, size_type n)
Equivalent to insert(erase(first, last), s, s + n).

 

basic_string& replace(iterator first, iterator last, 
                      const charT* s)
Equivalent to insert(erase(first, last), s, s + traits::length(s)). 
basic_string& replace(iterator first, iterator last, 
                      size_type n, charT c)
Equivalent to insert(erase(first, last), n, c). 
template <class InputIterator>
basic_string& replace(iterator first, iterator last, 
                      InputIterator f, InputIterator l)
Equivalent to insert(erase(first, last), f, l).
size_type copy(charT* buf, size_type n, size_type pos = 0) const Copies at most n characters from *this to a character array. Throws out_of_range if pos > size(). Otherwise, equivalent to copy(begin() + pos, begin() + pos + min(n, size()), buf). Note that this member function does nothing other than copy characters from *this to buf; in particular, it does not terminate buf with a null character.

 

size_type find(const basic_string& s, size_type pos = 0) const Searches for s as a substring of *this, beginning at character position pos. It is almost the same as search, except that search tests elements for equality using operator== or a user-provided function object, while this member function uses traits::eq. Returns the lowest character position N such that pos <= N and pos + s.size() <= size() and such that, for every i less than s.size(), (*this)[N + i] compares equal to s[i]. Returns npos if no such position N exists. Note that it is legal to call this member function with arguments such that s.size() > size() - pos, but such a search will always fail.

 

size_type find(const charT* s, size_type pos, size_type n) const Searches for the first n characters of s as a substring of *this, beginning at character pos of *this. This is equivalent to find(basic_string(s, n), pos).

 

size_type find(const charT* s, size_type pos = 0) const Searches for a null-terminated character array as a substring of *this, beginning at character pos of *this. This is equivalent to find(basic_string(s), pos).

 

size_type find(charT c, size_type pos = 0) const Searches for the character c, beginning at character position pos. That is, returns the first character position N greater than or equal to pos, and less than size(), such that (*this)[N] compares equal to c. Returns npos if no such character position N exists.

 

size_type rfind(const basic_string& s, size_type pos = npos) const Searches backward for s as a substring of *this. It is almost the same as find_end, except that find_end tests elements for equality using operator== or a user-provided function object, while this member function uses traits::eq. This member function returns the largest character position N such that N <= pos and N + s.size() <= size(), and such that, for every i less than s.size(), (*this)[N + i]

compares equal to s[i]. Returns npos if no such position N exists. Note that it is legal to call this member function with arguments such that s.size() > size(), but such a search will always fail.

size_type rfind(const charT* s, size_type pos, size_type n) const Searches backward for the first n characters of s as a substring of *this. Equivalent to rfind(basic_string(s, n), pos).
size_type rfind(const charT* s, size_type pos = npos) const Searches backward for a null-terminated character array as a substring of *this. Equivalent to rfind(basic_string(s), pos).
size_type rfind(charT c, size_type pos = npos) const

 

Searches backward for the character c. That is, returns the largest character position N such that N <= pos and N < size(), and such that (*this)[N] compares equal to c. Returns npos if no such character position exists.

 

size_type find_first_of(const basic_string& s, size_type pos = 0) const Searches within *this, beginning at pos, for the first character that is equal to any character within s. This is similar to the standard algorithm find_first_of, but differs because find_first_of compares characters using operator== or a user-provided function object, while this member function uses traits::eq. Returns the smallest character position N such that pos <= N < size(), and such that (*this)[N]

compares equal to some character within s. Returns npos if no such character position exists.

size_type find_first_of(const charT* s, size_type pos, size_type n) const Searches within *this, beginning at pos, for the first character that is equal to any character within the range [s, s+n). That is, returns the smallest character position N such that pos <= N < size(), and such that (*this)[N]

compares equal to some character in [s, s+n). Returns npos if no such character position exists.

size_type find_first_of(const charT* s, size_type pos = 0) const Equivalent to find_first_of(s, pos, traits::length(s)).

 

size_type find_first_of(charT c, size_type pos = 0) const Equivalent to find(c, pos).
size_type find_first_not_of(const basic_string& s, size_type pos = 0) const

 

Searches within *this, beginning at pos, for the first character that is not equal to any character within s. Returns the smallest character position N such that pos <= N < size(), and such that (*this)[N]

does not compare equal to any character within s. Returns npos if no such character position exists.

size_type find_first_not_of(const charT* s, size_type pos, size_type n) const Searches within *this, beginning at pos, for the first character that is not equal to any character within the range [s, s+n). That is, returns the smallest character position N such that pos <= N < size(), and such that (*this)[N]

does not compare equal to any character in [s, s+n). Returns npos if no such character position exists.

size_type find_first_not_of(const charT* s, size_type pos = 0) const Equivalent to find_first_not_of(s, pos, traits::length(s)).

 

size_type find_first_not_of(charT c, size_type pos = 0) const Returns the smallest character position N such that pos <= N < size(), and such that (*this)[N]

does not compare equal to c. Returns npos if no such character position exists.

size_type find_last_of(const basic_string& s, size_type pos = npos) const

Searches backward within *this for the first character that is equal to any character within s. That is, returns the largest character position N such that N <= pos and N < size(), and such that (*this)[N] compares equal to some character within s. Returns npos if no such character position exists.

 

size_type find_last_of(const charT* s, size_type pos, size_type n) const Searches backward within *this for the first character that is equal to any character within the range [s, s+n). That is, returns the largest character position N such that N <= pos and N < size(), and such that (*this)[N] compares equal to some character within [s, s+n). Returns npos if no such character position exists.

 

size_type find_last_of(const charT* s, size_type pos = npos) const Equivalent to find_last_of(s, pos, traits::length(s)).
size_type find_last_of(charT c, size_type pos = npos) const

 

Equivalent to rfind(c, pos).
size_type find_last_not_of(const basic_string& s, size_type pos = npos) const Searches backward within *this for the first character that is not equal to any character within s. That is, returns the largest character position N such that N <= pos and N < size(), and such that (*this)[N] does not compare equal to any character within s. Returns npos if no such character position exists.

 

size_type find_last_not_of(const charT* s, size_type pos, size_type n) const Searches backward within *this for the first character that is not equal to any character within [s, s+n). That is, returns the largest character position N such that N <= pos and N < size(), and such that (*this)[N] does not compare equal to any character within [s, s+n). Returns npos if no such character position exists.

 

size_type find_last_not_of(const charT* s, size_type pos = npos) const Equivalent to find_last_of(s, pos, traits::length(s)).
size_type find_last_not_of(charT c, size_type pos = npos) const

 

Searches backward *this for the first character that is not equal to c. That is, returns the largest character position N such that N <= pos and N < size(), and such that (*this)[N] does not compare equal to c.

 

basic_string substr(size_type pos = 0, size_type n = npos) const Equivalent to basic_string(*this, pos, n).
int compare(const basic_string& s) const

 

Three-way lexicographical comparison of s and *this, much like strcmp. If traits::compare(data, s.data(), min(size(), s.size())) is nonzero, then it returns that nonzero value. Otherwise returns a negative number if size() < s.size(), a positive number if size() > s.size(), and zero if the two are equal.

 

int compare(size_type pos, size_type n, const basic_string& s) const Three-way lexicographical comparison of s and a substring of *this. Equivalent to basic_string(*this, pos, n).compare(s).

 

int compare(size_type pos, size_type n, const basic_string& s, size_type pos1, size_type n1) const Three-way lexicographical comparison of a substring of s and a substring of *this. Equivalent to basic_string(*this, pos, n).compare(basic_string(s, pos1, n1)).

 

int compare(const charT* s) const Three-way lexicographical comparison of s and *this. Equivalent to compare(basic_string(s)).
int compare(size_type pos, size_type n, const charT* s, size_type len = npos) const Three-way lexicographical comparison of the first min(len, traits::length(s) characters of s and a substring of *this. Equivalent to basic_string(*this, pos, n).compare(basic_string(s, min(len, traits::length(s)))).

 

template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const basic_string<charT, traits, Alloc>& s2)
String concatenation. Equivalent to creating a temporary copy of s, appending s2, and then returning the temporary copy. 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>

operator+(const charT* s1,
          const basic_string<charT, traits, Alloc>& s2)
String concatenation. Equivalent to creating a temporary basic_string object from s1, appending s2, and then returning the temporary object. 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const charT* s2)
String concatenation. Equivalent to creating a temporary copy of s, appending s2, and then returning the temporary copy.

 

template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(charT c,
          const basic_string<charT, traits, Alloc>& s2)
String concatenation. Equivalent to creating a temporary object with the constructor basic_string(1, c), appending s2, and then returning the temporary object. 
template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>

operator+(const basic_string<charT, traits, Alloc>& s1,
          charT c)
String concatenation. Equivalent to creating a temporary object, appending c with push_back, and then returning the temporary object.

 

template <class charT, class traits, class Alloc>
bool operator==(const charT* s1, 
                const basic_string<charT, traits, Alloc>& s2)
String equality. Equivalent to basic_string(s1).compare(s2) == 0. 
template <class charT, class traits, class Alloc>
bool operator==(const basic_string<charT, traits, Alloc>& s1,
                const charT* s2)
String equality. Equivalent to basic_string(s1).compare(s2) == 0. 
template <class charT, class traits, class Alloc>
bool operator!=(const charT* s1, 
                const basic_string<charT, traits, Alloc>& s2)
String inequality. Equivalent to basic_string(s1).compare(s2) == 0. 
template <class charT, class traits, class Alloc>
bool operator!=(const basic_string<charT, traits, Alloc>& s1,
                const charT* s2)
String inequality. Equivalent to !(s1 == s2).

 

template <class charT, class traits, class Alloc>
bool operator<(const charT* s1, 
               const basic_string<charT, traits, Alloc>& s2)
String comparison. Equivalent to !(s1 == s2).

 

template <class charT, class traits, class Alloc>
bool operator<(const basic_string<charT, traits, Alloc>& s1,
               const charT* s2)
String comparison. Equivalent to !(s1 == s2).

 

template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
           basic_string<charT, traits, Alloc>& s)
Reads s from the input stream is. Specifically, it skips whitespace, and then replaces the contents of s with characters read from the input stream. It continues reading characters until it encounters a whitespace character (in which case that character is not extracted), or until end-of-file, or, if is.width() is nonzero, until it has read is.width() characters. This member function resets is.width() to zero.

 

template <class charT, class traits, class Alloc>
basic_ostream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
           const basic_string<charT, traits, Alloc>& s)
Writes s to the output stream is. It writes max(s.size(), is.width()) characters, padding as necessary. This member function resets is.width() to zero. 
template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Alloc>& s,
        charT delim)

 

Replaces the contents of s with characters read from the input stream. It continues reading characters until it encounters the character delim (in which case that character is extracted but not stored in s), or until end of file. Note that getline, unlike operator>>, does not skip whitespace. As the name suggests, it is most commonly used to read an entire line of text precisely as the line appears in an input file. 
template <class charT, class traits, class Alloc>
basic_istream<charT, traits>&
getline(basic_istream<charT, traits>& is,
        basic_string<charT, traits, Alloc>& s)

 

Equivalent to getline(is, s, is.widen('/n/)).

-- WinterWen - 03 Jul 2005

 
 
 
 
andylin02
关注
专栏目录
c++ basic_string 和string区别
mls805379973的博客
11-13 633
可以轻松地扩展到其他字符类型的字符串，而不仅限于。这样设计的好处是，通过使用模板类。模板类被设计为支持多种字符类型，而。是其中一种特定字符类型的字符串类。的一种特例，专门用于处理。的一个具体实例化，即。
cuda报错basic_string.tcc:1067:16: error: cannot call member function ‘void std::basic_string
最新发布
youzjuer的博客
04-26 63
本来在网络上找了很多办法，有说gcc版本需要6.x才行，但是6.x被centos的scl工具遗弃了，根本无法下载，后来才发现是是编译选项的问题。需要加一个-std=c++11。-I是指定依赖的库函数。
basic string
学海无涯
12-20 1225
basic_string Category: containers Description basic_string 是基于字符序列容器(Sequence)的模板类, 包含了说有序列容器的常用操作，同时也包含了字符串的标准操作，如"查找"和"合并" 。 basic_string 类是通过字符类型和类型的特征( Character Traits )来实例化的。但通常我们不直接使用
basic-string
weixin_48799254的博客
12-07 331
basic-string 定义 用引号引起来的字符，不可以被修改，只能从新创建 ”string” ’string’ ”””string””” ’’’string‘’’ 运算 加法：n1 = ’hello’ n2 = ’world’ n3 = n1 + n2 = ‘hello world’ 乘法：n1 = ‘a’ * 5 = ‘aaaaa’ 成员运算： A in B：A在B中，为True A not in B： A不在B中，为True 切片 索引：字符串是可迭代对象，从前往后索引值是从0开始的，从后往前索引值
C++ basic_string
hl156的博客
06-07 7883
basic_string 类 Visual Studio 2015 其他版本 Visual Studio 2013 Visual Studio 2012  若要了解有关 Visu...
C++之basic_string与string理解(一百三十七)
Android系统攻城狮
04-03 596
【代码】C++之basic_string与string用法区别(一百一三十七)
STL玄学：Basic_string的用法简介
MZW_BG的博客
10-17 4285
前言 众所周知，C++中的STL是万能强大的 除了调试时令人抓狂、自带超大常数之外，它用起来还是很方便的。 正片 据我观察，绝大多数的STL都只有在开启O2之后才能与手打数据结构取得相当的速度 但是一个东西除外： std::string 通常来说，在OJ上评测使用STL的代码运行时间是不使用STL的1.2~2倍 比如说priority_queue，也就是优先队列 在洛谷P……单源最短路径 ...
basic_string源码
08-05
basic_string源码详解 basic_string是C++标准库中一个非常重要的类，它提供了字符串处理的功能。在本文中，我们将深入探讨basic_string的源码，了解它的实现机制和内部数据结构。 basic_string的内部数据结构 ...
c++:错误：undefined reference to `std::__cxx11::basic_string＜char, std::char_traits＜char＞,
mzhan017的博客
11-19 6981
编译出错的命令 g++ thread.cpp 代码 #include <iostream> #include <thread> using namespace std; int main(); class abc { friend int print(); protected: string m_string; public: string get(); }; string abc::get() { return m_string; }
boost::basic_string_view的应用实例和源码解析
qq_37934722的博客
08-25 279
在实际开发中，有时候使用std::string操作字符串会带来一些不必要的开销，而使用boost::basic_string_view则可以避免这个问题。在boost库中，boost::basic_string_view是通过一个指向字符数组的指针和一个长度来实现的，它不拥有这个字符数组，只是对其进行了引用，因此也不能修改这个数组。从上面的代码中可以看出，使用std::string和boost::basic_string_view操作字符串的方式略有不同，但都能够有效地做到字符串的操作。
C++中为string为何叫basic_string＜char＞
Pass-by
02-23 2289
//假设下面是basic_string类的定义（不用关系它定义是否完整），那么就有一个疑问？ //难道字符串的还有不同的类型吗？需要使用模版 template <class T> class basic_string { private: T* _str; //... }; 这里就需要了解一下编码： 编码的由来： 计算机只能计算和识别二进制，必须让计算机识别文字，才能和计算机进行交互，彼此也才能通过计算机通信。 由此，有了ASCII编码的诞生，它起始于50年代后期，在1967年定案，是.
c++ basic_strings
125096
04-30 2510
通用字符串类 该basic_string的是String类的任何字符类型（见字符串描述）的泛化。 模板参数 图表 字符类型。 该字符串是通过这种类型的字符序列形成的。 这应是一个非数组POD类型。 性状 性格特征类定义了basic_string的对象（见char_traits）用字的基本属性。 特点:: char_type应是一样的图表。 别名为成员类型的basic_string::的trait
STL之basic_string
https://gitcode.net/liuyuan185442111
05-20 6742
basic_string在basic_string.h中定义，部分成员函数在basic_string.tcc中定义。
VB中String的用法及原理
热门推荐
石头记
04-15 2万+
    在各种不同开发语言中,字符串类型显然是最常见,也是最常用的。     常用代表它最易用，是这样吗？未必，越简单，越普通，你会忽视，内里隐藏着的陷井更容易使你中招。它往往是绊脚石，或者程序中性能的瓶颈。     本身,我对VB语言及相关应用并不太熟，只不过近期编码用到，有些体会。一: 先来总结一下,常用编程语言的字串表达方式: C:      char(wchat_t) * 或 []:  字
⚡【C++要笑着学】(16) String类：编码的由来 | basic_string 模板类 | string类的常用接口讲解 | 学会查文档
有道无术, 术尚可求。有术无道, 止于术。
04-28 3819
本章将介绍 string 类，在 string 讲解之前会补充一些知识点，比如 basic_string 和字符编码等。string 类的东西太多了，全部介绍一遍似乎不太现实，所以我们将介绍 string 常用的接口函数。如果以后需要用到一些接口函数，要学会查文档，现查现用的技能。
如何解决basic_string::_M_create错误？
两天宇宙人的博客
10-20 6090
????原因   原因在于使用string(iter1, iter2)这个构造函数时，iter1>iter2。 #include <string> #include <iostream> #include <algorithm> using namespace std; int main() { try{ string s("abc"); ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值