`basic_string` Třída

Článek
10/12/2023

Sekvence řízené objektem typu basic_string jsou standardní třída řetězce C++ a označují se jako řetězce, ale neměly by se zaměňovat s řetězci ve stylu C++, které se používají v rámci standardní knihovny jazyka C++. Standardní řetězec C++ je kontejner, který umožňuje použití řetězců jako normálních typů, jako jsou operace porovnání a zřetězení, iterátory, algoritmy standardní knihovny C++ a kopírování a přiřazování s pamětí spravovanou alokátorem třídy. Pokud potřebujete převést řetězec Standard C++ na řetězec ve stylu C s hodnotou null, použijte člena basic_string::c_str .

Syntaxe

template <class CharType, class Traits = char_traits<CharType>, class Allocator = allocator<CharType>>
class basic_string;

Parametry

CharType
Datový typ jednoho znaku, který má být uložen v řetězci. Standardní knihovna jazyka C++ poskytuje specializace této šablony třídy s definicemi string typů pro prvky typu char, wstringpro , u16string pro wchar_tchar16_ta u32string pro char32_t.

Traits
Různé důležité vlastnosti CharType prvků v basic_string specializace jsou popsány třídou Traits. Výchozí hodnota je char_traits<CharType>.

Allocator
Typ představující uložený objekt alokátoru, který zapouzdřuje podrobnosti o přidělení a uvolnění paměti řetězce. Výchozí hodnota je allocator<CharType>.

Konstruktory

Konstruktor	Popis
`basic_string`	Vytvoří řetězec, který je prázdný nebo inicializovaný určitými znaky nebo je kopií celého nebo části jiného objektu řetězce nebo řetězce C.

Typedefs

Název typu	Popis
`allocator_type`	Typ, který představuje `allocator` třídu pro objekt string.
`const_iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může přistupovat k prvku v řetězci a číst ho `const` .
`const_pointer`	Typ, který poskytuje ukazatel na `const` prvek v řetězci.
`const_reference`	Typ, který poskytuje odkaz na `const` prvek uložený v řetězci pro čtení a provádění `const` operací.
`const_reverse_iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může číst libovolný `const` prvek v řetězci.
`difference_type`	Typ, který poskytuje rozdíl mezi dvěma iterátory, které odkazují na prvky ve stejném řetězci.
`iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může číst nebo upravovat libovolný prvek v řetězci.
`npos`	Celočíselnou hodnotu bez znaménka inicializovanou na -1, která označuje buď "nenalezena", nebo "všechny zbývající znaky" v případě selhání vyhledávací funkce.
`pointer`	Typ, který poskytuje ukazatel na prvek znaku v řetězci nebo matici znaků.
`reference`	Typ, který poskytuje odkaz na prvek uložený v řetězci.
`reverse_iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může číst nebo upravovat prvek v obráceném řetězci.
`size_type`	Celočíselný typ bez znaménka pro počet prvků v řetězci.
`traits_type`	Typ pro vlastnosti znaků prvků uložených v řetězci.
`value_type`	Typ, který představuje typ znaků uložených v řetězci.

Členské funkce

Členová funkce	Popis
`append`	Přidá znaky na konec řetězce.
`assign`	Přiřadí nové hodnoty znaků k obsahu řetězce.
`at`	Vrátí odkaz na prvek v zadaném umístění v řetězci.
`back`
`begin`	Vrátí iterátor adresování prvního prvku v řetězci.
`c_str`	Převede obsah řetězce jako řetězec ve stylu C, null-terminated, string.
`capacity`	Vrátí největší počet prvků, které by mohly být uloženy v řetězci bez zvýšení přidělení paměti řetězce.
`cbegin`	Vrátí konstantní iterátor adresování prvního prvku v řetězci.
`cend`	Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v řetězci.
`clear`	Vymaže všechny prvky řetězce.
`compare`	Porovná řetězec se zadaným řetězcem a určí, jestli jsou dva řetězce stejné nebo jestli je jeden lexikálně menší než druhý.
`copy`	Zkopíruje maximálně zadaný počet znaků z indexované pozice ve zdrojovém řetězci do cílového pole znaků. Zastaralé Místo toho použijte `basic_string::_Copy_s`.
`crbegin`	Vrátí iterátor const, který řeší první prvek v obráceném řetězci.
`crend`	Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v obráceném řetězci.
`_Copy_s`	Specifické pro Microsoft: Zkopíruje maximálně zadaný počet znaků z indexované pozice ve zdrojovém řetězci do cílového pole znaků.
`data`	Převede obsah řetězce na pole znaků.
`empty`	Testuje, zda řetězec obsahuje znaky.
`end`	Vrátí iterátor, který řeší umístění úspěšného posledního prvku v řetězci.
`ends_with`^C++20	Zkontroluje, jestli řetězec končí zadanou příponou.
`erase`	Odebere prvek nebo rozsah prvků v řetězci ze zadané pozice.
`find`	Vyhledá řetězec ve směru dopředu pro první výskyt podřetězce, který odpovídá zadané sekvenci znaků.
`find_first_not_of`	Vyhledá řetězec prvního znaku, který není žádným prvkem zadaného řetězce.
`find_first_of`	Vyhledá řetězec prvního znaku, který odpovídá libovolnému prvku zadaného řetězce.
`find_last_not_of`	Vyhledá řetězec posledního znaku, který není žádným prvkem zadaného řetězce.
`find_last_of`	Vyhledá řetězec posledního znaku, který je prvkem zadaného řetězce.
`front`	Vrátí odkaz na první prvek v řetězci.
`get_allocator`	Vrátí kopii objektu `allocator` použitého k vytvoření řetězce.
`insert`	Vloží prvek, několik prvků nebo rozsah prvků do řetězce na zadané pozici.
`length`	Vrátí aktuální počet prvků v řetězci.
`max_size`	Vrátí maximální počet znaků, které může řetězec obsahovat.
`pop_back`	Vymaže poslední prvek řetězce.
`push_back`	Přidá prvek na konec řetězce.
`rbegin`	Vrátí iterátor na první prvek v obráceném řetězci.
`rend`	Vrátí iterátor, který odkazuje těsně za posledním prvkem v obráceném řetězci.
`replace`	Nahradí prvky v řetězci na zadané pozici zadanými znaky nebo znaky zkopírovanými z jiných oblastí nebo řetězců nebo řetězců jazyka C.
`reserve`	Nastaví kapacitu řetězce na číslo alespoň tak velké jako zadané číslo.
`resize`	Určuje novou velikost řetězce, připojení nebo mazání prvků podle potřeby.
`rfind`	Vyhledá řetězec v zpětném směru pro první výskyt podřetězce, který odpovídá zadané sekvenci znaků.
`shrink_to_fit`	Zahodí nadbytečnou kapacitu řetězce.
`size`	Vrátí aktuální počet prvků v řetězci.
`starts_with`^C++20	Zkontroluje, jestli řetězec začíná zadanou předponou.
`substr`	Zkopíruje podřetězce nejvýše určitého počtu znaků z řetězce začínajícího od zadané pozice.
`swap`	Vyměňte obsah dvou řetězců.

Operátory

Operátor	Popis
`operator+=`	Připojí znaky k řetězci.
`operator=`	Přiřadí nové hodnoty znaků k obsahu řetězce.
`operator[]`	Poskytuje odkaz na znak se zadaným indexem v řetězci.

Literály

Hlavičky, které definují basic_string také následující uživatelsky definované literály, které vytvoří řetězec zadaného typu ze vstupních parametrů.

Deklarace	Popis
`inline string operator"" s(const char* str, size_t len)`	Vrací: `string(str, len)`
`inline string operator"" s(const wchar_t* str, size_t len)`	Vrací: `wstring(str, len)`
`inline basic_string<char8_t> operator"" s(const char8_t* str, size_t len)`	Vrací: `basic_string<char8_t>(str, len)`
`inline u16string operator"" s(const char16_t* str, size_t len)`	Vrací: `u16string(str, len)`
`inline u32string operator"" s(const char32_t* str, size_t len)`	Vrací: `u32string(str, len)`

Poznámky

Pokud je funkce požádána o vygenerování sekvence delší než max_size prvky, funkce hlásí chybu délky vyvoláním objektu typu length_error.

Odkazy, ukazatele a iterátory, které určují prvky řízené sekvence, mohou být neplatné po každém volání funkce, která mění řízenou sekvenci nebo po prvním volání nečlenovéconst funkce.

Požadavky

Header:<string>

Namespace: std

`basic_string::allocator_type`

Typ, který představuje třídu alokátoru pro objekt string.

typedef Allocator allocator_type;

Poznámky

Typ je synonymem pro parametr Allocatoršablony .

Příklad

// basic_string_allocator_type.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects
   // that use the default allocator.
   string s1;
   basic_string <char>::allocator_type xchar = s1.get_allocator( );
   // You can now call functions on the allocator class xchar used by s1
}

`basic_string::append`

Přidá znaky na konec řetězce.

basic_string<CharType, Traits, Allocator>& append(
    const value_type* ptr);

basic_string<CharType, Traits, Allocator>& append(
    const value_type* ptr,
    size_type count);

basic_string<CharType, Traits, Allocator>& append(
    const basic_string<CharType, Traits, Allocator>& str,
    size_type offset,
    size_type count);

basic_string<CharType, Traits, Allocator>& append(
    const basic_string<CharType, Traits, Allocator>& str);

basic_string<CharType, Traits, Allocator>& append(
    size_type count,
    value_type char_value);

template <class InputIterator>
basic_string<CharType, Traits, Allocator>& append(
    InputIterator first,
    InputIterator last);

basic_string<CharType, Traits, Allocator>& append(
    const_pointer first,
    const_pointer last);

basic_string<CharType, Traits, Allocator>& append(
    const_iterator first,
    const_iterator last);

Parametry

ptr
Řetězec jazyka C, který se má připojit.

str
Řetězec, jehož znaky mají být připojeny.

offset
Index části zdrojového řetězce poskytujícího znaky, které mají být připojeny.

count
Maximální počet znaků, které se mají připojit ze zdrojového řetězce.

char_value
Hodnota znaku, která má být připojena.

first
Vstupní iterátor adresovaný prvním prvkem v rozsahu, který se má připojit.

last
Vstupní iterátor nebo const_iterator adresování pozice jednoho za posledním prvkem v rozsahu, const_pointerkterý se má připojit.

Vrácená hodnota

Odkaz na objekt řetězce, který je připojen se znaky předané členské funkce.

Poznámky

Znaky mohou být připojeny k řetězci pomocí operator+= členské funkce append nebo push_back. operator+= připojí hodnoty s jedním argumentem, zatímco členová funkce s více argumenty append umožňuje zadat konkrétní část řetězce pro přidání.

Příklad

// basic_string_append.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function
   // appending a C-string to a string
   string str1a ( "Hello " );
   cout << "The original string str1 is: " << str1a << endl;
   const char *cstr1a = "Out There ";
   cout << "The C-string cstr1a is: " << cstr1a << endl;
   str1a.append ( cstr1a );
   cout << "Appending the C-string cstr1a to string str1 gives: "
        << str1a << "." << endl << endl;

   // The second member function
   // appending part of a C-string to a string
   string str1b ( "Hello " );
   cout << "The string str1b is: " << str1b << endl;
   const char *cstr1b = "Out There ";
   cout << "The C-string cstr1b is: " << cstr1b << endl;
   str1b.append ( cstr1b , 3 );
   cout << "Appending the 1st part of the C-string cstr1b "
        << "to string str1 gives: " << str1b << "."
        << endl << endl;

   // The third member function
   // appending part of one string to another
   string str1c ( "Hello " ), str2c ( "Wide World " );
   cout << "The string str2c is: " << str2c << endl;
   str1c.append ( str2c , 5 , 5 );
   cout << "The appended string str1 is: "
        << str1c << "." << endl << endl;

   // The fourth member function
   // appending one string to another in two ways,
   // comparing append and operator [ ]
   string str1d ( "Hello " ), str2d ( "Wide " ), str3d ( "World " );
   cout << "The  string str2d is: " << str2d << endl;
   str1d.append ( str2d );
   cout << "The appended string str1d is: "
        << str1d << "." << endl;
   str1d += str3d;
   cout << "The doubly appended strig str1 is: "
        << str1d << "." << endl << endl;

   // The fifth member function
   // appending characters to a string
   string str1e ( "Hello " );
   str1e.append ( 4 , '!' );
   cout << "The string str1 appended with exclamations is: "
        << str1e << endl << endl;

   // The sixth member function
   // appending a range of one string to another
   string str1f ( "Hello " ), str2f ( "Wide World " );
   cout << "The string str2f is: " << str2f << endl;
   str1f.append ( str2f.begin ( ) + 5 , str2f.end ( ) - 1 );
   cout << "The appended string str1 is: "
        << str1f << "." << endl << endl;
}

The original string str1 is: Hello
The C-string cstr1a is: Out There
Appending the C-string cstr1a to string str1 gives: Hello Out There .

The string str1b is: Hello
The C-string cstr1b is: Out There
Appending the 1st part of the C-string cstr1b to string str1 gives: Hello Out.

The string str2c is: Wide World
The appended string str1 is: Hello World.

The  string str2d is: Wide
The appended string str1d is: Hello Wide .
The doubly appended strig str1 is: Hello Wide World .

The string str1 appended with exclamations is: Hello !!!!

The string str2f is: Wide World
The appended string str1 is: Hello World.

`basic_string::assign`

Přiřadí nové hodnoty znaků k obsahu řetězce.

basic_string<CharType, Traits, Allocator>& assign(
    const value_type* ptr);

basic_string<CharType, Traits, Allocator>& assign(
    const value_type* ptr,
    size_type count);

basic_string<CharType, Traits, Allocator>& assign(
    const basic_string<CharType, Traits, Allocator>& str,
    size_type off,
    size_type count);

basic_string<CharType, Traits, Allocator>& assign(
    const basic_string<CharType, Traits, Allocator>& str);

basic_string<CharType, Traits, Allocator>& assign(
    size_type count,
    value_type char_value);

template <class InIt>
basic_string<CharType, Traits, Allocator>& assign(
    InputIterator first,
    InputIterator last);

basic_string<CharType, Traits, Allocator>& assign(
    const_pointer first,
    const_pointer last);

basic_string<CharType, Traits, Allocator>& assign(
    const_iterator first,
    const_iterator last);

Parametry

ptr
Ukazatel na znaky řetězce C, které mají být přiřazeny cílovému řetězci.

count
Počet znaků, které se mají přiřadit, ze zdrojového řetězce.

str
Zdrojový řetězec, jehož znaky mají být přiřazeny k cílovému řetězci.

char_value
Hodnota znaku, která má být přiřazena.

first
Vstupní iterátor, const_pointer nebo const_iterator adresování prvního znaku v rozsahu zdrojového řetězce, který se má přiřadit k cílové oblasti.

last
Vstupní iterátor, const_pointer nebo const_iterator adresování jednoho za posledním znakem v rozsahu zdrojového řetězce, který se má přiřadit cílové oblasti.

off
Pozice, ve které se začnou přiřazovat nové znaky.

Vrácená hodnota

Odkaz na objekt řetězce, který je přiřazen nové znaky členské funkce.

Poznámky

Řetězce mohou být přiřazeny nové hodnoty znaků. Nová hodnota může být řetězec a řetězec C nebo jeden znak. Může operator= se použít, pokud je možné novou hodnotu popsat jedním parametrem; jinak členová funkce assign, která má více parametrů, lze použít k určení, která část řetězce má být přiřazena k cílovému řetězci.

Příklad

// basic_string_assign.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function assigning the
   // characters of a C-string to a string
   string str1a;
   const char *cstr1a = "Out There";
   cout << "The C-string cstr1a is: " << cstr1a <<  "." << endl;
   str1a.assign ( cstr1a );
   cout << "Assigning the C-string cstr1a to string str1 gives: "
        << str1a << "." << endl << endl;

   // The second member function assigning a specific
   // number of the of characters a C-string to a string
   string  str1b;
   const char *cstr1b = "Out There";
   cout << "The C-string cstr1b is: " << cstr1b << endl;
   str1b.assign ( cstr1b , 3 );
   cout << "Assigning the 1st part of the C-string cstr1b "
        << "to string str1 gives: " << str1b << "."
        << endl << endl;

   // The third member function assigning a specific number
   // of the characters from one string to another string
   string str1c ( "Hello " ), str2c ( "Wide World " );
   cout << "The string str2c is: " << str2c << endl;
   str1c.assign ( str2c , 5 , 5 );
   cout << "The newly assigned string str1 is: "
        << str1c << "." << endl << endl;

   // The fourth member function assigning the characters
   // from one string to another string in two equivalent
   // ways, comparing the assign and operator =
   string str1d ( "Hello" ), str2d ( "Wide" ), str3d ( "World" );
   cout << "The original string str1 is: " << str1d << "." << endl;
   cout << "The string str2d is: " << str2d << endl;
   str1d.assign ( str2d );
   cout << "The string str1 newly assigned with string str2d is: "
        << str1d << "." << endl;
   cout << "The string str3d is: " << str3d << "." << endl;
   str1d = str3d;
   cout << "The string str1 reassigned with string str3d is: "
        << str1d << "." << endl << endl;

   // The fifth member function assigning a specific
   // number of characters of a certain value to a string
   string str1e ( "Hello " );
   str1e.assign ( 4 , '!' );
   cout << "The string str1 assigned with eclamations is: "
        << str1e << endl << endl;

   // The sixth member function assigning the value from
   // the range of one string to another string
   string str1f ( "Hello " ), str2f ( "Wide World " );
   cout << "The string str2f is: " << str2f << endl;
   str1f.assign ( str2f.begin ( ) + 5 , str2f.end ( ) - 1 );
   cout << "The string str1 assigned a range of string str2f is: "
        << str1f << "." << endl << endl;
}

The C-string cstr1a is: Out There.
Assigning the C-string cstr1a to string str1 gives: Out There.

The C-string cstr1b is: Out There
Assigning the 1st part of the C-string cstr1b to string str1 gives: Out.

The string str2c is: Wide World
The newly assigned string str1 is: World.

The original string str1 is: Hello.
The string str2d is: Wide
The string str1 newly assigned with string str2d is: Wide.
The string str3d is: World.
The string str1 reassigned with string str3d is: World.

The string str1 assigned with eclamations is: !!!!

The string str2f is: Wide World
The string str1 assigned a range of string str2f is: World.

`basic_string::at`

Poskytuje odkaz na znak se zadaným indexem v řetězci.

const_reference at(size_type offset) const;

reference at(size_type offset);

Parametry

offset
Index pozice prvku, na který se má odkazovat.

Vrácená hodnota

Odkaz na znak řetězce na pozici určené indexem parametru.

Poznámky

První prvek řetězce má index nuly a následující prvky jsou indexovány po sobě kladnými celými čísly, takže řetězec délky n má nth prvek indexovaný číslem n - 1.

Člen operator[] je rychlejší než členová funkce at pro poskytování přístupu ke čtení a zápisu k prvkům řetězce.

Člen operator[] nekontroluje, jestli je index předaný jako parametr platný, ale členová funkce at ano a proto by se měla použít v případě, že platnost není jistá. Neplatný index, což je index menší než nula nebo větší než nebo rovna velikosti řetězce, předaný členské funkci at vyvolá out_of_range výjimku třídy . Neplatný index předaný výsledkům operator[] nedefinovaného chování, ale index se rovná délce řetězce je platný index pro const řetězce a operátor při předání tohoto indexu vrátí znak null.

Vrácený odkaz může být zneplatněn řetězcovými relokacemi nebo úpravami neřetězcůconst .

Příklad

// basic_string_at.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ( "Hello world" ), str2 ( "Goodbye world" );
   const string  cstr1 ( "Hello there" ), cstr2 ( "Goodbye now" );
   cout << "The original string str1 is: " << str1 << endl;
   cout << "The original string str2 is: " << str2 << endl;

   // Element access to the non const strings
   basic_string <char>::reference refStr1 = str1 [6];
   basic_string <char>::reference refStr2 = str2.at ( 3 );

   cout << "The character with an index of 6 in string str1 is: "
        << refStr1 << "." << endl;
   cout << "The character with an index of 3 in string str2 is: "
        << refStr2 << "." << endl;

   // Element access to the const strings
   basic_string <char>::const_reference crefStr1 = cstr1 [ cstr1.length ( ) ];
   basic_string <char>::const_reference crefStr2 = cstr2.at ( 8 );

   if ( crefStr1 == '\0' )
      cout << "The null character is returned as a valid reference."
           << endl;
   else
      cout << "The null character is not returned." << endl;
   cout << "The character with index 8 in the const string cstr2 is: "
        << crefStr2 << "." << endl;
}

`basic_string::back`

Vrátí odkaz na poslední prvek v řetězci.

const_reference back() const;

reference back();

Vrácená hodnota

Odkaz na poslední prvek řetězce, který musí být neprázdný.

Poznámky

`basic_string::basic_string`

Vytvoří řetězec, který je prázdný, inicializovaný určitými znaky nebo je kopií celého řetězce nebo části jiného řetězcového objektu nebo stylu jazyka C (s ukončenou hodnotou null).

basic_string();

explicit basic_string(
    const allocator_type& alloc_type);

basic_string(
    const basic_string& right);

basic_string(
    basic_string&& right);

basic_string(
    const basic_string& right,
    size_type right_offset,
    size_type count = npos);

basic_string(
    const basic_string& right,
    size_type right_offset,
    size_type count,
    const allocator_type& alloc_type);

basic_string(
    const value_type* ptr,
    size_type count);

basic_string(
    const value_type* ptr,
    size_type count,
    const allocator_type& alloc_type);

basic_string(
    const value_type* ptr);

basic_string(
    const value_type* ptr,
    const allocator_type& alloc_type);

basic_string(
    size_type count,
    value_type char_value);

basic_string(
    size_type count,
    value_type char_value,
    const allocator_type& alloc_type);

template <class InputIterator>
basic_string(
    InputIterator first,
    InputIterator last);

template <class InputIterator>
basic_string(
    InputIterator first,
    InputIterator last,
    const allocator_type& alloc_type);

basic_string(
    const_pointer first,
    const_pointer last);

basic_string(
    const_iterator first,
    const_iterator last);

Parametry

ptr
Řetězec jazyka C, jehož znaky se mají použít k inicializaci vytvořeného objektu string . Tato hodnota nemůže být nulovým ukazatelem, pokud count není nula.

alloc_type
Třída alokátoru úložiště pro objekt řetězce, který je vytvořen.

count
Počet znaků, které se mají inicializovat.

right
Řetězec pro inicializaci vytvořeného řetězce.

right_offset
Index znaku v řetězci, který je prvním, který se použije k inicializaci hodnot znaků pro vytvořený řetězec.

char_value
Hodnota znaku, která se má zkopírovat do vytvořeného řetězce.

first
Vstupní iterátor, const_pointer nebo const_iterator adresování prvního prvku ve zdrojové oblasti, který se má vložit.

last
Vstupní iterátor, const_pointer nebo const_iterator adresování pozice za posledním prvkem ve zdrojovém rozsahu, který se má vložit.

Vrácená hodnota

Odkaz na objekt řetězce, který je vytvořen konstruktory.

Poznámky

Všechny konstruktory ukládají basic_string::allocator_type a inicializují řízenou sekvenci. Objekt alokátoru je argument al, pokud je k dispozici. Pro konstruktor kopírování je right.get_allocator()to volání basic_string::get_allocator. Jinak je alokátor Alloc().

Řízená sekvence se inicializuje na kopii sekvence operandu určené zbývajícími operandy. Konstruktor bez sekvence operandu určuje prázdnou počáteční řízenou sekvenci. Pokud InputIterator je celočíselného typu v konstruktoru šablony, pořadí first, last operandů se chová stejně jako (size_type) first, (value_type) last.

Příklad

// basic_string_ctor.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function initializing with a C-string
   const char *cstr1a = "Hello Out There.";
   basic_string <char> str1a ( cstr1a , 5);
   cout << "The string initialized by C-string cstr1a is: "
        << str1a << "." << endl;

   // The second member function initializing with a string
   string  str2a ( "How Do You Do" );
   basic_string <char> str2b ( str2a , 7 , 7 );
   cout << "The string initialized by part of the string cstr2a is: "
        << str2b << "." << endl;

   // The third member function initializing a string
   // with a number of characters of a specific value
   basic_string <char> str3a ( 5, '9' );
   cout << "The string initialized by five number 9s is: "
        << str3a << endl;

   // The fourth member function creates an empty string
   // and string with a specified allocator
   basic_string <char> str4a;
   string str4b;
   basic_string <char> str4c ( str4b.get_allocator( ) );
   if (str4c.empty ( ) )
      cout << "The string str4c is empty." << endl;
   else
      cout << "The string str4c is not empty." << endl;

   // The fifth member function initializes a string from
   // another range of characters
   string str5a ( "Hello World" );
   basic_string <char> str5b ( str5a.begin ( ) + 5 , str5a.end ( ) );
   cout << "The string initialized by another range is: "
        << str5b << "." << endl;
}

`basic_string::begin`

Vrátí iterátor adresování prvního prvku v řetězci.

const_iterator begin() const;

iterator begin();

Vrácená hodnota

Iterátor náhodného přístupu, který řeší první prvek sekvence nebo těsně za koncem prázdné sekvence.

Příklad

// basic_string_begin.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( ) {
   using namespace std;
   string str1 ( "No way out." ), str2;
   basic_string <char>::iterator strp_Iter, str1_Iter, str2_Iter;
   basic_string <char>::const_iterator str1_cIter;

   str1_Iter = str1.begin ( );
   cout << "The first character of the string str1 is: "
        << *str1_Iter << endl;
   cout << "The full original string str1 is: " << str1 << endl;

   // The dereferenced iterator can be used to modify a character
*str1_Iter = 'G';
   cout << "The first character of the modified str1 is now: "
        << *str1_Iter << endl;
   cout << "The full modified string str1 is now: " << str1 << endl;

   // The following line would be an error because iterator is const
   // *str1_cIter = 'g';

   // For an empty string, begin is equivalent to end
   if (  str2.begin ( ) == str2.end ( ) )
      cout << "The string str2 is empty." << endl;
   else
      cout << "The string str2 is not empty." << endl;
}

`basic_string::c_str`

Převede obsah řetězce jako řetězec ve stylu jazyka C, ukončený hodnotou null.

const value_type *c_str() const;

Vrácená hodnota

Ukazatel na verzi stylu C vyvolání řetězce. Hodnota ukazatele není platná po volání jinéconst funkce, včetně destruktoru, ve basic_string třídě objektu.

Poznámky

Objekty typu řetězce patřící do šablony basic_string<char> třídy nemusí být nutně ukončeny null. Znak null se používá jako speciální znak '\0' v řetězci C k označení konce řetězce, ale nemá žádný zvláštní význam v objektu typu řetězec a může být součástí řetězce stejně jako jakýkoli jiný znak. Existuje automatický převod z const char * řetězců na řetězce, ale třída řetězců neposkytuje automatické převody z řetězců ve stylu jazyka C na objekty typu basic_string<char>.

Vrácený řetězec ve stylu jazyka C by neměl být změněn, což by mohlo zneplatnit ukazatel na řetězec nebo odstranit, protože řetězec má omezenou životnost a vlastní řetězec třídy.

Příklad

// basic_string_c_str.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   string  str1 ( "Hello world" );
   cout << "The original string object str1 is: "
        << str1 << endl;
   cout << "The length of the string object str1 = "
        << str1.length ( ) << endl << endl;

   // Converting a string to an array of characters
   const char *ptr1 = 0;
   ptr1= str1.data ( );
   cout << "The modified string object ptr1 is: " << ptr1
        << endl;
   cout << "The length of character array str1 = "
        << strlen ( ptr1) << endl << endl;

   // Converting a string to a C-style string
   const char *c_str1 = str1.c_str ( );
   cout << "The C-style string c_str1 is: " << c_str1
        << endl;
   cout << "The length of C-style string str1 = "
        << strlen ( c_str1) << endl << endl;
}

The original string object str1 is: Hello world
The length of the string object str1 = 11

The modified string object ptr1 is: Hello world
The length of character array str1 = 11

The C-style string c_str1 is: Hello world
The length of C-style string str1 = 11

`basic_string::capacity`

Vrátí největší počet prvků, které by mohly být uloženy v řetězci bez zvýšení přidělení paměti řetězce.

size_type capacity() const;

Vrácená hodnota

Velikost úložiště, které je aktuálně přiděleno v paměti pro uložení řetězce.

Poznámky

Členová funkce vrátí úložiště, které je aktuálně přiděleno pro uložení řízené sekvence, a to alespoň tak velkou hodnotu jako size.

Příklad

// basic_string_capacity.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string  str1 ("Hello world");
   cout << "The original string str1 is: " << str1 << endl;

   // The size and length member functions differ in name only
   basic_string <char>::size_type sizeStr1, lenStr1;
   sizeStr1 = str1.size ( );
   lenStr1 = str1.length ( );

   basic_string <char>::size_type capStr1, max_sizeStr1;
   capStr1 = str1.capacity ( );
   max_sizeStr1 = str1.max_size ( );

   // Compare size, length, capacity & max_size of a string
   cout << "The current size of original string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The current length of original string str1 is: "
        << lenStr1 << "." << endl;
   cout << "The capacity of original string str1 is: "
        << capStr1 << "." << endl;
   cout << "The max_size of original string str1 is: "
        << max_sizeStr1 << "." << endl << endl;

   str1.erase ( 6, 5 );
   cout << "The modified string str1 is: " << str1 << endl;

   sizeStr1 = str1.size (  );
   lenStr1 = str1.length (  );
   capStr1 = str1.capacity (  );
   max_sizeStr1 = str1.max_size (  );

   // Compare size, length, capacity & max_size of a string
   // after erasing part of the original string
   cout << "The current size of modified string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The current length of modified string str1 is: "
        << lenStr1 << "." << endl;
   cout << "The capacity of modified string str1 is: "
        << capStr1 << "." << endl;
   cout << "The max_size of modified string str1 is: "
        << max_sizeStr1 << "." << endl;
}

`basic_string::cbegin`

const Vrátí iterátor, který řeší první prvek v oblasti.

const_iterator cbegin() const;

Vrácená hodnota

const Iterátor náhodného přístupu, který odkazuje na první prvek oblasti nebo umístění těsně za koncem prázdné oblasti (pro prázdnou oblast, cbegin() == cend()).

Poznámky

Při návratové cbeginhodnotě nelze upravit prvky v oblasti.

Tuto členská funkce můžete použít místo begin() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá spolu s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V tomto příkladu zvažte Container , že se jedná o upravitelný (non-const) kontejner jakéhokoli druhu, který podporuje begin() a cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`basic_string::cend`

const Vrátí iterátor, který řeší umístění za posledním prvkem v rozsahu.

const_iterator cend() const;

Vrácená hodnota

const Iterátor náhodného přístupu, který odkazuje těsně za koncem rozsahu.

Poznámky

cend slouží k otestování, zda iterátor předal konec jeho rozsahu.

Tuto členská funkce můžete použít místo end() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá spolu s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V tomto příkladu zvažte Container , že se jedná o upravitelný (non-const) kontejner jakéhokoli druhu, který podporuje end() a cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Hodnota vrácená cend by neměla být dereferenced.

`basic_string::clear`

Vymaže všechny prvky řetězce.

void clear();

Poznámky

Řetězec, na kterém je volána členová funkce, bude prázdný.

Příklad

// basic_string_clear.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string  str1 ("Hello world"), str2;
   basic_string <char>::iterator str_Iter;
   cout << "The original string str1 is: ";
   for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
      cout << *str_Iter;
   cout << endl;

   str1.clear ( );
   cout << "The modified string str1 is: ";
   for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
      cout << *str_Iter;
   cout << endl;

   //For an empty string, begin is equivalent to end
   if ( str1.begin ( ) == str1.end ( ) )
      cout << "Nothing printed above because "
           << "the string str1 is empty." << endl;
   else
      cout << "The string str1 is not empty." << endl;
}

The original string str1 is: Hello world
The modified string str1 is:
Nothing printed above because the string str1 is empty.

`basic_string::compare`

Porovnává porovnává malá a velká písmena se zadaným řetězcem, aby bylo možné určit, jestli jsou tyto dva řetězce stejné nebo jestli je jeden lexikálně menší než druhý.

int compare(
    const basic_string<CharType, Traits, Allocator>& str) const;

int compare(
    size_type position_1,
    size_type number_1,
    const basic_string<CharType, Traits, Allocator>& str) const;

int compare(
    size_type position_1,
    size_type number_1,
    const basic_string<CharType, Traits, Allocator>& str,
    size_type offset,
    size_type count) const;

int compare(
    const value_type* ptr) const;

int compare(
    size_type position_1,
    size_type number_1,
    const value_type* ptr) const;

int compare(
    size_type position_1,
    size_type number_1,
    const value_type* ptr
    size_type number_2) const;

Parametry

str
Řetězec, který se má porovnat s řetězcem operandu.

position_1
Index řetězce operandu, na kterém začíná porovnání.

number_1
Maximální počet znaků z řetězce operandu, který se má porovnat.

number_2
Maximální počet znaků z řetězce parametru, který se má porovnat.

offset
Index řetězce parametru, na kterém začíná porovnání.

count
Maximální počet znaků z řetězce parametru, který se má porovnat.

ptr
Řetězec jazyka C, který se má porovnat s řetězcem operandu.

Vrácená hodnota

Záporná hodnota, pokud je řetězec operandu menší než řetězec parametru; nula, pokud jsou tyto dva řetězce stejné; nebo kladnou hodnotu, pokud je řetězec operandu větší než řetězec parametru.

Poznámky

Členské compare funkce porovnávají všechny nebo části parametrů a operandových řetězců v závislosti na tom, které použité.

V porovnání se rozlišují malá a velká písmena.

Příklad

// basic_string_compare.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function compares
   // an operand string to a parameter string
   int comp1;
   string s1o ( "CAB" );
   string s1p ( "CAB" );
   cout << "The operand string is: " << s1o << endl;
   cout << "The parameter string is: " << s1p << endl;
   comp1 = s1o.compare ( s1p );
   if ( comp1 < 0 )
      cout << "The operand string is less than "
           << "the parameter string." << endl;
   else if ( comp1 == 0 )
      cout << "The operand string is equal to "
           << "the parameter string." << endl;
   else
      cout << "The operand string is greater than "
           << "the parameter string." << endl;
   cout << endl;

   // The second member function compares part of
   // an operand string to a parameter string
   int comp2a, comp2b;
   string s2o ( "AACAB" );
   string s2p ( "CAB" );
   cout << "The operand string is: " << s2o << endl;
   cout << "The parameter string is: " << s2p << endl;
   comp2a = s2o.compare (  2 , 3 , s2p );
   if ( comp2a < 0 )
      cout << "The last three characters of "
           << "the operand string\n are less than "
           << "the parameter string." << endl;
   else if ( comp2a == 0 )
      cout << "The last three characters of "
           << "the operand string\n are equal to "
           << "the parameter string." << endl;
   else
      cout << "The last three characters of "
           << "the operand string\n is greater than "
           << "the parameter string." << endl;

   comp2b = s2o.compare (  0 , 3 , s2p );
   if ( comp2b < 0 )
      cout << "The first three characters of "
           << "the operand string\n are less than "
           << "the parameter string." << endl;
   else if ( comp2b == 0 )
      cout << "The first three characters of "
           << "the operand string\n are equal to "
           << "the parameter string." << endl;
   else
      cout << "The first three characters of "
           << "the operand string\n is greater than "
           << "the parameter string." << endl;
   cout << endl;

   // The third member function compares part of
   // an operand string to part of a parameter string
   int comp3a;
   string s3o ( "AACAB" );
   string s3p ( "DCABD" );
   cout << "The operand string is: " << s3o << endl;
   cout << "The parameter string is: " << s3p << endl;
   comp3a = s3o.compare (  2 , 3 , s3p , 1 , 3 );
   if ( comp3a < 0 )
      cout << "The three characters from position 2 of "
           << "the operand string are less than\n "
           << "the 3 characters parameter string "
           << "from position 1." << endl;
   else if ( comp3a == 0 )
      cout << "The three characters from position 2 of "
           << "the operand string are equal to\n "
           << "the 3 characters parameter string "
           << "from position 1." << endl;
   else
      cout << "The three characters from position 2 of "
           << "the operand string is greater than\n "
           << "the 3 characters parameter string "
           << "from position 1." << endl;
   cout << endl;

   // The fourth member function compares
   // an operand string to a parameter C-string
   int comp4a;
   string s4o ( "ABC" );
   const char* cs4p = "DEF";
   cout << "The operand string is: " << s4o << endl;
   cout << "The parameter C-string is: " << cs4p << endl;
   comp4a = s4o.compare ( cs4p );
   if ( comp4a < 0 )
      cout << "The operand string is less than "
           << "the parameter C-string." << endl;
   else if ( comp4a == 0 )
      cout << "The operand string is equal to "
           << "the parameter C-string." << endl;
   else
      cout << "The operand string is greater than "
           << "the parameter C-string." << endl;
   cout << endl;

   // The fifth member function compares part of
   // an operand string to a parameter C-string
   int comp5a;
   string s5o ( "AACAB" );
   const char* cs5p = "CAB";
   cout << "The operand string is: " << s5o << endl;
   cout << "The parameter string is: " << cs5p << endl;
   comp5a = s5o.compare (  2 , 3 , s2p );
   if ( comp5a < 0 )
      cout << "The last three characters of "
           << "the operand string\n are less than "
           << "the parameter C-string." << endl;
   else if ( comp5a == 0 )
      cout << "The last three characters of "
           << "the operand string\n are equal to "
           << "the parameter C-string." << endl;
   else
      cout << "The last three characters of "
           << "the operand string\n is greater than "
           << "the parameter C-string." << endl;
   cout << endl;

   // The sixth member function compares part of
   // an operand string to part of an equal length of
   // a parameter C-string
   int comp6a;
   string s6o ( "AACAB" );
   const char* cs6p = "ACAB";
   cout << "The operand string is: " << s6o << endl;
   cout << "The parameter C-string is: " << cs6p << endl;
   comp6a = s6o.compare (  1 , 3 , cs6p , 3 );
   if ( comp6a < 0 )
      cout << "The 3 characters from position 1 of "
           << "the operand string are less than\n "
           << "the first 3 characters of the parameter C-string."
           << endl;
   else if ( comp6a == 0 )
      cout << "The 3 characters from position 2 of "
           << "the operand string are equal to\n "
           << "the first 3 characters of the parameter C-string."
           <<  endl;
   else
      cout << "The 3 characters from position 2 of "
           << "the operand string is greater than\n "
           << "the first 3 characters of the parameter C-string."
           << endl;
   cout << endl;
}

The operand string is: CAB
The parameter string is: CAB
The operand string is equal to the parameter string.

The operand string is: AACAB
The parameter string is: CAB
The last three characters of the operand string
are equal to the parameter string.
The first three characters of the operand string
are less than the parameter string.

The operand string is: AACAB
The parameter string is: DCABD
The three characters from position 2 of the operand string are equal to
the 3 characters parameter string from position 1.

The operand string is: ABC
The parameter C-string is: DEF
The operand string is less than the parameter C-string.

The operand string is: AACAB
The parameter string is: CAB
The last three characters of the operand string
are equal to the parameter C-string.

The operand string is: AACAB
The parameter C-string is: ACAB
The 3 characters from position 2 of the operand string are equal to
the first 3 characters of the parameter C-string.

`basic_string::const_iterator`

Typ, který poskytuje iterátor náhodného přístupu, který může přistupovat k prvku v řetězci a číst ho const .

typedef implementation-defined const_iterator;

Poznámky

Typ const_iterator nelze použít k úpravě hodnoty znaku a slouží k iteraci řetězce směrem dopředu.

Příklad

Podívejte se na příklad begin , jak deklarovat a používat const_iterator.

`basic_string::const_pointer`

Typ, který poskytuje ukazatel na const prvek v řetězci.

typedef typename allocator_type::const_pointer const_pointer;

Poznámky

Typ je synonymem pro allocator_type::const_pointer.

Pro typ stringje ekvivalentní .char*

Ukazatele deklarované const musí být inicializovány, když jsou deklarovány. Ukazatele const vždy odkazují na stejné umístění paměti a mohou odkazovat na konstantní nebo nekonstanční data.

Příklad

// basic_string_const_ptr.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   basic_string<char>::const_pointer pstr1a = "In Here";
   const char *cstr1c = "Out There";

   cout << "The string pstr1a is: " << pstr1a <<  "." << endl;
   cout << "The C-string cstr1c is: " << cstr1c << "." << endl;
}

The string pstr1a is: In Here.
The C-string cstr1c is: Out There.

`basic_string::const_reference`

Typ, který poskytuje odkaz na const prvek uložený v řetězci pro čtení a provádění const operací.

typedef typename allocator_type::const_reference const_reference;

Poznámky

Typ const_reference nelze použít k úpravě hodnoty elementu.

Typ je synonymem pro allocator_type::const_reference. Pro typ string, je ekvivalentní const char&.

Příklad

Podívejte se na příklad at , jak deklarovat a používat const_reference.

`basic_string::const_reverse_iterator`

Typ, který poskytuje iterátor náhodného přístupu, který může číst libovolný const prvek v řetězci.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Poznámky

Typ const_reverse_iterator nemůže změnit hodnotu znaku a používá se k iteraci řetězce v obráceném směru.

Příklad

Podívejte se na příklad rbegin , jak deklarovat a používat const_reverse_iterator.

`basic_string::copy`

Zkopíruje maximálně zadaný počet znaků z indexované pozice ve zdrojovém řetězci do cílového pole znaků.

Tato metoda je potenciálně nebezpečná, protože volající spoléhá na kontrolu správnosti předaných hodnot. Místo toho zvažte použití basic_string::_Copy_s .

size_type copy(
    value_type* ptr,
    size_type count,
    size_type offset = 0) const;

Parametry

ptr
Cílové pole znaků, do kterého se mají prvky zkopírovat.

count Maximální počet znaků, které se mají zkopírovat ze zdrojového řetězce.

offset
Počáteční pozice ve zdrojovém řetězci, ze kterého se mají vytvořit kopie.

Vrácená hodnota

Počet zkopírovaných znaků.

Poznámky

Na konec kopie není připojen znak null.

Příklad

// basic_string_copy.cpp
// compile with: /EHsc /W3
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ( "Hello World" );
   basic_string <char>::iterator str_Iter;
   char array1 [ 20 ] = { 0 };
   char array2 [ 10 ] = { 0 };
   basic_string <char>:: pointer array1Ptr = array1;
   basic_string <char>:: value_type *array2Ptr = array2;

   cout << "The original string str1 is: ";
   for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
      cout << *str_Iter;
   cout << endl;

   basic_string <char>:: size_type nArray1;
   // Note: string::copy is potentially unsafe, consider
   // using string::_Copy_s instead.
   nArray1 = str1.copy ( array1Ptr , 12 );  // C4996
   cout << "The number of copied characters in array1 is: "
        << nArray1 << endl;
   cout << "The copied characters array1 is: " << array1 << endl;

   basic_string <char>:: size_type nArray2;
   // Note: string::copy is potentially unsafe, consider
   // using string::_Copy_s instead.
   nArray2 = str1.copy ( array2Ptr , 5 , 6  );  // C4996
   cout << "The number of copied characters in array2 is: "
           << nArray2 << endl;
   cout << "The copied characters array2 is: " << array2Ptr << endl;
}

The original string str1 is: Hello World
The number of copied characters in array1 is: 11
The copied characters array1 is: Hello World
The number of copied characters in array2 is: 5
The copied characters array2 is: World

`basic_string::crbegin`

Vrátí iterátor const, který řeší první prvek v obráceném řetězci.

const_reverse_iterator crbegin() const;

Vrácená hodnota

Reverzní iterátor, který odkazuje těsně za koncem řetězce. Pozice určuje začátek reverzního řetězce.

`basic_string::crend`

const Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném řetězci.

const_reverse_iterator crend() const;

Vrácená hodnota

Reverzní const iterátor, který řeší umístění úspěšné poslední prvek v obráceném řetězci (umístění, které předchází prvnímu prvku v nereverzním řetězci).

Poznámky

`basic_string::_Copy_s`

Zkopíruje maximálně zadaný počet znaků z indexované pozice ve zdrojovém řetězci do cílového pole znaků.

size_type _Copy_s(
    value_type* dest,
    size_type dest_size,
    size_type count,
    size_type offset = 0) const;

Parametry

dest
Cílové pole znaků, do kterého se mají prvky zkopírovat.

dest_size
Velikost dest.

count Maximální počet znaků, které se mají zkopírovat ze zdrojového řetězce.

offset
Počáteční pozice ve zdrojovém řetězci, ze kterého se mají vytvořit kopie.

Vrácená hodnota

Počet zkopírovaných znaků.

Poznámky

Na konec kopie není připojen znak null. Tato funkce je specifická pro Microsoft.

Příklad

// basic_string__Copy_s.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
    using namespace std;
    string str1("Hello World");
    basic_string<char>::iterator str_Iter;
    const int array1_size = 20;
    char array1[array1_size] = { 0 };
    const int array2_size = 10;
    char array2[array2_size] = { 0 };
    basic_string<char>:: pointer array1Ptr = array1;
    basic_string<char>:: value_type *array2Ptr = array2;

    cout << "The original string str1 is: ";
    for (str_Iter = str1.begin(); str_Iter != str1.end(); str_Iter++)
        cout << *str_Iter;
    cout << endl;

    basic_string<char>::size_type nArray1;
    nArray1 = str1._Copy_s(array1Ptr, array1_size, 12);
    cout << "The number of copied characters in array1 is: "
         << nArray1 << endl;
    cout << "The copied characters array1 is: " << array1 << endl;

    basic_string<char>:: size_type nArray2;
    nArray2 = str1._Copy_s(array2Ptr, array2_size, 5, 6);
    cout << "The number of copied characters in array2 is: "
         << nArray2 << endl;
    cout << "The copied characters array2 is: " << array2Ptr << endl;
}

The original string str1 is: Hello World
The number of copied characters in array1 is: 11
The copied characters array1 is: Hello World
The number of copied characters in array2 is: 5
The copied characters array2 is: World

`basic_string::data`

Převede obsah řetězce na pole znaků ukončené hodnotou null.

const value_type *data() const noexcept;
value_type *data() noexcept;

Vrácená hodnota

Ukazatel na první prvek pole s ukončenou hodnotou null obsahující obsah řetězce. U prázdného řetězce ukazatel odkazuje na jeden znak null, který se rovná value_type().

Poznámky

Ukazatel vrácený data body v platném rozsahu [data(), data() + size()]. Každý prvek v oblasti odpovídá aktuálním datům v řetězci. To znamená, že pro každý platný posun n v rozsahu , data() + n == addressof(operator[](n)).

Pokud upravíte obsah řetězce vráceného const přetížením data, chování není definováno. Také se zobrazí nedefinované chování, pokud se znak null terminálu změní na jinou hodnotu. Vrácený ukazatel může být neplatný, pokudconst není odkaz na řetězec předán funkci standardní knihovny. Může být také zneplatněná voláním nečlenovéconst funkce. Volání členů at, , back, begin, end, frontrbegin, rend, a operator[] ne invalida ukazatel.

Před C++11 data nezaručil, že vrácený řetězec byl ukončen s hodnotou null. Vzhledem k tomu, data že C++11 a c_str oba vrátí řetězec ukončený hodnotou null a jsou v podstatě stejné.

const Přetížení není v jazyce C++17 nové. Pokud ho chcete použít, zadejte možnost kompilátoru /std:c++17 nebo novější.

Příklad

// basic_string_data.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   string str1 ( "Hello world" );
   cout << "The original string object str1 is: "
        << str1 << endl;
   cout << "The length of the string object str1 = "
        << str1.length ( ) << endl << endl;

   // Converting a string to an array of characters
   const char *ptr1 = 0;
   ptr1= str1.data ( );
   cout << "The modified string object ptr1 is: " << ptr1
        << endl;
   cout << "The length of character array str1 = "
        << strlen ( ptr1) << endl << endl;

   // Converting a string to a C-style string
   const char *c_str1 = str1.c_str ( );
   cout << "The C-style string c_str1 is: " << c_str1
        << endl;
   cout << "The length of C-style string str1 = "
        << strlen ( c_str1) << endl << endl;
}

The original string object str1 is: Hello world
The length of the string object str1 = 11

The modified string object ptr1 is: Hello world
The length of character array str1 = 11

The C-style string c_str1 is: Hello world
The length of C-style string str1 = 11

`basic_string::difference_type`

Typ, který poskytuje rozdíl mezi dvěma iterátory, které odkazují na prvky ve stejném řetězci.

typedef typename allocator_type::difference_type difference_type;

Poznámky

Typ signed integer popisuje objekt, který může představovat rozdíl mezi adresami libovolných dvou prvků v řízené sekvenci.

Pro typ stringje ekvivalentní .ptrdiff_t

Příklad

// basic_string_diff_type.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ( "quintillion" );
   cout << "The original string str1 is: " << str1 << endl;
   basic_string <char>::size_type indexChFi, indexChLi;

   indexChFi = str1.find_first_of ( "i" );
   indexChLi = str1.find_last_of ( "i" );
   basic_string<char>::difference_type diffi = indexChLi - indexChFi;

   cout << "The first character i is at position: "
        << indexChFi << "." << endl;
   cout << "The last character i is at position: "
        << indexChLi << "." << endl;
   cout << "The difference is: " << diffi << "." << endl;
}

The original string str1 is: quintillion
The first character i is at position: 2.
The last character i is at position: 8.
The difference is: 6.

`basic_string::empty`

Testuje, zda řetězec obsahuje znaky, nebo ne.

bool empty() const;

Vrácená hodnota

true pokud řetězcový objekt neobsahuje žádné znaky; false pokud má alespoň jeden znak.

Poznámky

Členová funkce je ekvivalentní size == 0.

Příklad

// basic_string_empty.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main() {
   using namespace std;

   bool b1, b2;

   string str1 ("Hello world");
   cout << "The original string object str1 is: " << str1 << endl;
   b1 = str1.empty();
   if (b1)
      cout << "The string object str1 is empty." << endl;
   else
      cout << "The string object str1 is not empty." << endl;
   cout << endl;

   // An example of an empty string object
   string str2;
   b2 = str2.empty();
   if (b2)
      cout << "The string object str2 is empty." << endl;
   else
      cout << "The string object str2 is not empty." << endl;
}

`basic_string::end`

Vrátí iterátor, který řeší umístění úspěšného posledního prvku v řetězci.

const_iterator end() const;

iterator end();

Vrácená hodnota

Vrátí iterátor náhodného přístupu, který řeší umístění úspěšné poslední prvek v řetězci.

Poznámky

end se často používá k otestování, jestli iterátor dosáhl konce řetězce. Hodnota vrácená end by neměla být dereferenced.

Pokud je vrácená hodnota end přiřazena k objektu const_iteratorřetězce, nelze upravit. Pokud je vrácená hodnota end přiřazena k objektu iterator, může být objekt řetězce změněn.

Příklad

// basic_string_end.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ( "No way out." ), str2;
   basic_string <char>::iterator str_Iter, str1_Iter, str2_Iter;
   basic_string <char>::const_iterator str1_cIter;

   str1_Iter = str1.end ( );
   str1_Iter--;
   str1_Iter--;
   cout << "The last character-letter of the string str1 is: " << *str1_Iter << endl;
   cout << "The full original string str1 is: " << str1 << endl;

   // end used to test when an iterator has reached the end of its string
   cout << "The string is now: ";
   for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
      cout << *str_Iter;
   cout << endl;

   // The dereferenced iterator can be used to modify a character
   *str1_Iter = 'T';
   cout << "The last character-letter of the modified str1 is now: "
        << *str1_Iter << endl;
   cout << "The modified string str1 is now: " << str1 << endl;

   // The following line would be an error because iterator is const
   // *str1_cIter = 'T';

   // For an empty string, end is equivalent to begin
   if ( str2.begin( ) == str2.end ( ) )
      cout << "The string str2 is empty." << endl;
   else
      cout << "The stringstr2  is not empty." << endl;
}

The last character-letter of the string str1 is: t
The full original string str1 is: No way out.
The string is now: No way out.
The last character-letter of the modified str1 is now: T
The modified string str1 is now: No way ouT.
The string str2 is empty.

`basic_string::ends_with`

Zkontrolujte, jestli řetězec končí zadanou příponou.

bool ends_with(const CharType c) const noexcept;
bool ends_with(const CharType* const x) const noexcept;
bool ends_with(const basic_string_view sv) const noexcept;

Parametry

c
Přípona jednoho znaku, která se má vyhledat.

sv
Zobrazení řetězců obsahující příponu, která se má vyhledat.
Můžete předat std::basic_string, který převede na zobrazení řetězce.

x
Řetězec znaků ukončený hodnotou null obsahující příponu, která se má vyhledat.

Vrácená hodnota

true pokud řetězec končí zadanou příponou; false jinak.

Poznámky

ends_with() je nový v jazyce C++20. Pokud ho chcete použít, zadejte možnost kompilátoru /std:c++20 nebo novější.

Zkontrolujte starts_with , jestli řetězec začíná zadanou předponou.

Příklad

// Requires /std:c++20 or /std:c++latest
#include <string>
#include <iostream>

int main()
{
    std::basic_string<char> str = "abcdefg";

    std::cout << std::boolalpha; // so booleans show as 'true'/'false'
    std::cout << str.ends_with('g') << '\n';
    std::cout << str.ends_with("eFg") << '\n';

    std::basic_string<char> str2 = "efg";
    std::cout << str.ends_with(str2);

    return 0;
}

true
false
true

`basic_string::erase`

Odebere prvek nebo rozsah prvků v řetězci ze zadané pozice.

iterator erase(
    iterator first,
    iterator last);

iterator erase(
    iterator iter);

basic_string<CharType, Traits, Allocator>& erase(
    size_type offset = 0,
    size_type count = npos);

Parametry

first
Iterátor adresovaný pozici prvního prvku v rozsahu, který se má vymazat.

last
Iterátor adresovaný pozici za posledním prvkem v rozsahu, který se má vymazat.

iter
Iterátor adresovaný pozici prvku v řetězci, který se má vymazat.

offset
Index prvního znaku v řetězci, který se má odebrat.

count
Počet prvků, které budou odebrány, pokud existuje tolik v rozsahu řetězce začínajícím offset.

Vrácená hodnota

U prvních dvou členských funkcí iterátor adresovaný prvním znakem za posledním znakem odebraným členovou funkcí. U třetí členské funkce odkazuje na objekt řetězce, ze kterého byly prvky vymazány.

Poznámky

Třetí člen funkce vrátí *this.

Příklad

// basic_string_erase.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The 1st member function using a range demarcated
   // by iterators
   string str1 ( "Hello world" );
   basic_string <char>::iterator str1_Iter;
   cout << "The original string object str1 is: "
        << str1 << "." << endl;
   str1_Iter = str1.erase ( str1.begin ( ) + 3 , str1.end ( ) - 1 );
   cout << "The first element after those removed is: "
        << *str1_Iter << "." << endl;
   cout << "The modified string object str1 is: " << str1
           << "." << endl << endl;

   // The 2nd member function erasing a char pointed to
   // by an iterator
   string str2 ( "Hello World" );
   basic_string <char>::iterator str2_Iter;
   cout << "The original string object str2 is: " << str2
        << "." << endl;
   str2_Iter = str2.erase ( str2.begin ( ) + 5 );
   cout << "The first element after those removed is: "
        << *str2_Iter << "." << endl;
   cout << "The modified string object str2 is: " << str2
        << "." << endl << endl;

   // The 3rd member function erasing a number of chars
   // after a char
   string str3 ( "Hello computer" ), str3m;
   basic_string <char>::iterator str3_Iter;
   cout << "The original string object str3 is: "
        << str3 << "." << endl;
   str3m = str3.erase ( 6 , 8 );
   cout << "The modified string object str3m is: "
        << str3m << "." << endl;
}

The original string object str1 is: Hello world.
The first element after those removed is: d.
The modified string object str1 is: Held.

The original string object str2 is: Hello World.
The first element after those removed is: W.
The modified string object str2 is: HelloWorld.

The original string object str3 is: Hello computer.
The modified string object str3m is: Hello .

`basic_string::find`

Vyhledá řetězec ve směru dopředu pro první výskyt podřetězce, který odpovídá zadané sekvenci znaků.

size_type find(
    value_type char_value,
    size_type offset = 0) const;

size_type find(
    const value_type* ptr,
    size_type offset = 0) const;

size_type find(
    const value_type* ptr,
    size_type offset,
    size_type count) const;

size_type find(
    const basic_string<CharType, Traits, Allocator>& str,
    size_type offset = 0) const;

Parametry

char_value
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index pozice, na které má vyhledávání začít.

ptr
Řetězec znaků, který má členská funkce vyhledat.

count
Počet znaků, počítaných vpřed od prvního znaku v řetězci znaků, které má členská funkce vyhledat.

str
Řetězec, který má členská funkce vyhledat.

Vrácená hodnota

Index prvního znaku nalezeného podřetězce, v opačném případě npos.

Příklad

// basic_string_find.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function
   // searches for a single character in a string
   string str1 ( "Hello Everyone" );
   cout << "The original string str1 is: " << str1 << endl;
   basic_string <char>::size_type indexCh1a, indexCh1b;

   indexCh1a = str1.find ( "e" , 3 );
   if (indexCh1a != string::npos )
      cout << "The index of the 1st 'e' found after the 3rd"
           << " position in str1 is: " << indexCh1a << endl;
   else
      cout << "The character 'e' was not found in str1 ." << endl;

   indexCh1b = str1.find ( "x" );
   if (indexCh1b != string::npos )
      cout << "The index of the 'x' found in str1 is: "
           << indexCh1b << endl << endl;
   else
      cout << "The Character 'x' was not found in str1."
           << endl << endl;

   // The second member function searches a string
   // for a substring as specified by a C-string
   string str2 ( "Let me make this perfectly clear." );
   cout << "The original string str2 is: " << str2 << endl;
   basic_string <char>::size_type indexCh2a, indexCh2b;

   const char *cstr2 = "perfect";
   indexCh2a = str2.find ( cstr2 , 5 );
   if ( indexCh2a != string::npos )
      cout << "The index of the 1st element of 'perfect' "
           << "after\n the 5th position in str2 is: "
           << indexCh2a << endl;
   else
      cout << "The substring 'perfect' was not found in str2 ."
           << endl;

   const char *cstr2b = "imperfectly";
   indexCh2b = str2.find ( cstr2b , 0 );
   if (indexCh2b != string::npos )
      cout << "The index of the 1st element of 'imperfect' "
           << "after\n the 5th position in str3 is: "
           << indexCh2b << endl;
   else
      cout << "The substring 'imperfect' was not found in str2 ."
           << endl << endl;

   // The third member function searches a string
   // for a substring as specified by a C-string
   string str3 ( "This is a sample string for this program" );
   cout << "The original string str3 is: " << str3 << endl;
   basic_string <char>::size_type indexCh3a, indexCh3b;

   const char *cstr3a = "sample";
   indexCh3a = str3.find ( cstr3a );
   if ( indexCh3a != string::npos )
      cout << "The index of the 1st element of sample "
           << "in str3 is: " << indexCh3a << endl;
   else
      cout << "The substring 'sample' was not found in str3 ."
           << endl;

   const char *cstr3b = "for";
   indexCh3b = str3.find ( cstr3b , indexCh3a + 1 , 2 );
   if (indexCh3b != string::npos )
      cout << "The index of the next occurrence of 'for' is in "
           << "str3 begins at: " << indexCh3b << endl << endl;
   else
      cout << "There is no next occurrence of 'for' in str3 ."
           << endl << endl;

   // The fourth member function searches a string
   // for a substring as specified by a string
   string str4 ( "clearly this perfectly unclear." );
   cout << "The original string str4 is: " << str4 << endl;
   basic_string <char>::size_type indexCh4a, indexCh4b;

   string str4a ( "clear" );
   indexCh4a = str4.find ( str4a , 5 );
   if ( indexCh4a != string::npos )
      cout << "The index of the 1st element of 'clear' "
           << "after\n the 5th position in str4 is: "
           << indexCh4a << endl;
   else
      cout << "The substring 'clear' was not found in str4 ."
           << endl;

   string str4b ( "clear" );
   indexCh4b = str4.find ( str4b );
   if (indexCh4b != string::npos )
      cout << "The index of the 1st element of 'clear' "
           << "in str4 is: "
           << indexCh4b << endl;
   else
      cout << "The substring 'clear' was not found in str4 ."
           << endl << endl;
}

The original string str1 is: Hello Everyone
The index of the 1st 'e' found after the 3rd position in str1 is: 8
The Character 'x' was not found in str1.

The original string str2 is: Let me make this perfectly clear.
The index of the 1st element of 'perfect' after
the 5th position in str2 is: 17
The substring 'imperfect' was not found in str2 .

The original string str3 is: This is a sample string for this program
The index of the 1st element of sample in str3 is: 10
The index of the next occurrence of 'for' is in str3 begins at: 24

The original string str4 is: clearly this perfectly unclear.
The index of the 1st element of 'clear' after
the 5th position in str4 is: 25
The index of the 1st element of 'clear' in str4 is: 0

`basic_string::find_first_not_of`

Vyhledá řetězec prvního znaku, který není prvkem zadaného řetězce.

size_type find_first_not_of(
    value_type char_value,
    size_type offset = 0) const;

size_type find_first_not_of(
    const value_type* ptr,
    size_type offset = 0) const;

size_type find_first_not_of(
    const value_type* ptr,
    size_type offset,
    size_type count) const;

size_type find_first_not_of(
    const basic_string<CharType, Traits, Allocator>& str,
    size_type offset = 0) const;

Parametry

char_value
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index pozice, na které má vyhledávání začít.

ptr
Řetězec znaků, který má členská funkce vyhledat.

count
Počet znaků, počítaných vpřed od prvního znaku v řetězci znaků, které má členská funkce vyhledat.

str
Řetězec, který má členská funkce vyhledat.

Vrácená hodnota

Index prvního znaku nalezeného podřetězce, v opačném případě npos.

Příklad

// basic_string_find_first_not_of.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function
   // searches for a single character in a string
   string str1 ( "xddd-1234-abcd" );
   cout << "The original string str1 is: " << str1 << endl;
   basic_string <char>::size_type indexCh1a, indexCh1b;
   static const basic_string <char>::size_type npos = -1;

   indexCh1a = str1.find_first_not_of ( "d" , 2 );
   if ( indexCh1a != npos )
      cout << "The index of the 1st 'd' found after the 3rd"
           << " position in str1 is: " << indexCh1a << endl;
   else
      cout << "The character 'd' was not found in str1 ." << endl;

   indexCh1b = str1.find_first_not_of  ( "x" );
   if (indexCh1b != npos )
      cout << "The index of the 'non x' found in str1 is: "
           << indexCh1b << endl << endl;
   else
      cout << "The character 'non x' was not found in str1."
           << endl << endl;

   // The second member function searches a string
   // for a substring as specified by a C-string
   string str2 ( "BBB-1111" );
   cout << "The original string str2 is: " << str2 << endl;
   basic_string <char>::size_type indexCh2a, indexCh2b;

   const char *cstr2 = "B1";
   indexCh2a = str2.find_first_not_of ( cstr2 , 6 );
   if ( indexCh2a != npos )
      cout << "The index of the 1st occurrence of an "
           << "element of 'B1' in str2 after\n the 6th "
           << "position is: " << indexCh2a << endl;
   else
      cout << "Elements of the substring 'B1' were not"
           << "\n found in str2 after the 6th position."
           << endl;

   const char *cstr2b = "B2";
   indexCh2b = str2.find_first_not_of ( cstr2b );
   if ( indexCh2b != npos )
      cout << "The index of the 1st element of 'B2' "
           << "after\n the 0th position in str2 is: "
           << indexCh2b << endl << endl;
   else
      cout << "The substring 'B2' was not found in str2 ."
           << endl << endl << endl;

   // The third member function searches a string
   // for a substring as specified by a C-string
   string str3 ( "444-555-GGG" );
   cout << "The original string str3 is: " << str3 << endl;
   basic_string <char>::size_type indexCh3a, indexCh3b;

   const char *cstr3a = "45G";
   indexCh3a = str3.find_first_not_of ( cstr3a );
   if ( indexCh3a != npos )
      cout << "The index of the 1st occurrence of an "
           << "element in str3\n other than one of the "
           << "characters in '45G' is: " << indexCh3a
           << endl;
   else
      cout << "Elements in str3 contain only characters "
           << " in the string '45G'. "
           << endl;

   const char *cstr3b = "45G";
   indexCh3b = str3.find_first_not_of ( cstr3b , indexCh3a + 1 , 2 );
   if ( indexCh3b != npos )
      cout << "The index of the second occurrence of an "
           << "element of '45G' in str3\n after the 0th "
           << "position is: " << indexCh3b << endl << endl;
   else
      cout << "Elements in str3 contain only characters "
           << " in the string  '45G'. "
           << endl  << endl;

   // The fourth member function searches a string
   // for a substring as specified by a string
   string str4 ( "12-ab-12-ab" );
   cout << "The original string str4 is: " << str4 << endl;
   basic_string <char>::size_type indexCh4a, indexCh4b;

   string str4a ( "ba3" );
   indexCh4a = str4.find_first_not_of ( str4a , 5 );
   if (indexCh4a != npos )
      cout << "The index of the 1st non occurrence of an "
           << "element of 'ba3' in str4 after\n the 5th "
           << "position is: " << indexCh4a << endl;
   else
      cout << "Elements other than those in the substring"
           << " 'ba3' were not found in the string str4."
           << endl;

   string str4b ( "12" );
   indexCh4b = str4.find_first_not_of ( str4b  );
   if (indexCh4b != npos )
      cout << "The index of the 1st non occurrence of an "
           << "element of '12' in str4 after\n the 0th "
           << "position is: " << indexCh4b << endl;
   else
      cout << "Elements other than those in the substring"
           << " '12' were not found in the string str4."
           << endl;
}

The original string str1 is: xddd-1234-abcd
The index of the 1st 'd' found after the 3rd position in str1 is: 4
The index of the 'non x' found in str1 is: 1

The original string str2 is: BBB-1111
Elements of the substring 'B1' were not
found in str2 after the 6th position.
The index of the 1st element of 'B2' after
the 0th position in str2 is: 3

The original string str3 is: 444-555-GGG
The index of the 1st occurrence of an element in str3
other than one of the characters in '45G' is: 3
The index of the second occurrence of an element of '45G' in str3
after the 0th position is: 7

The original string str4 is: 12-ab-12-ab
The index of the 1st non occurrence of an element of 'ba3' in str4 after
the 5th position is: 5
The index of the 1st non occurrence of an element of '12' in str4 after
the 0th position is: 2

`basic_string::find_first_of`

Vyhledá řetězec prvního znaku, který odpovídá libovolnému prvku zadaného řetězce.

size_type find_first_of(
    value_type char_value,
    size_type offset = 0) const;

size_type find_first_of(
    const value_type* ptr,
    size_type offset = 0) const;

size_type find_first_of(
    const value_type* ptr,
    size_type offset,
    size_type count) const;

size_type find_first_of(
    const basic_string<CharType, Traits, Allocator>& str,
    size_type offset = 0) const;

Parametry

char_value
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index pozice, na které má vyhledávání začít.

ptr
Řetězec znaků, který má členská funkce vyhledat.

count
Počet znaků, počítaných vpřed od prvního znaku v řetězci znaků, které má členská funkce vyhledat.

str
Řetězec, který má členská funkce vyhledat.

Vrácená hodnota

Index prvního znaku nalezeného podřetězce, v opačném případě npos.

Příklad

// basic_string_find_first_of.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function
   // searches for a single character in a string
   string str1 ( "abcd-1234-abcd-1234" );
   cout << "The original string str1 is: " << str1 << endl;
   basic_string <char>::size_type indexCh1a, indexCh1b;
   static const basic_string <char>::size_type npos = -1;

   indexCh1a = str1.find_first_of ( "d" , 5 );
   if ( indexCh1a != npos )
      cout << "The index of the 1st 'd' found after the 5th"
           << " position in str1 is: " << indexCh1a << endl;
   else
      cout << "The character 'd' was not found in str1 ." << endl;

   indexCh1b = str1.find_first_of ( "x" );
   if ( indexCh1b != npos )
      cout << "The index of the 'x' found in str1 is: "
           << indexCh1b << endl << endl;
   else
      cout << "The character 'x' was not found in str1."
           << endl << endl;

   // The second member function searches a string
   // for any element of a substring as specified by a C-string
   string str2 ( "ABCD-1234-ABCD-1234" );
   cout << "The original string str2 is: " << str2 << endl;
   basic_string <char>::size_type indexCh2a, indexCh2b;

   const char *cstr2 = "B1";
   indexCh2a = str2.find_first_of ( cstr2 , 6 );
   if ( indexCh2a != npos )
      cout << "The index of the 1st occurrence of an "
           << "element of 'B1' in str2 after\n the 6th "
           << "position is: " << indexCh2a << endl;
   else
      cout << "Elements of the substring 'B1' were not "
           << "found in str2 after the 10th position."
           << endl;

   const char *cstr2b = "D2";
   indexCh2b = str2.find_first_of ( cstr2b );
   if ( indexCh2b != npos )
      cout << "The index of the 1st element of 'D2' "
           << "after\n the 0th position in str2 is: "
           << indexCh2b << endl << endl;
   else
      cout << "The substring 'D2' was not found in str2 ."
           << endl << endl << endl;

   // The third member function searches a string
   // for any element of a substring as specified by a C-string
   string str3 ( "123-abc-123-abc-456-EFG-456-EFG" );
   cout << "The original string str3 is: " << str3 << endl;
   basic_string <char>::size_type indexCh3a, indexCh3b;

   const char *cstr3a = "5G";
   indexCh3a = str3.find_first_of ( cstr3a );
   if ( indexCh3a != npos )
      cout << "The index of the 1st occurrence of an "
           << "element of '5G' in str3 after\n the 0th "
           << "position is: " << indexCh3a << endl;
   else
      cout << "Elements of the substring '5G' were not "
           << "found in str3\n after the 0th position."
           << endl;

   const char *cstr3b = "5GF";
   indexCh3b = str3.find_first_of  ( cstr3b , indexCh3a + 1 , 2 );
   if (indexCh3b != npos )
      cout << "The index of the second occurrence of an "
           << "element of '5G' in str3\n after the 0th "
           << "position is: " << indexCh3b << endl << endl;
   else
      cout << "Elements of the substring '5G' were not "
           << "found in str3\n after the first occurrrence."
           << endl << endl;

   // The fourth member function searches a string
   // for any element of a substring as specified by a string
   string str4 ( "12-ab-12-ab" );
   cout << "The original string str4 is: " << str4 << endl;
   basic_string <char>::size_type indexCh4a, indexCh4b;

   string str4a ( "ba3" );
   indexCh4a = str4.find_first_of ( str4a , 5 );
   if ( indexCh4a != npos )
      cout << "The index of the 1st occurrence of an "
           << "element of 'ba3' in str4 after\n the 5th "
           << "position is: " << indexCh4a << endl;
   else
      cout << "Elements of the substring 'ba3' were not "
           << "found in str4\n after the 0th position."
           << endl;

   string str4b ( "a2" );
   indexCh4b = str4.find_first_of ( str4b );
   if ( indexCh4b != npos )
      cout << "The index of the 1st occurrence of an "
           << "element of 'a2' in str4 after\n the 0th "
           << "position is: " << indexCh4b << endl;
   else
      cout << "Elements of the substring 'a2' were not "
           << "found in str4\n after the 0th position."
           << endl;
}

The original string str1 is: abcd-1234-abcd-1234
The index of the 1st 'd' found after the 5th position in str1 is: 13
The character 'x' was not found in str1.

The original string str2 is: ABCD-1234-ABCD-1234
The index of the 1st occurrence of an element of 'B1' in str2 after
the 6th position is: 11
The index of the 1st element of 'D2' after
the 0th position in str2 is: 3

The original string str3 is: 123-abc-123-abc-456-EFG-456-EFG
The index of the 1st occurrence of an element of '5G' in str3 after
the 0th position is: 17
The index of the second occurrence of an element of '5G' in str3
after the 0th position is: 22

The original string str4 is: 12-ab-12-ab
The index of the 1st occurrence of an element of 'ba3' in str4 after
the 5th position is: 9
The index of the 1st occurrence of an element of 'a2' in str4 after
the 0th position is: 1

`basic_string::find_last_not_of`

Vyhledá řetězec posledního znaku, který není žádným prvkem zadaného řetězce.

size_type find_last_not_of(
    value_type char_value,
    size_type offset = npos) const;

size_type find_last_not_of(
    const value_type* ptr,
    size_type offset = npos) const;

size_type find_last_not_of(
    const value_type* ptr,
    size_type offset,
    size_type count) const;

size_type find_last_not_of(
    const basic_string<CharType, Traits, Allocator>& str,
    size_type offset = npos) const;

Parametry

char_value
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index pozice, ve které má být hledání dokončeno.

ptr
Řetězec znaků, který má členská funkce vyhledat.

count
Počet znaků, počítaných vpřed od prvního znaku v řetězci znaků, které má členská funkce vyhledat.

str
Řetězec, který má členská funkce vyhledat.

Vrácená hodnota

Index prvního znaku nalezeného podřetězce, v opačném případě npos.

Příklad

// basic_string_find_last_not_of.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function
   // searches for a single character in a string
   string str1 ( "dddd-1dd4-abdd" );
   cout << "The original string str1 is: " << str1 << endl;
   basic_string <char>::size_type indexCh1a, indexCh1b;
   static const basic_string <char>::size_type npos = -1;

   indexCh1a = str1.find_last_not_of ( "d" , 7 );
   if ( indexCh1a != npos )
      cout << "The index of the last non 'd'\n found before the "
           << "7th position in str1 is: " << indexCh1a << endl;
   else
      cout << "The non 'd' character was not found ." << endl;

   indexCh1b = str1.find_last_not_of  ( "d" );
   if ( indexCh1b != npos )
      cout << "The index of the non 'd' found in str1 is: "
           << indexCh1b << endl << endl;
   else
      cout << "The Character 'non x' was not found in str1."
           << endl << endl;

   // The second member function searches a string
   // for a substring as specified by a C-string
   string str2 ( "BBB-1111" );
   cout << "The original string str2 is: " << str2 << endl;
   basic_string <char>::size_type indexCh2a, indexCh2b;

   const char *cstr2 = "B1";
   indexCh2a = str2.find_last_not_of  ( cstr2 , 6 );
   if ( indexCh2a != npos )
      cout << "The index of the last occurrence of a "
           << "element\n not of 'B1' in str2 before the 6th "
           << "position is: " << indexCh2a << endl;
   else
      cout << "Elements not of the substring 'B1' were not "
           << "\n found in str2 before the 6th position."
           << endl;

   const char *cstr2b = "B-1";
   indexCh2b = str2.find_last_not_of  ( cstr2b );
   if ( indexCh2b != npos )
      cout << "The index of the last element not "
           << "in 'B-1'\n is: "
           << indexCh2b << endl << endl;
   else
      cout << "The elements of the substring 'B-1' were "
           << "not found in str2 ."
           << endl << endl;

   // The third member function searches a string
   // for a substring as specified by a C-string
   string str3 ( "444-555-GGG" );
   cout << "The original string str3 is: " << str3 << endl;
   basic_string <char>::size_type indexCh3a, indexCh3b;

   const char *cstr3a = "45G";
   indexCh3a = str3.find_last_not_of ( cstr3a );
   if ( indexCh3a != npos )
      cout << "The index of the last occurrence of an "
           << "element in str3\n other than one of the "
           << "characters in '45G' is: " << indexCh3a
           << endl;
   else
      cout << "Elements in str3 contain only characters "
           << " in the string  '45G'. "
           << endl;

   const char *cstr3b = "45G";
   indexCh3b = str3.find_last_not_of ( cstr3b , 6 , indexCh3a - 1 );
   if (indexCh3b != npos )
      cout << "The index of the penultimate occurrence of an "
           << "element\n not in '45G' in str3 is: "
           << indexCh3b << endl << endl;
   else
      cout << "Elements in str3 contain only characters "
           << " in the string '45G'. "
           << endl  << endl;

   // The fourth member function searches a string
   // for a substring as specified by a string
   string str4 ( "12-ab-12-ab" );
   cout << "The original string str4 is: " << str4 << endl;
   basic_string <char>::size_type indexCh4a, indexCh4b;

   string str4a ( "b-a" );
   indexCh4a = str4.find_last_not_of  ( str4a , 5 );
   if ( indexCh4a != npos )
      cout << "The index of the last occurrence of an "
           << "element not\n in 'b-a' in str4 before the 5th "
           << "position is: " << indexCh4a << endl;
   else
      cout << "Elements other than those in the substring"
           << " 'b-a' were not found in the string str4."
           << endl;

   string str4b ( "12" );
   indexCh4b = str4.find_last_not_of ( str4b  );
   if ( indexCh4b != npos )
      cout << "The index of the last occurrence of an "
           << "element not in '12'\n in str4 before the end "
           << "position is: " << indexCh4b << endl;
   else
      cout << "Elements other than those in the substring"
           << " '12'\n were not found in the string str4."
           << endl;
}

The original string str1 is: dddd-1dd4-abdd
The index of the last non 'd'
found before the 7th position in str1 is: 5
The index of the non 'd' found in str1 is: 11

The original string str2 is: BBB-1111
The index of the last occurrence of a element
not of 'B1' in str2 before the 6th position is: 3
The elements of the substring 'B-1' were not found in str2 .

The original string str3 is: 444-555-GGG
The index of the last occurrence of an element in str3
other than one of the characters in '45G' is: 7
The index of the penultimate occurrence of an element
not in '45G' in str3 is: 3

The original string str4 is: 12-ab-12-ab
The index of the last occurrence of an element not
in 'b-a' in str4 before the 5th position is: 1
The index of the last occurrence of an element not in '12'
in str4 before the end position is: 10

`basic_string::find_last_of`

Vyhledá řetězec posledního znaku, který odpovídá libovolnému prvku zadaného řetězce.

size_type find_last_of(
    value_type char_value,
    size_type offset = npos) const;

size_type find_last_of(
    const value_type* ptr,
    size_type offset = npos) const;

size_type find_last_of(
    const value_type* ptr,
    size_type offset,
    size_type count) const;

size_type find_last_of(
    const basic_string<CharType, Traits, Allocator>& str,
    size_type offset = npos) const;

Parametry

char_value
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index pozice, ve které má být hledání dokončeno.

ptr
Řetězec znaků, který má členská funkce vyhledat.

count
Počet znaků, počítaných vpřed od prvního znaku v řetězci znaků, které má členská funkce vyhledat.

str
Řetězec, který má členská funkce vyhledat.

Vrácená hodnota

Index posledního znaku podřetětědce, který byl při úspěchu vyhledána; jinak npos.

Příklad

// basic_string_find_last_of.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function
   // searches for a single character in a string
   string str1 ( "abcd-1234-abcd-1234" );
   cout << "The original string str1 is: " << str1 << endl;
   basic_string <char>::size_type indexCh1a, indexCh1b;
   static const basic_string <char>::size_type npos = -1;

   indexCh1a = str1.find_last_of ( "d" , 14 );
   if ( indexCh1a != npos )
      cout << "The index of the last 'd' found before the 14th"
           << " position in str1 is: " << indexCh1a << endl;
   else
      cout << "The character 'd' was not found in str1 ." << endl;

   indexCh1b = str1.find_first_of ( "x" );
   if ( indexCh1b != npos )
      cout << "The index of the 'x' found in str1 is: "
           << indexCh1b << endl << endl;
   else
      cout << "The character 'x' was not found in str1."
           << endl << endl;

   // The second member function searches a string
   // for a substring as specified by a C-string
   string str2 ( "ABCD-1234-ABCD-1234" );
   cout << "The original string str2 is: " << str2 << endl;
   basic_string <char>::size_type indexCh2a, indexCh2b;

   const char *cstr2 = "B1";
   indexCh2a = str2.find_last_of  ( cstr2 , 12 );
   if (indexCh2a != npos )
      cout << "The index of the last occurrence of an "
           << "element of 'B1' in str2 before\n the 12th "
           << "position is: " << indexCh2a << endl;
   else
      cout << "Elements of the substring 'B1' were not "
           << "found in str2 before the 12th position."
           << endl;

   const char *cstr2b = "D2";
   indexCh2b = str2.find_last_of  ( cstr2b );
   if ( indexCh2b != npos )
      cout << "The index of the last element of 'D2' "
           << "after\n the 0th position in str2 is: "
           << indexCh2b << endl << endl;
   else
      cout << "The substring 'D2' was not found in str2 ."
           << endl << endl << endl;

   // The third member function searches a string
   // for a substring as specified by a C-string
   string str3 ( "456-EFG-456-EFG" );
   cout << "The original string str3 is: " << str3 << endl;
   basic_string <char>::size_type indexCh3a;

   const char *cstr3a = "5E";
   indexCh3a = str3.find_last_of ( cstr3a , 8 , 8 );
   if ( indexCh3a != npos )
      cout << "The index of the last occurrence of an "
           << "element of '5E' in str3 before\n the 8th "
           << "position is: " << indexCh3a << endl << endl;
   else
      cout << "Elements of the substring '5G' were not "
           << "found in str3\n before the 8th position."
           << endl << endl;

   // The fourth member function searches a string
   // for a substring as specified by a string
   string str4 ( "12-ab-12-ab" );
   cout << "The original string str4 is: " << str4 << endl;
   basic_string <char>::size_type indexCh4a, indexCh4b;

   string str4a ( "ba3" );
   indexCh4a = str4.find_last_of  ( str4a , 8 );
   if ( indexCh4a != npos )
      cout << "The index of the last occurrence of an "
           << "element of 'ba3' in str4 before\n the 8th "
           << "position is: " << indexCh4a << endl;
   else
      cout << "Elements of the substring 'ba3' were not "
           << "found in str4\n after the 0th position."
           << endl;

   string str4b ( "a2" );
   indexCh4b = str4.find_last_of ( str4b  );
   if ( indexCh4b != npos )
      cout << "The index of the last occurrence of an "
           << "element of 'a2' in str4 before\n the 0th "
           << "position is: " << indexCh4b << endl;
   else
      cout << "Elements of the substring 'a2' were not "
           << "found in str4\n after the 0th position."
           << endl;
}

The original string str1 is: abcd-1234-abcd-1234
The index of the last 'd' found before the 14th position in str1 is: 13
The character 'x' was not found in str1.

The original string str2 is: ABCD-1234-ABCD-1234
The index of the last occurrence of an element of 'B1' in str2 before
the 12th position is: 11
The index of the last element of 'D2' after
the 0th position in str2 is: 16

The original string str3 is: 456-EFG-456-EFG
The index of the last occurrence of an element of '5E' in str3 before
the 8th position is: 4

The original string str4 is: 12-ab-12-ab
The index of the last occurrence of an element of 'ba3' in str4 before
the 8th position is: 4
The index of the last occurrence of an element of 'a2' in str4 before
the 0th position is: 9

`basic_string::front`

Vrátí odkaz na první prvek v řetězci.

const_reference front() const;

reference front();

Vrácená hodnota

Odkaz na první prvek řetězce, který musí být neprázdný.

Poznámky

`basic_string::get_allocator`

Vrátí kopii objektu alokátoru použitého k vytvoření řetězce.

allocator_type get_allocator() const;

Vrácená hodnota

Alokátor používaný řetězcem.

Poznámky

Členová funkce vrátí uložený objekt alokátoru.

Alokátory pro třídu řetězců určují, jak třída spravuje úložiště. Výchozí alokátory dodávané s třídami kontejneru jsou dostatečné pro většinu programovacích potřeb. Psaní a používání vlastní třídy alokátoru je pokročilá funkce jazyka C++.

Příklad

// basic_string_get_allocator.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects
   // that use the default allocator.
   string s1;
   basic_string <char> s2;
   basic_string <char, char_traits< char >, allocator< char > > s3;

   // s4 will use the same allocator class as s1
   basic_string <char> s4( s1.get_allocator ( ) );

   basic_string <char>::allocator_type xchar = s1.get_allocator( );
   // You can now call functions on the allocator class xchar used by s1
}

`basic_string::insert`

Vloží prvek, několik prvků nebo rozsah prvků do řetězce na zadané pozici.

basic_string<CharType, Traits, Allocator>& insert(
    size_type position,
    const value_type* ptr);

basic_string<CharType, Traits, Allocator>& insert(
    size_type position,
    const value_type* ptr,
    size_type count);

basic_string<CharType, Traits, Allocator>& insert(
    size_type position,
    const basic_string<CharType, Traits, Allocator>& str);

basic_string<CharType, Traits, Allocator>& insert(
    size_type position,
    const basic_string<CharType, Traits, Allocator>& str,
    size_type offset,
    size_type count);

basic_string<CharType, Traits, Allocator>& insert(
    size_type position,
    size_type count,
    value_type char_value);

iterator insert(
    iterator iter);

iterator insert(
    iterator iter,
    value_type char_value)l
template <class InputIterator>
void insert(
    iterator iter,
    InputIterator first,
    InputIterator last);

void insert(
    iterator iter,
    size_type count,
    value_type char_value);

void insert(
    iterator iter,
    const_pointer first,
    const_pointer last);

void insert(
    iterator iter,
    const_iterator first,
    const_iterator last);

Parametry

position
Index pozice za bodem vložení nových znaků.

ptr
Řetězec C je zcela nebo částečně vložen do řetězce.

count
Počet znaků, které se mají vložit.

str
Řetězec, který má být zcela nebo částečně vložen do cílového řetězce.

offset
Index části zdrojového řetězce poskytujícího znaky, které mají být připojeny.

char_value
Hodnota znaku prvků, které se mají vložit.

iter
Iterátor adresuje pozici, za kterou má být vložen znak.

first
Vstupní iterátor nebo const_iterator adresování prvního prvku ve zdrojovém rozsahu, const_pointerkterý se má vložit.

last
Vstupní iterátor nebo const_iterator adresování pozice jednoho za posledním prvkem ve zdrojovém rozsahu, const_pointerkterý se má vložit.

Vrácená hodnota

Funkce, které vracejí hodnotu, vrátí jednu z těchto funkcí:

Odkaz na basic_string ten, který obsahuje původní řetězec a nové znaky.
Iterátor na začátku vložených znaků.

Příklad

// basic_string_insert.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function inserting a C-string
   // at a given position
   basic_string <char> str1a ( "way" );
   const char *cstr1a = "a";
   str1a.insert ( 0, cstr1a );
   cout << "The string with a C-string inserted at position 0 is: "
        << str1a << "." << endl;

   // The second member function inserting a C-string
   // at a given position for a specified number of elements
   basic_string <char> str2a ( "Good" );
   const char *cstr2a = "Bye Bye Baby";
   str2a.insert ( 4, cstr2a ,3 );
   cout << "The string with a C-string inserted at the end is: "
        << str2a << "." << endl;

   // The third member function inserting a string
   // at a given position
   basic_string <char> str3a ( "Bye" );
   string str3b ( "Good" );
   str3a.insert ( 0, str3b );
   cout << "The string with a string inserted at position 0 is: "
        << str3a << "." << endl;

   // The fourth member function inserting part of
   // a string at a given position
   basic_string <char> str4a ( "Good " );
   string str4b ( "Bye Bye Baby" );
   str4a.insert ( 5, str4b , 8 , 4 );
   cout << "The string with part of a string inserted at position 4 is: "
        << str4a << "." << endl;

   // The fifth member function inserts a number of characters
   // at a specified position in the string
   string str5 ( "The number is: ." );
   str5.insert ( 15 , 3 , '3' );
   cout << "The string with characters inserted is: "
        << str5 << endl;

   // The sixth member function inserts a character
   // at a specified position in the string
   string str6 ( "ABCDFG" );
   basic_string <char>::iterator str6_Iter = ( str6.begin ( ) + 4 );
   str6.insert ( str6_Iter , 'e' );
   cout << "The string with a character inserted is: "
        << str6 << endl;

   // The seventh member function inserts a range
   // at a specified position in the string
   string str7a ( "ABCDHIJ" );
   string str7b ( "abcdefgh" );
   basic_string <char>::iterator str7a_Iter = (str7a.begin ( ) + 4 );
   str7a.insert ( str7a_Iter , str7b.begin ( ) + 4 , str7b.end ( ) -1 );
   cout << "The string with a character inserted from a range is: "
        << str7a << endl;

   // The eighth member function inserts a number of
   // characters at a specified position in the string
   string str8 ( "ABCDHIJ" );
   basic_string <char>::iterator str8_Iter = ( str8.begin ( ) + 4 );
   str8.insert ( str8_Iter , 3 , 'e' );
   cout << "The string with a character inserted from a range is: "
        << str8 << endl;
}

The string with a C-string inserted at position 0 is: away.
The string with a C-string inserted at the end is: GoodBye.
The string with a string inserted at position 0 is: GoodBye.
The string with part of a string inserted at position 4 is: Good Baby.
The string with characters inserted is: The number is: 333.
The string with a character inserted is: ABCDeFG
The string with a character inserted from a range is: ABCDefgHIJ
The string with a character inserted from a range is: ABCDeeeHIJ

`basic_string::iterator`

Typ, který poskytuje iterátor náhodného přístupu, který může přistupovat k prvku v řetězci a číst ho const .

typedef implementation-defined iterator;

Poznámky

Typ iterator lze použít k úpravě hodnoty znaku a slouží k iteraci řetězce směrem dopředu.

Příklad

Podívejte se na příklad begin , jak deklarovat a používat iterator.

`basic_string::length`

Vrátí aktuální počet prvků v řetězci.

size_type length() const;

Poznámky

Členová funkce je stejná jako size.

Příklad

// basic_string_length.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ("Hello world");
   cout << "The original string str1 is: " << str1 << endl;

   // The size and length member functions differ in name only
   basic_string <char>::size_type sizeStr1, lenStr1;
   sizeStr1 = str1.size ( );
   lenStr1 = str1.length ( );

   basic_string <char>::size_type capStr1, max_sizeStr1;
   capStr1 = str1.capacity ( );
   max_sizeStr1 = str1.max_size ( );

   // Compare size, length, capacity & max_size of a string
   cout << "The current size of original string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The current length of original string str1 is: "
        << lenStr1 << "." << endl;
   cout << "The capacity of original string str1 is: "
        << capStr1 << "." << endl;
   cout << "The max_size of original string str1 is: "
        << max_sizeStr1 << "." << endl << endl;

   str1.erase ( 6, 5 );
   cout << "The modified string str1 is: " << str1 << endl;

   sizeStr1 = str1.size ( );
   lenStr1 = str1.length ( );
   capStr1 = str1.capacity ( );
   max_sizeStr1 = str1.max_size ( );

   // Compare size, length, capacity & max_size of a string
   // after erasing part of the original string
   cout << "The current size of modified string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The current length of modified string str1 is: "
        << lenStr1 << "." << endl;
   cout << "The capacity of modified string str1 is: "
        << capStr1 << "." << endl;
   cout << "The max_size of modified string str1 is: "
        << max_sizeStr1 << "." << endl;
}

`basic_string::max_size`

Vrátí maximální počet znaků, které může řetězec obsahovat.

size_type max_size() const;

Vrácená hodnota

Maximální počet znaků, které může řetězec obsahovat.

Poznámky

Výjimka typu length_error Třída je vyvolán, když operace vytvoří řetězec s délkou větší než maximální velikost.

Příklad

// basic_string_max_size.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ("Hello world");
   cout << "The original string str1 is: " << str1 << endl;

   // The size and length member functions differ in name only
   basic_string <char>::size_type sizeStr1, lenStr1;
   sizeStr1 = str1.size ( );
   lenStr1 = str1.length ( );

   basic_string <char>::size_type capStr1, max_sizeStr1;
   capStr1 = str1.capacity ( );
   max_sizeStr1 = str1.max_size ( );

   // Compare size, length, capacity & max_size of a string
   cout << "The current size of original string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The current length of original string str1 is: "
        << lenStr1 << "." << endl;
   cout << "The capacity of original string str1 is: "
        << capStr1 << "." << endl;
   cout << "The max_size of original string str1 is: "
        << max_sizeStr1 << "." << endl << endl;

   str1.erase ( 6, 5 );
   cout << "The modified string str1 is: " << str1 << endl;

   sizeStr1 = str1.size ( );
   lenStr1 = str1.length ( );
   capStr1 = str1.capacity ( );
   max_sizeStr1 = str1.max_size ( );

   // Compare size, length, capacity & max_size of a string
   // after erasing part of the original string
   cout << "The current size of modified string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The current length of modified string str1 is: "
        << lenStr1 << "." << endl;
   cout << "The capacity of modified string str1 is: "
        << capStr1 << "." << endl;
   cout << "The max_size of modified string str1 is: "
        << max_sizeStr1 << "." << endl;
}

`basic_string::npos`

Celočíselnou hodnotu bez znaménka inicializovanou na -1, která označuje buď "nenalezena", nebo "všechny zbývající znaky" v případě selhání vyhledávací funkce.

static const size_type npos = -1;

Poznámky

Pokud je vrácená hodnota kontrolována npos pro tuto hodnotu, nemusí fungovat, pokud návratová hodnota není typu size_type a nikoli int nebo unsigned.

Příklad

Podívejte se na příklad find , jak deklarovat a používat npos.

`basic_string::operator+=`

Připojí znaky k řetězci.

basic_string<CharType, Traits, Allocator>& operator+=(
    value_type char_value);

basic_string<CharType, Traits, Allocator>& operator+=(
    const value_type* ptr);

basic_string<CharType, Traits, Allocator>& operator+=(
    const basic_string<CharType, Traits, Allocator>& right);

Parametry

char_value
Znak, který se má připojit.

ptr
Znaky řetězce C, které se mají připojit.

right
Znaky řetězce, které se mají připojit.

Vrácená hodnota

Odkaz na objekt řetězce, který je připojen se znaky předané členské funkce.

Poznámky

Znaky mohou být připojeny k řetězci pomocí operator+= členské funkce append nebo push_back. Připojí operator+= hodnoty s jedním argumentem, zatímco členová funkce připojení více argumentů umožňuje zadat konkrétní část řetězce pro přidání.

Příklad

// basic_string_op_app.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function
   // appending a single character to a string
   string str1a ( "Hello" );
   cout << "The original string str1 is: " << str1a << endl;
   str1a +=  '!' ;
   cout << "The string str1 appended with an exclamation is: "
        << str1a << endl << endl;

   // The second member function
   // appending a C-string to a string
   string  str1b ( "Hello " );
   const char *cstr1b = "Out There";
   cout << "The C-string cstr1b is: " << cstr1b << endl;
   str1b +=  cstr1b;
   cout << "Appending the C-string cstr1b to string str1 gives: "
        << str1b << "." << endl << endl;

   // The third member function
   // appending one string to another in two ways,
   // comparing append and operator [ ]
   string str1d ( "Hello " ), str2d ( "Wide " ), str3d ( "World" );
   cout << "The string str2d is: " << str2d << endl;
   str1d.append ( str2d );
   cout << "The appended string str1d is: "
        << str1d << "." << endl;
   str1d += str3d;
   cout << "The doubly appended strig str1 is: "
        << str1d << "." << endl << endl;
}

The original string str1 is: Hello
The string str1 appended with an exclamation is: Hello!

The C-string cstr1b is: Out There
Appending the C-string cstr1b to string str1 gives: Hello Out There.

The string str2d is: Wide
The appended string str1d is: Hello Wide .
The doubly appended strig str1 is: Hello Wide World.

`basic_string::operator=`

Přiřadí nové hodnoty znaků k obsahu řetězce.

basic_string<CharType, Traits, Allocator>& operator=(
    value_type char_value);

basic_string<CharType, Traits, Allocator>& operator=(
    const value_type* ptr);

basic_string<CharType, Traits, Allocator>& operator=(
    const basic_string<CharType, Traits, Allocator>& right);

basic_string<CharType, Traits, Allocator>& operator=(
    const basic_string<CharType, Traits, Allocator>&& right);

Parametry

char_value
Hodnota znaku, která má být přiřazena.

ptr
Ukazatel na znaky řetězce C, které mají být přiřazeny cílovému řetězci.

right
Zdrojový řetězec, jehož znaky mají být přiřazeny k cílovému řetězci.

Vrácená hodnota

Odkaz na objekt řetězce, který je přiřazen nové znaky členské funkce.

Poznámky

Řetězce mohou být přiřazeny nové hodnoty znaků. Nová hodnota může být řetězec a řetězec C nebo jeden znak. Lze operator= použít, pokud lze novou hodnotu popsat jedním parametrem, jinak členová funkce assign, která má více parametrů, může být použita k určení, která část řetězce má být přiřazena k cílovému řetězci.

Příklad

// basic_string_op_assign.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function assigning a
   // character of a certain value to a string
   string str1a ( "Hello " );
   str1a = '0';
   cout << "The string str1 assigned with the zero character is: "
        << str1a << endl << endl;

   // The second member function assigning the
   // characters of a C-string to a string
   string  str1b;
   const char *cstr1b = "Out There";
   cout << "The C-string cstr1b is: " << cstr1b <<  "." << endl;
   str1b = cstr1b;
   cout << "Assigning the C-string cstr1a to string str1 gives: "
        << str1b << "." << endl << endl;

   // The third member function assigning the characters
   // from one string to another string in two equivalent
   // ways, comparing the assign and operator =
   string str1c ( "Hello" ), str2c ( "Wide" ), str3c ( "World" );
   cout << "The original string str1 is: " << str1c << "." << endl;
   cout << "The string str2c is: " << str2c << "." << endl;
   str1c.assign ( str2c );
   cout << "The string str1 newly assigned with string str2c is: "
        << str1c << "." << endl;
   cout << "The string str3c is: " << str3c << "." << endl;
   str1c = str3c;
   cout << "The string str1 reassigned with string str3c is: "
        << str1c << "." << endl << endl;
}

The string str1 assigned with the zero character is: 0

The C-string cstr1b is: Out There.
Assigning the C-string cstr1a to string str1 gives: Out There.

The original string str1 is: Hello.
The string str2c is: Wide.
The string str1 newly assigned with string str2c is: Wide.
The string str3c is: World.
The string str1 reassigned with string str3c is: World.

`basic_string::operator[]`

Poskytuje odkaz na znak se zadaným indexem v řetězci.

const_reference operator[](size_type offset) const;
reference operator[](size_type offset);

Parametry

offset
Index pozice prvku, na který se má odkazovat.

Vrácená hodnota

Odkaz na znak řetězce na pozici určené indexem parametru.

Poznámky

První prvek řetězce má index nuly a následující prvky jsou indexovány po sobě kladně celými čísly. To znamená, že řetězec délky n má nth prvek indexovaný číslem n - 1.

operator[] je rychlejší než členová funkce at pro poskytování přístupu ke čtení a zápisu k prvkům řetězce.

operator[] nekontroluje, jestli je index předaný jako parametr platný, ale členová funkce at ano a proto by se měla použít v platnosti, není jistá. Neplatný index (index menší než nula nebo větší nebo rovna velikosti řetězce) předaný členské funkci at vyvolá out_of_range výjimku třídy . Neplatný index předaný výsledkům operator[] nedefinovaného chování, ale index se rovná délce řetězce je platný index pro const řetězce a operátor při předání tohoto indexu vrátí znak null.

Vrácený odkaz může být zneplatněn řetězcovými relokacemi nebo úpravami neřetězcůconst .

Při kompilaci s nastavenou _ITERATOR_DEBUG_LEVEL na hodnotu 1 nebo 2 dojde k chybě za běhu, pokud se pokusíte získat přístup k prvku mimo hranice řetězce. Další informace naleznete v tématu Kontrola iterátorů.

Příklad

// basic_string_op_ref.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ( "Hello world" ), str2 ( "Goodbye world" );
   const string cstr1 ( "Hello there" ), cstr2 ( "Goodbye now" );
   cout << "The original string str1 is: " << str1 << endl;
   cout << "The original string str2 is: " << str2 << endl;

   // Element access to the non-const strings
   basic_string <char>::reference refStr1 = str1 [6];
   basic_string <char>::reference refStr2 = str2.at ( 3 );

   cout << "The character with an index of 6 in string str1 is: "
        << refStr1 << "." << endl;
   cout << "The character with an index of 3 in string str2 is: "
        << refStr2 << "." << endl;

   // Element access to the const strings
   basic_string <char>::const_reference crefStr1 = cstr1 [ cstr1.length ( ) ];
   basic_string <char>::const_reference crefStr2 = cstr2.at ( 8 );

   if ( crefStr1 == '\0' )
      cout << "The null character is returned as a valid reference."
           << endl;
   else
      cout << "The null character is not returned." << endl;
   cout << "The character with index of 8 in the const string cstr2 is: "
        << crefStr2 << "." << endl;
}

`basic_string::pointer`

Typ, který poskytuje ukazatel na prvek znaku v řetězci nebo matici znaků.

typedef typename allocator_type::pointer pointer;

Poznámky

Typ je synonymem pro allocator_type::pointer.

Pro typ stringje ekvivalentní .char *

Příklad

// basic_string_pointer.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   basic_string<char>::pointer pstr1a = "In Here";
   char *cstr1b = "Out There";
   cout << "The string pstr1a is: " << pstr1a <<  "." << endl;
   cout << "The C-string cstr1b is: " << cstr1b << "." << endl;
}

The string pstr1a is: In Here.
The C-string cstr1b is: Out There.

`basic_string::pop_back`

Vymaže poslední prvek řetězce.

void pop_back();

Poznámky

Tato členová funkce efektivně volá erase(size() - 1) , aby se odstranil poslední prvek sekvence, který musí být neprázdný.

`basic_string::push_back`

Přidá prvek na konec řetězce.

void push_back(value_type char_value);

Parametry

char_value
Znak, který se má přidat na konec řetězce.

Poznámky

Člen funkce efektivně volá insert( end, char_value ). Další informace najdete v tématech insert a end.

Příklad

// basic_string_push_back.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ( "abc" );
   basic_string <char>::iterator str_Iter, str1_Iter;

   cout << "The original string str1 is: ";
   for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
      cout << *str_Iter;
   cout << endl;

   // str1.push_back ( 'd' );
   str1_Iter = str1.end ( );
   str1_Iter--;
   cout << "The last character-letter of the modified str1 is now: "
        << *str1_Iter << endl;

   cout << "The modified string str1 is: ";
   for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ )
      cout << *str_Iter;
   cout << endl;
}

The original string str1 is: abc
The last character-letter of the modified str1 is now: c
The modified string str1 is: abc

`basic_string::rbegin`

Vrátí iterátor na první prvek v obráceném řetězci.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Vrácená hodnota

Vrátí iterátor náhodného přístupu k prvnímu prvku v obráceném řetězci a adresuje, co by bylo posledním prvkem v odpovídajícím nereverzním řetězci.

Poznámky

rbegin se používá s obráceným řetězcem stejně, jako begin se používá s řetězcem.

Pokud je vrácená hodnota rbegin přiřazena k objektu const_reverse_iteratorřetězce, nelze upravit. Pokud je vrácená hodnota rbegin přiřazena k objektu reverse_iteratorřetězce, lze upravit objekt řetězce.

rbegin lze použít k inicializaci iterace přes řetězec zpět.

Příklad

// basic_string_rbegin.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ( "Able was I ere I saw Elba" ), str2;
   basic_string <char>::reverse_iterator str_rIter, str1_rIter, str2_rIter;
   basic_string <char>::const_reverse_iterator str1_rcIter;

   str1_rIter = str1.rbegin ( );
   // str1_rIter--;
   cout << "The first character-letter of the reversed string str1 is: "
        << *str1_rIter << endl;
   cout << "The full reversed string str1 is:\n ";
   for ( str_rIter = str1.rbegin( ); str_rIter != str1.rend( ); str_rIter++ )
      cout << *str_rIter;
   cout << endl;

   // The dereferenced iterator can be used to modify a character
   *str1_rIter = 'A';
   cout << "The first character-letter of the modified str1 is now: "
        << *str1_rIter << endl;
   cout << "The full modified reversed string str1 is now:\n ";
   for ( str_rIter = str1.rbegin( ); str_rIter != str1.rend( ); str_rIter++ )
      cout << *str_rIter;
   cout << endl;

   // The following line would be an error because iterator is const
   // *str1_rcIter = 'A';

   // For an empty string, begin is equivalent to end
   if ( str2.rbegin( ) == str2.rend ( ) )
      cout << "The string str2 is empty." << endl;
   else
      cout << "The stringstr2  is not empty." << endl;
}

The first character-letter of the reversed string str1 is: a
The full reversed string str1 is:
ablE was I ere I saw elbA
The first character-letter of the modified str1 is now: A
The full modified reversed string str1 is now:
AblE was I ere I saw elbA
The string str2 is empty.

`basic_string::reference`

Typ, který poskytuje odkaz na prvek uložený v řetězci.

typedef typename allocator_type::reference reference;

Poznámky

Typ reference lze použít k úpravě hodnoty elementu.

Typ je synonymem pro allocator_type::reference.

Pro typ stringje ekvivalentní .chr&

Příklad

Podívejte se na příklad at , jak deklarovat a používat reference.

`basic_string::rend`

Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném řetězci.

const_reverse_iterator rend() const;

reverse_iterator rend();

Vrácená hodnota

Reverzní iterátor náhodného přístupu, který řeší umístění úspěšné poslední prvek v obráceném řetězci.

Poznámky

rend se používá s obráceným řetězcem stejně, jako end se používá s řetězcem.

Pokud je vrácená hodnota rend přiřazena k objektu const_reverse_iteratorřetězce, nelze upravit. Pokud je vrácená hodnota rend přiřazena k objektu reverse_iteratorřetězce, lze upravit objekt řetězce.

rend lze použít k otestování, zda reverzní iterátor dosáhl konce řetězce.

Hodnota vrácená rend by neměla být dereferenced.

Příklad

// basic_string_rend.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ("Able was I ere I saw Elba"), str2;
   basic_string <char>::reverse_iterator str_rIter, str1_rIter, str2_rIter;
   basic_string <char>::const_reverse_iterator str1_rcIter;

   str1_rIter = str1.rend ( );
   str1_rIter--;
   cout << "The last character-letter of the reversed string str1 is: "
        << *str1_rIter << endl;
   cout << "The full reversed string str1 is:\n ";
   for ( str_rIter = str1.rbegin( ); str_rIter != str1.rend( ); str_rIter++ )
      cout << *str_rIter;
   cout << endl;

   // The dereferenced iterator can be used to modify a character
   *str1_rIter = 'o';
   cout << "The last character-letter of the modified str1 is now: "
        << *str1_rIter << endl;
   cout << "The full modified reversed string str1 is now:\n ";
   for ( str_rIter = str1.rbegin( ); str_rIter != str1.rend( ); str_rIter++ )
      cout << *str_rIter;
   cout << endl;

   // The following line would be an error because iterator is const
   // *str1_rcIter = 'T';

   // For an empty string, end is equivalent to begin
   if ( str2.rbegin( ) == str2.rend ( ) )
      cout << "The string str2 is empty." << endl;
   else
      cout << "The stringstr2  is not empty." << endl;
}

The last character-letter of the reversed string str1 is: A
The full reversed string str1 is:
ablE was I ere I saw elbA
The last character-letter of the modified str1 is now: o
The full modified reversed string str1 is now:
ablE was I ere I saw elbo
The string str2 is empty.

`basic_string::replace`

Nahradí prvky v řetězci na zadané pozici zadanými znaky nebo znaky zkopírovanými z jiných oblastí, řetězců nebo řetězců C.

basic_string<CharType, Traits, Allocator>& replace(
    size_type position_1,
    size_type number_1,
    const value_type* ptr);

basic_string<CharType, Traits, Allocator>& replace(
    size_type position_1,
    size_type number_1,
    const basic_string<CharType, Traits, Allocator>& str);

basic_string<CharType, Traits, Allocator>& replace(
    size_type position_1,
    size_type number_1,
    const value_type* ptr,
    size_type number_2);

basic_string<CharType, Traits, Allocator>& replace(
    size_type position_1,
    size_type number_1,
    const basic_string<CharType, Traits, Allocator>& str,
    size_type position_2,
    size_type number_2);

basic_string<CharType, Traits, Allocator>& replace(
    size_type position_1,
    size_type number_1,
    size_type count,
    value_type char_value);

basic_string<CharType, Traits, Allocator>& replace(
    iterator first0,
    iterator last0,
    const value_type* ptr);

basic_string<CharType, Traits, Allocator>& replace(
    iterator first0,
    iterator last0,
    const basic_string<CharType, Traits, Allocator>& str);

basic_string<CharType, Traits, Allocator>& replace(
    iterator first0,
    iterator last0,
    const value_type* ptr,
    size_type number_2);

basic_string<CharType, Traits, Allocator>& replace(
    iterator first0,
    iterator last0,
    size_type number_2,
    value_type char_value);

template <class InputIterator>
basic_string<CharType, Traits, Allocator>& replace(
    iterator first0,
    iterator last0,
    InputIterator first,
    InputIterator last);

basic_string<CharType, Traits, Allocator>& replace(
    iterator first0,
    iterator last0,
    const_pointer first,
    const_pointer last);

basic_string<CharType, Traits, Allocator>& replace(
    iterator first0,
    iterator last0,
    const_iterator first,
    const_iterator last);

Parametry

str
Řetězec, který má být zdrojem znaků pro řetězec operandu.

position_1
Index řetězce operandu, na kterém začíná nahrazení.

number_1
Maximální počet znaků, které se mají nahradit v řetězci operandu.

position_2
Index řetězce parametru, na kterém začíná kopírování.

number_2
Maximální počet znaků, které se mají použít z parametru C-string.

ptr
Řetězec jazyka C, který má být zdrojem znaků pro řetězec operandu.

char_value
Znak, který se má zkopírovat do řetězce operandu.

first0
Iterátor adresovaný prvním znakem, který se má odebrat v řetězci operandu.

last0
Iterátor adresovaný posledním znakem, který se má odebrat v řetězci operandu.

first
Iterátor, const_pointer nebo const_iterator adresování prvního znaku, který se má zkopírovat v řetězci parametru.

last
Iterátor, const_pointer nebo const_iterator adresování posledního znaku, který se má zkopírovat v řetězci parametru.

count
Počet zkopírování char_value do řetězce operandu.

Vrácená hodnota

Řetězec operandu s nahrazovacím řetězcem.

Příklad

// basic_string_replace.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first two member functions replace
   // part of the operand string with
   // characters from a parameter string or C-string
   string result1a, result1b;
   string s1o ( "AAAAAAAA" );
   string s1p ( "BBB" );
   const char* cs1p = "CCC";
   cout << "The operand string s1o is: " << s1o << endl;
   cout << "The parameter string s1p is: " << s1p << endl;
   cout << "The parameter C-string cs1p is: " << cs1p << endl;
   result1a = s1o.replace ( 1 , 3 , s1p );
   cout << "The result of s1o.replace ( 1 , 3 , s1p )\n is "
        << "the string: " << result1a << "." << endl;
   result1b = s1o.replace ( 5 , 3 , cs1p );
   cout << "The result of s1o.replace ( 5 , 3 , cs1p )\n is "
        << "the string: " << result1b << "." << endl;
   cout << endl;

   // The third & fourth member function replace
   // part of the operand string with characters
   // form part of a parameter string or C-string
   string result2a, result2b;
   string s2o ( "AAAAAAAA" );
   string s2p ( "BBB" );
   const char* cs2p = "CCC";
   cout << "The operand string s2o is: " << s2o << endl;
   cout << "The parameter string s1p is: " << s2p << endl;
   cout << "The parameter C-string cs2p is: " << cs2p << endl;
   result2a = s2o.replace ( 1 , 3 , s2p , 1 , 2 );
   cout << "The result of s2o.replace (1, 3, s2p, 1, 2)\n is "
        << "the string: " << result2a << "." << endl;
   result2b = s2o.replace ( 4 , 3 , cs2p , 1 );
   cout << "The result of s2o.replace (4 ,3 ,cs2p)\n is "
        << "the string: " << result2b << "." << endl;
   cout << endl;

   // The fifth member function replaces
   // part of the operand string with characters
   string result3a;
   string s3o ( "AAAAAAAA" );
   char ch3p = 'C';
   cout << "The operand string s3o is: " << s3o << endl;
   cout << "The parameter character c1p is: " << ch3p << endl;
   result3a = s3o.replace ( 1 , 3 , 4 , ch3p );
   cout << "The result of s3o.replace(1, 3, 4, ch3p)\n is "
        << "the string: " << result3a << "." << endl;
   cout << endl;

   // The sixth & seventh member functions replace
   // part of the operand string, delineated with iterators,
   // with a parameter string or C-string
   string s4o ( "AAAAAAAA" );
   string s4p ( "BBB" );
   const char* cs4p = "CCC";
   cout << "The operand string s4o is: " << s4o << endl;
   cout << "The parameter string s4p is: " << s4p << endl;
   cout << "The parameter C-string cs4p is: " << cs4p << endl;
   basic_string<char>::iterator IterF0, IterL0;
   IterF0 = s4o.begin ( );
   IterL0 = s4o.begin ( ) + 3;
   string result4a, result4b;
   result4a = s4o.replace ( IterF0 , IterL0 , s4p );
   cout << "The result of s1o.replace (IterF0, IterL0, s4p)\n is "
        << "the string: " << result4a << "." << endl;
   result4b = s4o.replace ( IterF0 , IterL0 , cs4p );
   cout << "The result of s4o.replace (IterF0, IterL0, cs4p)\n is "
        << "the string: " << result4b << "." << endl;
   cout << endl;

   // The 8th member function replaces
   // part of the operand string delineated with iterators
   // with a number of characters from a parameter C-string
   string s5o ( "AAAAAAAF" );
   const char* cs5p = "CCCBB";
   cout << "The operand string s5o is: " << s5o << endl;
   cout << "The parameter C-string cs5p is: " << cs5p << endl;
   basic_string<char>::iterator IterF1, IterL1;
   IterF1 = s5o.begin ( );
   IterL1 = s5o.begin ( ) + 4;
   string result5a;
   result5a = s5o.replace ( IterF1 , IterL1 , cs5p , 4 );
   cout << "The result of s5o.replace (IterF1, IterL1, cs4p ,4)\n is "
        << "the string: " << result5a << "." << endl;
   cout << endl;

   // The 9th member function replaces
   // part of the operand string delineated with iterators
   // with specified characters
   string s6o ( "AAAAAAAG" );
   char ch6p = 'q';
   cout << "The operand string s6o is: " << s6o << endl;
   cout << "The parameter character ch6p is: " << ch6p << endl;
   basic_string<char>::iterator IterF2, IterL2;
   IterF2 = s6o.begin ( );
   IterL2 = s6o.begin ( ) + 3;
   string result6a;
   result6a = s6o.replace ( IterF2 , IterL2 , 4 , ch6p );
   cout << "The result of s6o.replace (IterF1, IterL1, 4, ch6p)\n is "
        << "the string: " << result6a << "." << endl;
   cout << endl;

   // The 10th member function replaces
   // part of the operand string delineated with iterators
   // with part of a parameter string delineated with iterators
   string s7o ( "OOOOOOO" );
   string s7p ( "PPPP" );
   cout << "The operand string s7o is: " << s7o << endl;
   cout << "The parameter string s7p is: " << s7p << endl;
   basic_string<char>::iterator IterF3, IterL3, IterF4, IterL4;
   IterF3 = s7o.begin ( ) + 1;
   IterL3 = s7o.begin ( ) + 3;
   IterF4 = s7p.begin ( );
   IterL4 = s7p.begin ( ) + 2;
   string result7a;
   result7a = s7o.replace ( IterF3 , IterL3 , IterF4 , IterL4 );
   cout << "The result of s7o.replace (IterF3 ,IterL3 ,IterF4 ,IterL4)\n is "
        << "the string: " << result7a << "." << endl;
   cout << endl;
}

The operand string s1o is: AAAAAAAA
The parameter string s1p is: BBB
The parameter C-string cs1p is: CCC
The result of s1o.replace ( 1 , 3 , s1p )
is the string: ABBBAAAA.
The result of s1o.replace ( 5 , 3 , cs1p )
is the string: ABBBACCC.

The operand string s2o is: AAAAAAAA
The parameter string s1p is: BBB
The parameter C-string cs2p is: CCC
The result of s2o.replace (1, 3, s2p, 1, 2)
is the string: ABBAAAA.
The result of s2o.replace (4 ,3 ,cs2p)
is the string: ABBAC.

The operand string s3o is: AAAAAAAA
The parameter character c1p is: C
The result of s3o.replace(1, 3, 4, ch3p)
is the string: ACCCCAAAA.

The operand string s4o is: AAAAAAAA
The parameter string s4p is: BBB
The parameter C-string cs4p is: CCC
The result of s1o.replace (IterF0, IterL0, s4p)
is the string: BBBAAAAA.
The result of s4o.replace (IterF0, IterL0, cs4p)
is the string: CCCAAAAA.

The operand string s5o is: AAAAAAAF
The parameter C-string cs5p is: CCCBB
The result of s5o.replace (IterF1, IterL1, cs4p ,4)
is the string: CCCBAAAF.

The operand string s6o is: AAAAAAAG
The parameter character ch6p is: q
The result of s6o.replace (IterF1, IterL1, 4, ch6p)
is the string: qqqqAAAAG.

The operand string s7o is: OOOOOOO
The parameter string s7p is: PPPP
The result of s7o.replace (IterF3 ,IterL3 ,IterF4 ,IterL4)
is the string: OPPOOOO.

`basic_string::reserve`

Nastaví kapacitu řetězce na číslo alespoň tak velké jako zadané číslo.

void reserve(size_type count = 0);

Parametry

count
Početznakůch

Poznámky

Dostatek kapacity je důležité, protože relokace je časově náročný proces. A zneplatní všechny odkazy, ukazatele a iterátory, které odkazují na znaky v řetězci.

Koncept kapacity pro typy řetězcových objektů je stejný jako pro objekty typu vector. Na rozdíl od vector, člen funkce reserve může být volána ke zmenšení kapacity objektu. Požadavek není vazbu a může nebo nemusí dojít k chybě. Vzhledem k tomu, že výchozí hodnota parametru je nula, voláním reserve požadavku na vazbu zmenšíte kapacitu řetězce tak, aby odpovídala počtu znaků aktuálně v řetězci. Kapacita se nikdy nezmenší pod aktuálním počtem znaků.

Volání reserve je jediný možný způsob, jak zmenšit kapacitu řetězce. Jak je však uvedeno výše, tento požadavek není vazbu a nemusí se stát.

Příklad

// basic_string_reserve.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ("Hello world");
   cout << "The original string str1 is: " << str1 << endl;

   basic_string <char>::size_type sizeStr1, sizerStr1;
   sizeStr1 = str1.size ( );
   basic_string <char>::size_type capStr1, caprStr1;
   capStr1 = str1.capacity ( );

   // Compare size & capacity of the original string
   cout << "The current size of original string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The capacity of original string str1 is: "
        << capStr1 << "." << endl << endl;

   // Compare size & capacity of the string
   // with added capacity
   str1.reserve ( 40 );
   sizerStr1 = str1.size ( );
   caprStr1 = str1.capacity ( );

   cout << "The string str1with augmented capacity is: "
        << str1 << endl;
   cout << "The current size of string str1 is: "
        << sizerStr1 << "." << endl;
   cout << "The new capacity of string str1 is: "
        << caprStr1 << "." << endl << endl;

   // Compare size & capacity of the string
   // with downsized capacity
   str1.reserve ( );
   basic_string <char>::size_type sizedStr1;
   basic_string <char>::size_type capdStr1;
   sizedStr1 = str1.size ( );
   capdStr1 = str1.capacity ( );

   cout << "The string str1 with downsized capacity is: "
        << str1 << endl;
   cout << "The current size of string str1 is: "
        << sizedStr1 << "." << endl;
   cout << "The reduced capacity of string str1 is: "
        << capdStr1 << "." << endl << endl;
}

The original string str1 is: Hello world
The current size of original string str1 is: 11.
The capacity of original string str1 is: 15.

The string str1with augmented capacity is: Hello world
The current size of string str1 is: 11.
The new capacity of string str1 is: 47.

The string str1 with downsized capacity is: Hello world
The current size of string str1 is: 11.
The reduced capacity of string str1 is: 47.

`basic_string::resize`

Určuje novou velikost řetězce, připojení nebo mazání prvků podle potřeby.

void resize(
    size_type count,);

void resize(
    size_type count,
    value_type char_value);

Parametry

count
Nová velikost řetězce.

char_value
Hodnota, se kterou jsou připojené znaky inicializovány, pokud jsou požadovány další prvky.

Poznámky

Pokud výsledná velikost překročí maximální počet znaků, formulář vyvolá length_error.

Příklad

// basic_string_resize.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string  str1 ( "Hello world" );
   cout << "The original string str1 is: " << str1 << endl;

   basic_string <char>::size_type sizeStr1;
   sizeStr1 = str1.size ( );
   basic_string <char>::size_type capStr1;
   capStr1 = str1.capacity ( );

   // Compare size & capacity of the original string
   cout << "The current size of original string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The capacity of original string str1 is: "
        << capStr1 << "." << endl << endl;

   // Use resize to increase size by 2 elements: exclamations
   str1.resize ( str1.size ( ) + 2 , '!' );
   cout << "The resized string str1 is: " << str1 << endl;

   sizeStr1 = str1.size ( );
   capStr1 = str1.capacity ( );

   // Compare size & capacity of a string after resizing
   cout << "The current size of resized string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The capacity of resized string str1 is: "
        << capStr1 << "." << endl << endl;

   // Use resize to increase size by 20 elements:
   str1.resize ( str1.size ( ) + 20 );
   cout << "The resized string str1 is: " << str1 << endl;

   sizeStr1 = str1.size ( );
   capStr1 = str1.capacity ( );

   // Compare size & capacity of a string after resizing
   // note capacity increases automatically as required
   cout << "The current size of modified string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The capacity of modified string str1 is: "
        << capStr1 << "." << endl << endl;

   // Use resize to downsize by 28 elements:
   str1.resize ( str1.size ( ) - 28 );
   cout << "The downsized string str1 is: " << str1 << endl;

   sizeStr1 = str1.size (  );
   capStr1 = str1.capacity (  );

   // Compare size & capacity of a string after downsizing
   cout << "The current size of downsized string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The capacity of downsized string str1 is: "
        << capStr1 << "." << endl;
}

The original string str1 is: Hello world
The current size of original string str1 is: 11.
The capacity of original string str1 is: 15.

The resized string str1 is: Hello world!!
The current size of resized string str1 is: 13.
The capacity of resized string str1 is: 15.

The resized string str1 is: Hello world!!
The current size of modified string str1 is: 33.
The capacity of modified string str1 is: 47.

The downsized string str1 is: Hello
The current size of downsized string str1 is: 5.
The capacity of downsized string str1 is: 47.

`basic_string::reverse_iterator`

Typ, který poskytuje odkaz na prvek uložený v řetězci.

typedef std::reverse_iterator<iterator> reverse_iterator;

Poznámky

Typ reverse_iterator lze použít k úpravě hodnoty znaku a slouží k iteraci řetězce v obráceném směru.

Příklad

Podívejte se na příklad rbegin , jak deklarovat a používat reverse_iterator.

`basic_string::rfind`

Vyhledá řetězec v zpětném směru pro první výskyt podřetězce, který odpovídá zadané sekvenci znaků.

size_type rfind(
    value_type char_value,
    size_type offset = npos) const;

size_type rfind(
    const value_type* ptr,
    size_type offset = npos) const;

size_type rfind(
    const value_type* ptr,
    size_type offset,
    size_type count) const;

size_type rfind(
    const basic_string<CharType, Traits, Allocator>& str,
    size_type offset = npos) const;

Parametry

char_value
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index pozice, na které má vyhledávání začít.

ptr
Řetězec znaků, který má členská funkce vyhledat.

count
Počet znaků, počítaných vpřed od prvního znaku v řetězci znaků, které má členská funkce vyhledat.

str
Řetězec, který má členská funkce vyhledat.

Vrácená hodnota

Index posledního výskytu při zpětném hledání prvního znaku podřetězce při úspěchu; jinak npos.

Příklad

// basic_string_rfind.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // The first member function
   // searches for a single character in a string
   string str1 ( "Hello Everyone" );
   cout << "The original string str1 is: " << str1 << endl;
   basic_string <char>::size_type indexCh1a, indexCh1b;
   static const basic_string <char>::size_type npos = -1;

   indexCh1a = str1.rfind ( "e" , 9 );
   if ( indexCh1a != npos )
      cout << "The index of the 1st 'e' found before the 9th"
           << " position in str1 is: " << indexCh1a << endl;
   else
      cout << "The character 'e' was not found in str1 ." << endl;

   indexCh1b = str1.rfind ( "x" );
   if ( indexCh1b != npos )
      cout << "The index of the 'x' found in str1 is: "
           << indexCh1b << endl << endl;
   else
      cout << "The character 'x' was not found in str1."
           << endl << endl;

   // The second member function searches a string
   // for a substring as specified by a C-string
   string str2 ( "Let me make this perfectly clear." );
   cout << "The original string str2 is: " << str2 << endl;
   basic_string <char>::size_type indexCh2a, indexCh2b;

   const char *cstr2 = "perfect";
   indexCh2a = str2.rfind ( cstr2 , 30 );
   if ( indexCh2a != npos )
      cout << "The index of the 1st element of 'perfect' "
           << "before\n the 30th position in str2 is: "
           << indexCh2a << endl;
   else
      cout << "The substring 'perfect' was not found in str2 ."
           << endl;

   const char *cstr2b = "imperfectly";
   indexCh2b = str2.rfind ( cstr2b , 30 );
   if ( indexCh2b != npos )
      cout << "The index of the 1st element of 'imperfect' "
           << "before\n the 5th position in str3 is: "
           << indexCh2b << endl;
   else
      cout << "The substring 'imperfect' was not found in str2 ."
           << endl << endl;

   // The third member function searches a string
   // for a substring as specified by a C-string
   string str3 ( "It is a nice day. I am happy." );
   cout << "The original string str3 is: " << str3 << endl;
   basic_string <char>::size_type indexCh3a, indexCh3b;

   const char *cstr3a = "nice";
   indexCh3a = str3.rfind ( cstr3a );
   if ( indexCh3a != npos )
      cout << "The index of the 1st element of 'nice' "
           << "in str3 is: " << indexCh3a << endl;
   else
      cout << "The substring 'nice' was not found in str3 ."
           << endl;

   const char *cstr3b = "am";
   indexCh3b = str3.rfind ( cstr3b , indexCh3a + 25 , 2 );
   if ( indexCh3b != npos )
      cout << "The index of the next occurrence of 'am' in "
           << "str3 begins at: " << indexCh3b << endl << endl;
   else
      cout << "There is no next occurrence of 'am' in str3 ."
           << endl << endl;

   // The fourth member function searches a string
   // for a substring as specified by a string
   string str4 ( "This perfectly unclear." );
   cout << "The original string str4 is: " << str4 << endl;
   basic_string <char>::size_type indexCh4a, indexCh4b;

   string str4a ( "clear" );
   indexCh4a = str4.rfind ( str4a , 15 );
   if (indexCh4a != npos )
      cout << "The index of the 1st element of 'clear' "
           << "before\n the 15th position in str4 is: "
           << indexCh4a << endl;
   else
      cout << "The substring 'clear' was not found in str4 "
           << "before the 15th position." << endl;

   string str4b ( "clear" );
   indexCh4b = str4.rfind ( str4b );
   if ( indexCh4b != npos )
      cout << "The index of the 1st element of 'clear' "
           << "in str4 is: "
           << indexCh4b << endl;
   else
      cout << "The substring 'clear' was not found in str4 ."
           << endl << endl;
}

The original string str1 is: Hello Everyone
The index of the 1st 'e' found before the 9th position in str1 is: 8
The character 'x' was not found in str1.

The original string str2 is: Let me make this perfectly clear.
The index of the 1st element of 'perfect' before
the 30th position in str2 is: 17
The substring 'imperfect' was not found in str2 .

The original string str3 is: It is a nice day. I am happy.
The index of the 1st element of 'nice' in str3 is: 8
The index of the next occurrence of 'am' in str3 begins at: 20

The original string str4 is: This perfectly unclear.
The substring 'clear' was not found in str4 before the 15th position.
The index of the 1st element of 'clear' in str4 is: 17

`basic_string::shrink_to_fit`

Zahodí nadbytečnou kapacitu řetězce.

void shrink_to_fit();

Poznámky

Tato členová funkce eliminuje veškeré nepotřebné úložiště v kontejneru.

`basic_string::size`

Vrátí aktuální počet prvků v řetězci.

size_type size() const;

Vrácená hodnota

Délka řetězce.

Příklad

// basic_string_size.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ("Hello world");
   cout << "The original string str1 is: " << str1 << endl;

   // The size and length member functions differ in name only
   basic_string <char>::size_type sizeStr1, lenStr1;
   sizeStr1 = str1.size (  );
   lenStr1 = str1.length (  );

   basic_string <char>::size_type capStr1, max_sizeStr1;
   capStr1 = str1.capacity (  );
   max_sizeStr1 = str1.max_size (  );

   // Compare size, length, capacity & max_size of a string
   cout << "The current size of original string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The current length of original string str1 is: "
        << lenStr1 << "." << endl;
   cout << "The capacity of original string str1 is: "
        << capStr1 << "." << endl;
   cout << "The max_size of original string str1 is: "
        << max_sizeStr1 << "." << endl << endl;

   str1.erase ( 6, 5 );
   cout << "The modified string str1 is: " << str1 << endl;

   sizeStr1 = str1.size ( );
   lenStr1 = str1.length ( );
   capStr1 = str1.capacity ( );
   max_sizeStr1 = str1.max_size ( );

   // Compare size, length, capacity & max_size of a string
   // after erasing part of the original string
   cout << "The current size of modified string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The current length of modified string str1 is: "
        << lenStr1 << "." << endl;
   cout << "The capacity of modified string str1 is: "
        << capStr1 << "." << endl;
   cout << "The max_size of modified string str1 is: "
        << max_sizeStr1 << "." << endl;
}

`basic_string::size_type`

Typ celého čísla bez znaménka, který může představovat počet prvků a indexů v řetězci.

typedef typename allocator_type::size_type size_type;

Poznámky

je ekvivalentem allocator_type::size_type.

Pro typ stringje ekvivalentní .size_t

Příklad

// basic_string_size_type.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   string str1 ( "Hello world" );

   basic_string <char>::size_type sizeStr1, capStr1;
   sizeStr1 = str1.size (  );
   capStr1 = str1.capacity (  );

   cout << "The current size of string str1 is: "
        << sizeStr1 << "." << endl;
   cout << "The capacity of string str1 is: " << capStr1
         << "." << endl;
}

The current size of string str1 is: 11.
The capacity of string str1 is: 15.

`basic_string::starts_with`

Zkontrolujte, jestli řetězec začíná zadanou předponou.

bool starts_with(const CharType c) const noexcept;
bool starts_with(const CharType* const x) const noexcept;
bool starts_with(const basic_string_view sv) const noexcept;

Parametry

c
Předpona jednoho znaku, která se má vyhledat.

sv
Zobrazení řetězců obsahující předponu, která se má vyhledat.
Můžete předat std::basic_string, který převede na zobrazení řetězce.

x
Řetězec znaků ukončený hodnotou null obsahující předponu, která se má vyhledat.

Vrácená hodnota

true pokud řetězec začíná zadanou předponou; false jinak.

Poznámky

starts_with() je nový v jazyce C++20. Pokud ho chcete použít, zadejte možnost kompilátoru /std:c++20 nebo novější.

Zjistěte ends_with , jestli řetězec končí zadanou příponou.

Příklad

// Requires /std:c++20 or /std:c++latest
#include <string>
#include <iostream>

int main()
{
    std::basic_string<char> str = "abcdefg";

    std::cout << std::boolalpha; // so booleans show as 'true'/'false'
    std::cout << str.starts_with('b') << '\n';
    std::cout << str.starts_with("aBc") << '\n';

    std::basic_string<char> str2 = "abc";
    std::cout << str.starts_with(str2);

    return 0;
}

false
false
true

`basic_string::substr`

Zkopíruje podřetězce nejvýše určitého počtu znaků z řetězce začínajícího od zadané pozice.

basic_string<CharType, Traits, Allocator> substr(
    size_type offset = 0,
    size_type count = npos) const;

Parametry

offset
Index, který nachází prvek na pozici, ze které se vytvoří kopie řetězce, s výchozí hodnotou 0.

count
Počet znaků, které se mají zkopírovat, pokud jsou přítomné.

Vrácená hodnota

Objekt podřetězce, který je kopií prvků řetězcového operandu, počínaje pozicí určenou prvním argumentem.

Příklad

// basic_string_substr.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   string  str1 ("Heterological paradoxes are persistent.");
   cout << "The original string str1 is: \n " << str1
        << endl << endl;

   basic_string <char> str2 = str1.substr ( 6 , 7 );
   cout << "The substring str1 copied is: " << str2
        << endl << endl;

   basic_string <char> str3 = str1.substr (  );
   cout << "The default substring str3 is: \n " << str3
        <<  "\n which is the entire original string." << endl;
}

The original string str1 is:
Heterological paradoxes are persistent.

The substring str1 copied is: logical

The default substring str3 is:
Heterological paradoxes are persistent.
which is the entire original string.

`basic_string::swap`

Vyměňte obsah dvou řetězců.

void swap(
    basic_string<CharType, Traits, Allocator>& str);

Parametry

str
Zdrojový řetězec, jehož prvky se mají vyměňovat s prvky v cílovém řetězci.

Poznámky

Pokud prohozené řetězce mají stejný objekt alokátoru, členová swap funkce:

Vyskytuje se v konstantním čase.
Vyvolá žádné výjimky.
Zneplatní žádné odkazy, ukazatele nebo iterátory, které označují prvky ve dvou řetězcích.

V opačném případě provádí přiřazení prvků a konstruktor volání úměrný počtu prvků ve dvou kontrolovaných sekvencích.

Příklad

// basic_string_swap.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   // Declaring an objects of type basic_string<char>
   string s1 ( "Tweedledee" );
   string s2 ( "Tweedledum" );
   cout << "Before swapping string s1 and s2:" << endl;
   cout << " The basic_string s1 = " << s1 << "." << endl;
   cout << " The basic_string s2 = " << s2 << "." << endl;

   s1.swap ( s2 );
   cout << "After swapping string s1 and s2:" << endl;
   cout << " The basic_string s1 = " << s1 << "." << endl;
   cout << " The basic_string s2 = " << s2 << "." << endl;
}

Before swapping string s1 and s2:
The basic_string s1 = Tweedledee.
The basic_string s2 = Tweedledum.
After swapping string s1 and s2:
The basic_string s1 = Tweedledum.
The basic_string s2 = Tweedledee.

`basic_string::traits_type`

Typ pro vlastnosti znaků prvků uložených v řetězci.

typedef Traits traits_type;

Poznámky

Typ je synonymem druhého parametru Traitsšablony .

Pro typ stringje ekvivalentní .char_traits<char>

Příklad

Podívejte se na příklad copy , jak deklarovat a používat traits_type.

`basic_string::value_type`

Typ, který představuje typ znaků uložených v řetězci.

typedef typename allocator_type::value_type value_type;

Poznámky

Je ekvivalentní traits_type::char_type a je ekvivalentní char pro objekty typu string.

Příklad

// basic_string_value_type.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;

   basic_string<char>::value_type ch1 = 'G';

   char ch2 = 'H';

   cout << "The character ch1 is: " << ch1 << "." << endl;
   cout << "The character ch2 is: " << ch2 << "." << endl;
}

The character ch1 is: G.
The character ch2 is: H.

Viz také

<string>
Zabezpečení vláken ve standardní knihovně jazyka C++

Sdílet prostřednictvím

basic_string Třída

Syntaxe

Parametry

Konstruktory

Typedefs

Členské funkce

Operátory

Literály

Poznámky

Požadavky

basic_string::allocator_type

Poznámky

Příklad

basic_string::append

Parametry

Vrácená hodnota

Poznámky

Příklad

basic_string::assign

Parametry

Vrácená hodnota

Poznámky

Příklad

basic_string::at

Parametry

Vrácená hodnota

Poznámky

Příklad

basic_string::back

Vrácená hodnota

Poznámky

basic_string::basic_string

Parametry

Vrácená hodnota

Poznámky

Příklad

basic_string::begin

Vrácená hodnota

Příklad

basic_string::c_str

Vrácená hodnota

Poznámky

Příklad

basic_string::capacity

Vrácená hodnota

Poznámky

Příklad

basic_string::cbegin

Vrácená hodnota

Poznámky

basic_string::cend

Vrácená hodnota

Poznámky

basic_string::clear

Poznámky

Příklad

basic_string::compare

Parametry

Vrácená hodnota

Poznámky

Příklad

basic_string::const_iterator

Poznámky

Příklad

basic_string::const_pointer

Poznámky

Příklad

basic_string::const_reference

Poznámky

Příklad

basic_string::const_reverse_iterator

Poznámky

Příklad

basic_string::copy

Parametry

Vrácená hodnota

Poznámky

Příklad

basic_string::crbegin

`basic_string` Třída

`basic_string::allocator_type`

`basic_string::append`

`basic_string::assign`

`basic_string::at`

`basic_string::back`

`basic_string::basic_string`

`basic_string::begin`

`basic_string::c_str`

`basic_string::capacity`

`basic_string::cbegin`

`basic_string::cend`

`basic_string::clear`

`basic_string::compare`

`basic_string::const_iterator`

`basic_string::const_pointer`

`basic_string::const_reference`

`basic_string::const_reverse_iterator`

`basic_string::copy`

`basic_string::crbegin`

`basic_string::crend`

`basic_string::_Copy_s`

`basic_string::data`

`basic_string::difference_type`

`basic_string::empty`

`basic_string::end`

`basic_string::ends_with`

`basic_string::erase`

`basic_string::find`

`basic_string::find_first_not_of`

`basic_string::find_first_of`

`basic_string::find_last_not_of`

`basic_string::find_last_of`

`basic_string::front`

`basic_string::get_allocator`

`basic_string::insert`

`basic_string::iterator`

`basic_string::length`