STLリファレンス

<string>

ヘッダ<string>に定義された文字列クラスbasic_stringはSTLに含まれてはいません。が、プログラムの中でchar*の代わりに非常によく使われるのでここに紹介しておきます。

標準C++での文字列basic_stringは、いわゆる"文字"の並びをいうイメージがずいぶんと希薄になっています。というのも、"文字"の型をtemplate引数として与えることで、どんなものでも文字列として扱えるように作られているからです。

8bit ANSI文字列ならば: typedef basic_string< char, char_traits<char>, allocator<char> > string;

16bitのUNICODE文字列は:

  typedef basic_string< wchar_t,
                        char_traits<wchar_t>,
                        allocator<wchar_t> >
  wstring;
とtypedefされています。

このように、標準C++の提供するbasic_stringは、文字列というより、任意の型の要素を連続領域に保持するvectorに近いように感じられます。vector(配列)と異なる点は:

などが挙げられます。このような列の要素の特性を決定しているのがbasic_stringの第2テンプレート引数char_traitsです。

[basic_string]

  template<class charT, class traits = char_traits<charT>,
           class Allocator = allocator<charT> >
  class basic_string {
  public:
    //  types:
    typedef          traits                       traits_type;
    typedef typename traits::char_type            value_type;
    typedef          Allocator                    allocator_type;
    typedef typename Allocator::size_type         size_type;
    typedef typename Allocator::difference_type   difference_type;
    typedef typename Allocator::reference         reference;
    typedef typename Allocator::const_reference   const_reference;
    typedef typename Allocator::pointer           pointer;
    typedef typename Allocator::const_pointer     const_pointer;
    typedef implementation defined                iterator;
    typedef implementation defined                const_iterator;
    typedef std::reverse_iterator<iterator>       reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    static const size_type npos = -1;

    //  lib.string.cons construct/copy/destroy:
    explicit basic_string(const Allocator& a = Allocator());
    basic_string(const basic_string& str, size_type pos = 0,
                 size_type n = npos, const Allocator& a = Allocator());
    basic_string(const charT* s,
                 size_type n, const Allocator& a = Allocator());
    basic_string(const charT* s, const Allocator& a = Allocator());
    basic_string(size_type n, charT c, const Allocator& a = Allocator());
    template<class InputIterator>
      basic_string(InputIterator begin, InputIterator end,
                   const Allocator& a = Allocator());
   ~basic_string();
    basic_string& operator=(const basic_string& str);
    basic_string& operator=(const charT* s);
    basic_string& operator=(charT c);

    //  lib.string.iterators iterators:
    iterator               begin();
    const_iterator         begin() const;
    iterator               end();
    const_iterator         end() const;
    reverse_iterator       rbegin();
    const_reverse_iterator rbegin() const;
    reverse_iterator       rend();
    const_reverse_iterator rend() const;

    //  lib.string.capacity capacity:
    size_type size() const;
    size_type length() const;
    size_type max_size() const;
    void      resize(size_type n, charT c);
    void      resize(size_type n);
    size_type capacity() const;
    void      reserve(size_type res_arg = 0);
    void      clear();
    bool      empty() const;

    //  lib.string.access element access:
    const_reference operator[](size_type pos) const;
    reference       operator[](size_type pos);
    const_reference at(size_type n) const;
    reference       at(size_type n);

    //  lib.string.modifiers modifiers:
    basic_string& operator+=(const basic_string& str);
    basic_string& operator+=(const charT* s);
    basic_string& operator+=(charT c);
    basic_string& append(const basic_string& str);
    basic_string& append(const basic_string& str, size_type pos,
                         size_type n);
    basic_string& append(const charT* s, size_type n);
    basic_string& append(const charT* s);
    basic_string& append(size_type n, charT c);
    template<class InputIterator>
      basic_string& append(InputIterator first, InputIterator last);
    void          push_back(const charT);
    basic_string& assign(const basic_string&);
    basic_string& assign(const basic_string& str, size_type pos,
                         size_type n);
    basic_string& assign(const charT* s, size_type n);
    basic_string& assign(const charT* s);
    basic_string& assign(size_type n, charT c);
    template<class InputIterator>
      basic_string& assign(InputIterator first, InputIterator last);
    basic_string& insert(size_type pos1, const basic_string& str);
    basic_string& insert(size_type pos1, const basic_string& str,
                         size_type pos2, size_type n);
    basic_string& insert(size_type pos, const charT* s, size_type n);
    basic_string& insert(size_type pos, const charT* s);
    basic_string& insert(size_type pos, size_type n, charT c);
    iterator      insert(iterator p, charT c);
    void          insert(iterator p, size_type n, charT c);
    template<class InputIterator>
      void insert(iterator p, InputIterator first, InputIterator last);
    basic_string& erase(size_type pos = 0, size_type n = npos);
    iterator      erase(iterator position);
    iterator      erase(iterator first, iterator last);
    basic_string& replace(size_type pos1, size_type n1,
                          const basic_string& str);
    basic_string& replace(size_type pos1, size_type n1,
                          const basic_string& str,
                          size_type pos2, size_type n2);
    basic_string& replace(size_type pos, size_type n1,
                          const charT* s, size_type n2);
    basic_string& replace(size_type pos, size_type n1,
                          const charT* s);
    basic_string& replace(size_type pos, size_type n1, size_type n2,
                          charT c);
    basic_string& replace(iterator i1, iterator i2,
                          const basic_string& str);
    basic_string& replace(iterator i1, iterator i2,
                          const charT* s, size_type n);
    basic_string& replace(iterator i1, iterator i2, const charT* s);
    basic_string& replace(iterator i1, iterator i2, size_type n,
                          charT c);
    template<class InputIterator>
      basic_string& replace(iterator i1, iterator i2,
                            InputIterator j1, InputIterator j2);
    size_type copy(charT* s, size_type n, size_type pos = 0) const;
    void      swap(basic_string<charT,traits,Allocator>&);

    //  lib.string.ops string operations:
    const charT*   c_str() const;         //  explicit
    const charT*   data() const;
    allocator_type get_allocator() const;

    size_type find(const basic_string& str, size_type pos = 0) const;
    size_type find(const charT* s, size_type pos, size_type n) const;
    size_type find(const charT* s, size_type pos = 0) const;
    size_type find(charT c, size_type pos = 0) const;
    size_type rfind(const basic_string& str, size_type pos = npos) const;
    size_type rfind(const charT* s, size_type pos, size_type n) const;
    size_type rfind(const charT* s, size_type pos = npos) const;
    size_type rfind(charT c, size_type pos = npos) const;
    size_type find_first_of(const basic_string& str,
                            size_type pos = 0) const;
    size_type find_first_of(const charT* s, size_type pos,
                            size_type n) const;
    size_type find_first_of(const charT* s, size_type pos = 0) const;
    size_type find_first_of(charT c, size_type pos = 0) const;
    size_type find_last_of(const basic_string& str,
                           size_type pos = npos) const;
    size_type find_last_of(const charT* s, size_type pos,
                           size_type n) const;
    size_type find_last_of(const charT* s, size_type pos = npos) const;
    size_type find_last_of(charT c, size_type pos = npos) const;
    size_type find_first_not_of(const basic_string& str,
                                size_type pos = 0) const;
    size_type find_first_not_of(const charT* s, size_type pos,
                                size_type n) const;
    size_type find_first_not_of(const charT* s, size_type pos = 0) const;
    size_type find_first_not_of(charT c, size_type pos = 0) const;
    size_type find_last_not_of (const basic_string& str,
                                size_type pos = npos) const;
    size_type find_last_not_of (const charT* s, size_type pos,
                                size_type n) const;
    size_type find_last_not_of (const charT* s,
                                size_type pos = npos) const;
    size_type find_last_not_of (charT c, size_type pos = npos) const;
    basic_string substr(size_type pos = 0, size_type n = npos) const;
    int compare(const basic_string& str) const;
    int compare(size_type pos1, size_type n1,
                const basic_string& str) const;
    int compare(size_type pos1, size_type n1, const basic_string& str,
                size_type pos2, size_type n2) const;
    int compare(const charT* s) const;
    int compare(size_type pos1, size_type n1, const charT* s,
                size_type n2 = npos) const;

  };

[basic_stringのメソッド]

- コンストラクタ/デストラクタ - オペレータ -イテレータ

basic_stringは文字のコンテナとしての側面を持っています。すなわち、basic_stringが内包する文字を順番にたどるイテレータを提供することでSTLのアルゴリズムをそのまま適用することができます。たとえばbasic_stringは大文字から小文字への変換メソッドのたぐいは定義されていないのですが、アルゴリズムtransformを使って簡単に実現できます:

 string s;
 transform(s.begin(), s.end(), s.begin(), tolower);
- append/assign

operator+=(),operator=()と同様ですが、より細かな指定が可能なメソッドを提供します。

-比較

比較メソッドcompareは文字列全体の比較だけではなく、部分文字列の比較が可能なメソッドを提供します。

-削除

文字列中の特定の部分を削除します。

- 検索 - 挿入と置換 - 部分文字列と交換 - 領域と長さ

basic_stringは文字列の長さの変化に伴う領域の確保/解放の回数を減らすため、ある程度の余裕を持った領域をまとめて確保/開放します。

- その他