`basic_string` Klasa

Artykuł
10/12/2023

Sekwencje kontrolowane przez obiekt typu basic_string są klasą ciągów standardowego języka C++ i są określane jako ciągi, ale nie należy ich mylić z ciągami w stylu C w stylu null używanymi w całej standardowej bibliotece języka C++. Ciąg standardowego języka C++ to kontener, który umożliwia używanie ciągów jako zwykłych typów, takich jak operacje porównywania i łączenia, iteratory, algorytmy standardowej biblioteki języka C++ oraz kopiowanie i przypisywanie z pamięcią zarządzaną przez alokatora klas. Jeśli musisz przekonwertować ciąg języka C++ w warstwie Standardowa na ciąg w stylu C typu null, użyj elementu basic_string::c_str członkowskiego.

Składnia

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

Parametry

CharType
Typ danych pojedynczego znaku, który ma być przechowywany w ciągu. Biblioteka Standardowa języka C++ udostępnia specjalizacje tego szablonu klasy z definicjami string typów elementów typu char, wstring, dla wchar_t, u16string dla char16_t, i u32string dla char32_t.

Traits
Różne ważne właściwości CharType elementów w specjalizacji basic_string są opisane przez klasę Traits. Domyślna wartość to char_traits<CharType>.

Allocator
Typ reprezentujący przechowywany obiekt alokatora, który hermetyzuje szczegóły dotyczące alokacji ciągu i cofnięcia alokacji pamięci. Domyślna wartość to allocator<CharType>.

Konstruktory

Konstruktor	opis
`basic_string`	Tworzy ciąg, który jest pusty lub zainicjowany przez określone znaki albo jest kopią wszystkich lub części innego obiektu ciągu lub ciągu C.

Typedefs

Nazwa typu	opis
`allocator_type`	Typ reprezentujący klasę `allocator` dla obiektu ciągu.
`const_iterator`	Typ, który udostępnia iterator dostępu losowego, który może uzyskiwać dostęp do elementu i odczytywać go `const` w ciągu.
`const_pointer`	Typ, który dostarcza wskaźnik do `const` elementu w ciągu.
`const_reference`	Typ, który zawiera odwołanie do elementu przechowywanego `const` w ciągu do odczytywania i wykonywania `const` operacji.
`const_reverse_iterator`	Typ, który udostępnia iterator dostępu losowego, który może odczytywać dowolny `const` element w ciągu.
`difference_type`	Typ, który zapewnia różnicę między dwoma iteratorami odwołującymi się do elementów w tym samym ciągu.
`iterator`	Typ, który udostępnia iterator dostępu losowego, który może odczytywać lub modyfikować dowolny element w ciągu.
`npos`	Niepodpisane wartość całkowita zainicjowana na -1, która wskazuje na "nie znaleziono" lub "wszystkie pozostałe znaki", gdy funkcja wyszukiwania nie powiedzie się.
`pointer`	Typ, który dostarcza wskaźnik do elementu znaku w ciągu lub tablicy znaków.
`reference`	Typ, który zawiera odwołanie do elementu przechowywanego w ciągu.
`reverse_iterator`	Typ, który udostępnia iterator dostępu losowego, który może odczytywać lub modyfikować element w odwróconym ciągu.
`size_type`	Niepodpisany typ całkowity liczby elementów w ciągu.
`traits_type`	Typ cech znaków elementów przechowywanych w ciągu.
`value_type`	Typ reprezentujący typ znaków przechowywanych w ciągu.

Funkcje składowe

Funkcja składowa	opis
`append`	Dodaje znaki na końcu ciągu.
`assign`	Przypisuje nowe wartości znaków do zawartości ciągu.
`at`	Zwraca odwołanie do elementu w określonej lokalizacji w ciągu.
`back`
`begin`	Zwraca iterator odnoszący się do pierwszego elementu w ciągu.
`c_str`	Konwertuje zawartość ciągu jako ciąg w stylu C, zakończonym wartością null.
`capacity`	Zwraca największą liczbę elementów, które mogą być przechowywane w ciągu bez zwiększania alokacji pamięci ciągu.
`cbegin`	Zwraca iterator const odnoszący się do pierwszego elementu w ciągu.
`cend`	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w ciągu.
`clear`	Usuwa wszystkie elementy ciągu.
`compare`	Porównuje ciąg z określonym ciągiem, aby określić, czy dwa ciągi są równe, lub jeśli jeden jest leksykograficznie mniejszy niż drugi.
`copy`	Kopiuje najwyżej określoną liczbę znaków z indeksowanej pozycji w ciągu źródłowym do docelowej tablicy znaków. Przestarzałe. Użycie w zamian parametru `basic_string::_Copy_s`.
`crbegin`	Zwraca iterator const, który adresuje pierwszy element w odwróconym ciągu.
`crend`	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym ciągu.
`_Copy_s`	Microsoft Specific: kopiuje najwyżej określoną liczbę znaków z indeksowanej pozycji w ciągu źródłowym do tablicy znaków docelowych.
`data`	Konwertuje zawartość ciągu na tablicę znaków.
`empty`	Sprawdza, czy ciąg zawiera znaki.
`end`	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w ciągu.
`ends_with`^C++20	Sprawdza, czy ciąg kończy się określonym sufiksem.
`erase`	Usuwa element lub zakres elementów w ciągu z określonej pozycji.
`find`	Wyszukuje ciąg w kierunku do przodu dla pierwszego wystąpienia podciągów, który pasuje do określonej sekwencji znaków.
`find_first_not_of`	Wyszukuje ciąg dla pierwszego znaku, który nie jest żadnym elementem określonego ciągu.
`find_first_of`	Wyszukuje ciąg dla pierwszego znaku, który pasuje do dowolnego elementu określonego ciągu.
`find_last_not_of`	Wyszukuje ciąg ostatniego znaku, który nie jest żadnym elementem określonego ciągu.
`find_last_of`	Wyszukuje ciąg ostatniego znaku, który jest elementem określonego ciągu.
`front`	Zwraca odwołanie do pierwszego elementu w ciągu.
`get_allocator`	Zwraca kopię obiektu używanego `allocator` do konstruowania ciągu.
`insert`	Wstawia element, kilka elementów lub zakres elementów do ciągu w określonej pozycji.
`length`	Zwraca bieżącą liczbę elementów w ciągu.
`max_size`	Zwraca maksymalną liczbę znaków, które może zawierać ciąg.
`pop_back`	Usuwa ostatni element ciągu.
`push_back`	Dodaje element na końcu ciągu.
`rbegin`	Zwraca iterator do pierwszego elementu w odwróconym ciągu.
`rend`	Zwraca iterator, który wskazuje tuż poza ostatnim elementem w odwróconym ciągu.
`replace`	Zastępuje elementy w ciągu na określonej pozycji określonymi znakami lub znakami skopiowanymi z innych zakresów lub ciągów lub ciągów C.
`reserve`	Ustawia pojemność ciągu na liczbę co najmniej tak dużą, jak określona liczba.
`resize`	Określa nowy rozmiar ciągu, dołączanie lub wymazywanie elementów zgodnie z potrzebami.
`rfind`	Wyszukuje ciąg w kierunku wstecznym dla pierwszego wystąpienia podciągów, który pasuje do określonej sekwencji znaków.
`shrink_to_fit`	Odrzuca nadmiarową pojemność ciągu.
`size`	Zwraca bieżącą liczbę elementów w ciągu.
`starts_with`^C++20	Sprawdza, czy ciąg rozpoczyna się od określonego prefiksu.
`substr`	Kopiuje podciąg z co najwyżej pewnej liczby znaków z ciągu rozpoczynającego się od określonej pozycji.
`swap`	Wymiana zawartości dwóch ciągów.

Operatory

Operator	opis
`operator+=`	Dołącza znaki do ciągu.
`operator=`	Przypisuje nowe wartości znaków do zawartości ciągu.
`operator[]`	Zawiera odwołanie do znaku z określonym indeksem w ciągu.

Literały

Nagłówki definiujące basic_string również następujące literały zdefiniowane przez użytkownika, które tworzą ciąg określonego typu z parametrów wejściowych.

Deklaracja	opis
`inline string operator"" s(const char* str, size_t len)`	Zwroty: `string(str, len)`
`inline string operator"" s(const wchar_t* str, size_t len)`	Zwroty: `wstring(str, len)`
`inline basic_string<char8_t> operator"" s(const char8_t* str, size_t len)`	Zwroty: `basic_string<char8_t>(str, len)`
`inline u16string operator"" s(const char16_t* str, size_t len)`	Zwroty: `u16string(str, len)`
`inline u32string operator"" s(const char32_t* str, size_t len)`	Zwroty: `u32string(str, len)`

Uwagi

Jeśli funkcja zostanie poproszona o wygenerowanie sekwencji dłuższej niż max_size elementy, funkcja zgłasza błąd długości, zgłaszając obiekt typu length_error.

Odwołania, wskaźniki i iteratory, które wyznaczają elementy kontrolowanej sekwencji, mogą stać się nieprawidłowe po każdym wywołaniu funkcji, która zmienia kontrolowaną sekwencję lub po pierwszym wywołaniu funkcji innej niżconst składowa.

Wymagania

Nagłówek:<ciąg>

Przestrzeń nazw: std

`basic_string::allocator_type`

Typ reprezentujący klasę alokatora dla obiektu ciągu.

typedef Allocator allocator_type;

Uwagi

Typ jest synonimem parametru Allocatorszablonu .

Przykład

// 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`

Dodaje znaki na końcu ciągu.

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
Ciąg C do dołączenia.

str
Ciąg, którego znaki mają być dołączane.

offset
Indeks części ciągu źródłowego dostarczający znaki do dołączenia.

count
Liczba znaków, które mają być dołączane, co najwyżej z ciągu źródłowego.

char_value
Wartość znaku do dołączenia.

first
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie, który ma zostać dołączony.

last
Iterator wejściowy, const_pointerlub const_iterator adresowanie pozycji elementu poza ostatnim elementem w zakresie, który ma zostać dołączony.

Wartość zwracana

Odwołanie do obiektu ciągu, który jest dołączany z znakami przekazywanymi przez funkcję składową.

Uwagi

Znaki mogą być dołączane do ciągu przy użyciu funkcji append składowych operator+= lub .push_back operator+= Dołącza wartości pojedynczego argumentu, podczas gdy funkcja składowa wiele argumentów append umożliwia określenie określonej części ciągu do dodania.

Przykład

// 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`

Przypisuje nowe wartości znaków do zawartości ciągu.

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
Wskaźnik do znaków ciągu C, który ma zostać przypisany do ciągu docelowego.

count
Liczba znaków do przypisania z ciągu źródłowego.

str
Ciąg źródłowy, którego znaki mają być przypisane do ciągu docelowego.

char_value
Wartość znaku do przypisania.

first
Iterator wejściowy, const_pointer lub const_iterator odnoszący się do pierwszego znaku w zakresie ciągu źródłowego, który ma zostać przypisany do zakresu docelowego.

last
Iterator wejściowy, const_pointer lub const_iterator odnoszący się do tego, który wykracza poza ostatni znak w zakresie ciągu źródłowego, który ma zostać przypisany do zakresu docelowego.

off
Pozycja, w której zostaną przypisane nowe znaki.

Wartość zwracana

Odwołanie do obiektu ciągu, który jest przypisywany nowych znaków przez funkcję składową.

Uwagi

Ciągi można przypisywać nowe wartości znaków. Nowa wartość może być ciągiem i ciągiem C lub pojedynczym znakiem. Wartość może być używana, jeśli nową wartość można opisać za pomocą jednego parametru. W operator= przeciwnym razie funkcja assignskładowa , która ma wiele parametrów, może służyć do określenia, która część ciągu ma zostać przypisana do ciągu docelowego.

Przykład

// 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`

Zawiera odwołanie do znaku z określonym indeksem w ciągu.

const_reference at(size_type offset) const;

reference at(size_type offset);

Parametry

offset
Indeks pozycji elementu do przywołowania.

Wartość zwracana

Odwołanie do znaku ciągu w pozycji określonej przez indeks parametrów.

Uwagi

Pierwszy element ciągu ma indeks zero, a następujące elementy są indeksowane kolejno przez dodatnie liczby całkowite, dzięki czemu ciąg o długości n ma n element indeksowany przez liczbę n - 1.

Element członkowski operator[] jest szybszy niż funkcja at składowa w celu zapewnienia dostępu do odczytu i zapisu do elementów ciągu.

Element członkowski operator[] nie sprawdza, czy indeks przekazany jako parametr jest prawidłowy, ale funkcja at składowa nie powinna być używana, jeśli ważność nie jest pewna. Nieprawidłowy indeks, który jest indeksem mniejszym niż zero lub większy lub równy rozmiarowi ciągu, przekazany do funkcji at składowej zgłasza out_of_range wyjątek klasy . Nieprawidłowy indeks przekazany do operator[] wyników niezdefiniowanego zachowania, ale indeks równy długości ciągu jest prawidłowym indeksem dla ciągów const, a operator zwraca znak null po przekazaniu tego indeksu.

Zwrócone odwołanie może zostać unieważnione przez reallocations ciągu lub modyfikacje dla ciągów innychconst niż ciągi.

Przykład

// 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`

Zwraca odwołanie do ostatniego elementu w ciągu.

const_reference back() const;

reference back();

Wartość zwracana

Odwołanie do ostatniego elementu ciągu, który musi być niepusty.

Uwagi

`basic_string::basic_string`

Tworzy ciąg, który jest pusty, zainicjowany przez określone znaki lub jest kopią wszystkich lub części innego obiektu ciągu lub stylu C (zakończonego wartością 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
Ciąg C, którego znaki mają być używane do inicjowania string konstrukcji. Ta wartość nie może być wskaźnikiem o wartości null, chyba że count jest równa zero.

alloc_type
Klasa alokatora magazynu dla tworzonego obiektu ciągu.

count
Liczba znaków do zainicjowania.

right
Ciąg do zainicjowania tworzonego ciągu.

right_offset
Indeks znaku w ciągu, który jest pierwszym, który ma być używany do inicjowania wartości znaków dla tworzonego ciągu.

char_value
Wartość znaku, która ma zostać skopiowana do tworzonego ciągu.

first
Iterator wejściowy, const_pointer lub const_iterator odnoszący się do pierwszego elementu w zakresie źródłowym, który ma zostać wstawiony.

last
Iterator wejściowy, const_pointer lub const_iterator odnoszący się do położenia elementu poza ostatnim elementem w zakresie źródłowym, który ma zostać wstawiony.

Wartość zwracana

Odwołanie do obiektu ciągu, który jest konstruowany przez konstruktory.

Uwagi

Wszystkie konstruktory przechowują basic_string::allocator_type i inicjują kontrolowaną sekwencję. Obiekt alokatora jest argumentem al, jeśli istnieje. W przypadku konstruktora kopiowania jest right.get_allocator()to wywołanie metody basic_string::get_allocator. W przeciwnym razie alokator to Alloc().

Kontrolowana sekwencja jest inicjowana do kopii sekwencji operand określonej przez pozostałe operandy. Konstruktor bez sekwencji operandu określa pustą, początkową kontrolowaną sekwencję. Jeśli InputIterator jest typem całkowitym w konstruktorze szablonu, sekwencja first, last operandu zachowuje się tak samo jak (size_type) first, (value_type) last.

Przykład

// 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`

Zwraca iterator odnoszący się do pierwszego elementu w ciągu.

const_iterator begin() const;

iterator begin();

Wartość zwracana

Iterator dostępu losowego, który adresuje pierwszy element sekwencji lub tuż poza końcem pustej sekwencji.

Przykład

// 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`

Konwertuje zawartość ciągu jako ciąg w stylu C, zakończony o wartości null.

const value_type *c_str() const;

Wartość zwracana

Wskaźnik do wersji w stylu C wywoływanego ciągu. Wartość wskaźnika nie jest prawidłowa po wywołaniu funkcji innejconst niż, w tym destruktora, w basic_string klasie obiektu .

Uwagi

Obiekty typu ciąg należące do szablonu basic_string<char> klasy nie muszą mieć wartości null zakończone. Znak '\0' null jest używany jako znak specjalny w ciągu C, aby oznaczyć koniec ciągu, ale nie ma specjalnego znaczenia w obiekcie typu ciąg i może być częścią ciągu tak samo jak każdy inny znak. Istnieje automatyczna konwersja z const char * do ciągów, ale klasa ciągów nie zapewnia automatycznych konwersji z ciągów w stylu C do obiektów typu basic_string<char>.

Zwrócony ciąg w stylu C nie powinien być modyfikowany, co może spowodować unieważnienie wskaźnika do ciągu lub usunięcie, ponieważ ciąg ma ograniczony okres istnienia i jest własnością ciągu klasy.

Przykład

// 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`

Zwraca największą liczbę elementów, które mogą być przechowywane w ciągu bez zwiększania alokacji pamięci ciągu.

size_type capacity() const;

Wartość zwracana

Rozmiar magazynu przydzielonego obecnie w pamięci do przechowywania ciągu.

Uwagi

Funkcja składowa zwraca magazyn, który jest obecnie przydzielony do przechowywania kontrolowanej sekwencji, czyli co najmniej tak dużej wartości jak size.

Przykład

// 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 Zwraca iterator, który adresuje pierwszy element w zakresie.

const_iterator cbegin() const;

Wartość zwracana

const Iterator dostępu losowego, który wskazuje pierwszy element zakresu lub lokalizację tuż poza końcem pustego zakresu (dla pustego zakresu, cbegin() == cend()).

Uwagi

Przy zwracanej wartości cbeginelementu nie można modyfikować elementów w zakresie.

Możesz użyć tej funkcji składowej zamiast funkcji składowej begin() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany wraz ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niżconst) jakiegokolwiek rodzaju, który obsługuje begin() i cbegin().

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

// i2 is Container<T>::const_iterator

`basic_string::cend`

Zwraca iterator, który adresuje lokalizację const tuż poza ostatnim elementem w zakresie.

const_iterator cend() const;

Wartość zwracana

const Iterator dostępu losowego, który wskazuje tuż poza końcem zakresu.

Uwagi

cend służy do testowania, czy iterator przeszedł koniec jego zakresu.

Możesz użyć tej funkcji składowej zamiast funkcji składowej end() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany wraz ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niżconst) jakiegokolwiek rodzaju, który obsługuje end() i cend().

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

// i2 is Container<T>::const_iterator

Wartość zwracana przez cend nie powinna być wyłuszczone.

`basic_string::clear`

Usuwa wszystkie elementy ciągu.

void clear();

Uwagi

Ciąg, na którym jest wywoływana funkcja składowa, będzie pusta.

Przykład

// 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`

Czy porównanie uwzględniające wielkość liter z określonym ciągiem określa, czy dwa ciągi są równe lub jeśli jeden jest leksykograficznie mniejszy niż drugi.

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
Ciąg, który ma być porównywany z ciągiem operandu.

position_1
Indeks ciągu operandu, w którym rozpoczyna się porównanie.

number_1
Maksymalna liczba znaków z ciągu operandu do porównania.

number_2
Maksymalna liczba znaków z ciągu parametru do porównania.

offset
Indeks ciągu parametru, w którym rozpoczyna się porównanie.

count
Maksymalna liczba znaków z ciągu parametru do porównania.

ptr
Ciąg C do porównania z ciągiem operandu.

Wartość zwracana

Wartość ujemna, jeśli ciąg operandu jest mniejszy niż ciąg parametru; zero, jeśli dwa ciągi są równe; lub wartość dodatnia, jeśli ciąg operandu jest większy niż ciąg parametru.

Uwagi

Funkcje compare składowe porównują wszystkie lub części parametru i ciągi operandu w zależności od używanego parametru.

Porównanie uwzględnia wielkość liter.

Przykład

// 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, który udostępnia iterator dostępu losowego, który może uzyskiwać dostęp do elementu i odczytywać go const w ciągu.

typedef implementation-defined const_iterator;

Uwagi

Nie można użyć typu const_iterator do modyfikowania wartości znaku i służy do iterowania ciągu w kierunku do przodu.

Przykład

Zobacz przykład, aby zapoznać się z przykładem begin sposobu deklarowania i używania elementu const_iterator.

`basic_string::const_pointer`

Typ, który dostarcza wskaźnik do const elementu w ciągu.

typedef typename allocator_type::const_pointer const_pointer;

Uwagi

Typ jest synonimem .allocator_type::const_pointer

Dla typu stringjest to odpowiednik char*.

Wskaźniki, które są deklarowane const, muszą być inicjowane po ich zadeklarowaniu. Wskaźniki const zawsze wskazują tę samą lokalizację pamięci i mogą wskazywać stałe lub niestałe dane.

Przykład

// 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, który zawiera odwołanie do elementu przechowywanego const w ciągu do odczytywania i wykonywania const operacji.

typedef typename allocator_type::const_reference const_reference;

Uwagi

Nie można użyć typu const_reference do modyfikowania wartości elementu.

Typ jest synonimem .allocator_type::const_reference Dla typu stringjest to odpowiednik const char&.

Przykład

Zobacz przykład, aby zapoznać się z przykładem at sposobu deklarowania i używania elementu const_reference.

`basic_string::const_reverse_iterator`

Typ, który udostępnia iterator dostępu losowego, który może odczytywać dowolny const element w ciągu.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Uwagi

Typ const_reverse_iterator nie może modyfikować wartości znaku i jest używany do iterowania przez ciąg w odwrotnej kolejności.

Przykład

Zobacz przykład, aby zapoznać się z przykładem rbegin sposobu deklarowania i używania elementu const_reverse_iterator.

`basic_string::copy`

Kopiuje najwyżej określoną liczbę znaków z indeksowanej pozycji w ciągu źródłowym do docelowej tablicy znaków.

Ta metoda jest potencjalnie niebezpieczna, ponieważ opiera się na obiekcie wywołującym, aby sprawdzić, czy przekazane wartości są poprawne. Rozważ użycie basic_string::_Copy_s zamiast tego.

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

Parametry

ptr
Docelowa tablica znaków, do której mają zostać skopiowane elementy.

count Liczba znaków, które mają zostać skopiowane, co najwyżej z ciągu źródłowego.

offset
Pozycja początkowa w ciągu źródłowym, z którego mają zostać wykonane kopie.

Wartość zwracana

Liczba skopiowanych znaków.

Uwagi

Znak null nie jest dołączany na końcu kopii.

Przykład

// 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`

Zwraca iterator const, który adresuje pierwszy element w odwróconym ciągu.

const_reverse_iterator crbegin() const;

Wartość zwracana

Iterator odwrotny, który wskazuje tuż za końcem ciągu. Pozycja określa początek ciągu odwrotnego.

`basic_string::crend`

const Zwraca iterator, który odnosi się do lokalizacji, która zakończyła się powodzeniem ostatniego elementu w odwróconym ciągu.

const_reverse_iterator crend() const;

Wartość zwracana

const Iterator odwrotny, który odnosi się do lokalizacji, która zakończyła się powodzeniem ostatniego elementu w odwróconym ciągu (lokalizacja, która poprzedzała pierwszy element w ciągu niereversed).

Uwagi

`basic_string::_Copy_s`

Kopiuje najwyżej określoną liczbę znaków z indeksowanej pozycji w ciągu źródłowym do docelowej tablicy znaków.

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

Parametry

dest
Docelowa tablica znaków, do której mają zostać skopiowane elementy.

dest_size
Rozmiar dest.

count Liczba znaków, które mają zostać skopiowane, co najwyżej z ciągu źródłowego.

offset
Pozycja początkowa w ciągu źródłowym, z którego mają zostać wykonane kopie.

Wartość zwracana

Liczba skopiowanych znaków.

Uwagi

Znak null nie jest dołączany na końcu kopii. Ta funkcja jest specyficzna dla firmy Microsoft.

Przykład

// 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`

Konwertuje zawartość ciągu na tablicę znaków zakończonych wartością null.

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

Wartość zwracana

Wskaźnik do pierwszego elementu tablicy zakończonej wartością null zawierającej zawartość ciągu. W przypadku pustego ciągu wskaźnik wskazuje pojedynczy znak o wartości null równy value_type().

Uwagi

Wskaźnik zwrócony przez data punkty w prawidłowym zakresie [data(), data() + size()]. Każdy element w zakresie odpowiada bieżącym danym w ciągu. Oznacza to, że dla każdego prawidłowego przesunięcia n w zakresie , data() + n == addressof(operator[](n)).

Jeśli zmodyfikujesz zawartość ciągu zwróconego const przez przeciążenie data, zachowanie jest niezdefiniowane. Zachowanie jest również niezdefiniowane, jeśli znak null terminalu zostanie zmieniony na dowolną inną wartość. Zwrócony wskaźnik może zostać unieważniony, jeśliconst odwołanie do ciągu zostanie przekazane do standardowej funkcji biblioteki. Można go również unieważnić przez wywołanie funkcji innej niżconst składowa. Wywołania elementów członkowskich at, beginfrontendrbeginback, , rendi operator[] nie unieważniają wskaźnika.

Przed językiem C++11 data nie zagwarantowano, że zwrócony ciąg został zakończony wartością null. Ponieważ język C++11 data i c_str oba zwracają ciąg zakończony o wartości null i są w rzeczywistości takie same.

const Przeciążenie nie jest nowe w języku C++17. Aby go użyć, określ lub nowszą /std:c++17 opcję kompilatora.

Przykład

// 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, który zapewnia różnicę między dwoma iteratorami odwołującymi się do elementów w tym samym ciągu.

typedef typename allocator_type::difference_type difference_type;

Uwagi

Typ liczby całkowitej ze znakiem opisuje obiekt, który może reprezentować różnicę między adresami wszystkich dwóch elementów w kontrolowanej sekwencji.

Dla typu stringjest to odpowiednik ptrdiff_t.

Przykład

// 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`

Sprawdza, czy ciąg zawiera znaki, czy nie.

bool empty() const;

Wartość zwracana

true jeśli obiekt ciągu nie zawiera żadnych znaków; false jeśli ma co najmniej jeden znak.

Uwagi

Funkcja składowa jest równoważna size == 0.

Przykład

// 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`

Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w ciągu.

const_iterator end() const;

iterator end();

Wartość zwracana

Zwraca iterator dostępu losowego, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w ciągu.

Uwagi

end jest często używany do testowania, czy iterator osiągnął koniec jego ciągu. Wartość zwracana przez end nie powinna być wyłuszczone.

Jeśli wartość zwracana end elementu jest przypisana do const_iteratorobiektu , nie można zmodyfikować obiektu ciągu. Jeśli zwracana wartość end elementu jest przypisana do iteratorobiektu , można zmodyfikować obiekt ciągu.

Przykład

// 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`

Sprawdź, czy ciąg kończy się określonym sufiksem.

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
Sufiks pojedynczego znaku do wyszukania.

sv
Widok ciągu zawierający sufiks do wyszukania.
Można przekazać element std::basic_string, który konwertuje na widok ciągu.

x
Ciąg znaków o wartości null zawierający sufiks do wyszukania.

Wartość zwracana

true jeśli ciąg kończy się określonym sufiksem; false inaczej.

Uwagi

ends_with() jest nowy w języku C++20. Aby go użyć, określ lub nowszą /std:c++20 opcję kompilatora.

Zobacz, starts_with aby sprawdzić, czy ciąg rozpoczyna się od określonego prefiksu.

Przykład

// 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`

Usuwa element lub zakres elementów w ciągu z określonej pozycji.

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
Iterator odnoszący się do pozycji pierwszego elementu w zakresie, który ma zostać usunięty.

last
Iterator odnoszący się do pozycji jednej obok ostatniego elementu w zakresie, który ma zostać wymazany.

iter
Iterator odnoszący się do położenia elementu w ciągu do wymazywania.

offset
Indeks pierwszego znaku w ciągu, który ma zostać usunięty.

count
Liczba elementów, które zostaną usunięte, jeśli istnieje tyle w zakresie ciągu rozpoczynającego się od offset.

Wartość zwracana

W przypadku pierwszych dwóch funkcji składowych iterator zwracający się do pierwszego znaku po ostatnim znaku usuniętym przez funkcję składową. W przypadku trzeciej funkcji składowej odwołanie do obiektu string, z którego elementy zostały wymazane.

Uwagi

Trzecia funkcja składowa zwraca wartość *this.

Przykład

// 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`

Wyszukuje ciąg w kierunku do przodu dla pierwszego wystąpienia podciągów, który pasuje do określonej sekwencji znaków.

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
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks pozycji, w której ma rozpocząć się wyszukiwanie.

ptr
Ciąg C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczając do przodu od pierwszego znaku, w ciągu C, dla którego ma być wyszukiwana funkcja składowa.

str
Ciąg, dla którego ma być wyszukiwana funkcja składowa.

Wartość zwracana

Indeks pierwszego znaku podciągów wyszukiwany po pomyślnym zakończeniu; w przeciwnym razie npos.

Przykład

// 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`

Wyszukuje ciąg dla pierwszego znaku, który nie jest elementem określonego ciągu.

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
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks pozycji, w której ma rozpocząć się wyszukiwanie.

ptr
Ciąg C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczając do przodu od pierwszego znaku, w ciągu C, dla którego ma być wyszukiwana funkcja składowa.

str
Ciąg, dla którego ma być wyszukiwana funkcja składowa.

Wartość zwracana

Indeks pierwszego znaku podciągów wyszukiwany po pomyślnym zakończeniu; w przeciwnym razie npos.

Przykład

// 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`

Wyszukuje ciąg dla pierwszego znaku, który pasuje do dowolnego elementu określonego ciągu.

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
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks pozycji, w której ma rozpocząć się wyszukiwanie.

ptr
Ciąg C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczając do przodu od pierwszego znaku, w ciągu C, dla którego ma być wyszukiwana funkcja składowa.

str
Ciąg, dla którego ma być wyszukiwana funkcja składowa.

Wartość zwracana

Indeks pierwszego znaku podciągów wyszukiwany po pomyślnym zakończeniu; w przeciwnym razie npos.

Przykład

// 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`

Wyszukuje ciąg ostatniego znaku, który nie jest żadnym elementem określonego ciągu.

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
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks pozycji, w której ma zakończyć wyszukiwanie.

ptr
Ciąg C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczając do przodu od pierwszego znaku, w ciągu C, dla którego ma być wyszukiwana funkcja składowa.

str
Ciąg, dla którego ma być wyszukiwana funkcja składowa.

Wartość zwracana

Indeks pierwszego znaku podciągów wyszukiwany po pomyślnym zakończeniu; w przeciwnym razie npos.

Przykład

// 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`

Wyszukuje ciąg ostatniego znaku, który pasuje do dowolnego elementu określonego ciągu.

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
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks pozycji, w której ma zakończyć wyszukiwanie.

ptr
Ciąg C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczając do przodu od pierwszego znaku, w ciągu C, dla którego ma być wyszukiwana funkcja składowa.

str
Ciąg, dla którego ma być wyszukiwana funkcja składowa.

Wartość zwracana

Indeks ostatniego znaku podciągów wyszukiwany po pomyślnym zakończeniu; w przeciwnym razie npos.

Przykład

// 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`

Zwraca odwołanie do pierwszego elementu w ciągu.

const_reference front() const;

reference front();

Wartość zwracana

Odwołanie do pierwszego elementu ciągu, który musi być niepusty.

Uwagi

`basic_string::get_allocator`

Zwraca kopię obiektu alokatora używanego do konstruowania ciągu.

allocator_type get_allocator() const;

Wartość zwracana

Alokator używany przez ciąg.

Uwagi

Funkcja składowa zwraca przechowywany obiekt alokatora.

Alokatory dla klasy ciągów określają sposób zarządzania magazynem przez klasę. Domyślne alokatory dostarczane z klasami kontenerów są wystarczające dla większości potrzeb programistycznych. Pisanie i używanie własnej klasy alokatora to zaawansowana funkcja języka C++.

Przykład

// 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`

Wstawia element, kilka elementów lub zakres elementów do ciągu w określonej pozycji.

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
Indeks pozycji za punktem wstawiania nowych znaków.

ptr
Ciąg C do całkowitego lub częściowo wstawiony do ciągu.

count
Liczba znaków do wstawienia.

str
Ciąg, który ma być całkowicie lub częściowo wstawiony do ciągu docelowego.

offset
Indeks części ciągu źródłowego dostarczający znaki do dołączenia.

char_value
Wartość znaku elementów do wstawienia.

iter
Iterator odnoszący się do pozycji, za którą ma zostać wstawiony znak.

first
Iterator wejściowy, const_pointerlub const_iterator adresowanie pierwszego elementu w zakresie źródłowym, który ma zostać wstawiony.

last
Iterator wejściowy, const_pointerlub const_iterator odnoszący się do położenia elementu poza ostatnim elementem w zakresie źródłowym, który ma zostać wstawiony.

Wartość zwracana

Funkcje zwracające wartość zwracają jedną z następujących wartości:

Odwołanie do elementu basic_string zawierającego oryginalny ciąg oraz nowe znaki.
Iterator na początku wstawionych znaków.

Przykład

// 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, który udostępnia iterator dostępu losowego, który może uzyskiwać dostęp do elementu i odczytywać go const w ciągu.

typedef implementation-defined iterator;

Uwagi

Typ iterator może służyć do modyfikowania wartości znaku i służy do iterowania ciągu w kierunku do przodu.

Przykład

Zobacz przykład, aby zapoznać się z przykładem begin sposobu deklarowania i używania elementu iterator.

`basic_string::length`

Zwraca bieżącą liczbę elementów w ciągu.

size_type length() const;

Uwagi

Funkcja składowa jest taka sama jak size.

Przykład

// 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`

Zwraca maksymalną liczbę znaków, które może zawierać ciąg.

size_type max_size() const;

Wartość zwracana

Maksymalna liczba znaków, które może zawierać ciąg.

Uwagi

Wyjątek klasy typu length_error jest zgłaszany, gdy operacja generuje ciąg o długości większej niż maksymalny rozmiar.

Przykład

// 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`

Niepodpisane wartość całkowita zainicjowana na -1, która wskazuje na "nie znaleziono" lub "wszystkie pozostałe znaki", gdy funkcja wyszukiwania nie powiedzie się.

static const size_type npos = -1;

Uwagi

Gdy wartość zwracana ma być sprawdzana pod kątem npos wartości, może to nie działać, chyba że zwracana wartość jest typu size_type , a nie int lub unsigned.

Przykład

Zobacz przykład, aby zapoznać się z przykładem find sposobu deklarowania i używania elementu npos.

`basic_string::operator+=`

Dołącza znaki do ciągu.

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 do dołączenia.

ptr
Znaki ciągu C do dołączenia.

right
Znaki ciągu do dołączenia.

Wartość zwracana

Odwołanie do obiektu ciągu, który jest dołączany z znakami przekazywanymi przez funkcję składową.

Uwagi

Znaki mogą być dołączane do ciągu przy użyciu funkcji append składowych operator+= lub .push_back Dołącza operator+= wartości pojedynczego argumentu, podczas gdy funkcja składowa dołączania wielu argumentów umożliwia określenie określonej części ciągu do dodania.

Przykład

// 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=`

Przypisuje nowe wartości znaków do zawartości ciągu.

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
Wartość znaku do przypisania.

ptr
Wskaźnik do znaków ciągu C, który ma zostać przypisany do ciągu docelowego.

right
Ciąg źródłowy, którego znaki mają być przypisane do ciągu docelowego.

Wartość zwracana

Odwołanie do obiektu ciągu, który jest przypisywany nowych znaków przez funkcję składową.

Uwagi

Ciągi mogą mieć przypisane nowe wartości znaków. Nowa wartość może być ciągiem i ciągiem C lub pojedynczym znakiem. Może operator= być używany, jeśli nową wartość można opisać za pomocą jednego parametru, w przeciwnym razie funkcja assignskładowa , która ma wiele parametrów, może służyć do określenia, która część ciągu ma zostać przypisana do ciągu docelowego.

Przykład

// 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[]`

Zawiera odwołanie do znaku z określonym indeksem w ciągu.

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

Parametry

offset
Indeks pozycji elementu do przywołowania.

Wartość zwracana

Odwołanie do znaku ciągu w pozycji określonej przez indeks parametrów.

Uwagi

Pierwszy element ciągu ma indeks zero, a następujące elementy są indeksowane kolejno przez dodatnie liczby całkowite. Oznacza to, że ciąg o długości n ma nelement indeksowany przez liczbę n -1.

operator[] funkcja składowa jest szybsza niż funkcja at składowa zapewniająca dostęp do odczytu i zapisu do elementów ciągu.

operator[] Nie sprawdza, czy indeks przekazany jako parametr jest prawidłowy, ale funkcja at składowa i tak powinna być używana w ważności, nie jest pewna. Nieprawidłowy indeks (indeks mniejszy niż zero lub większy lub równy rozmiarowi ciągu) przekazany do funkcji at składowej zgłasza out_of_range wyjątek klasy . Nieprawidłowy indeks przekazany do operator[] powoduje niezdefiniowane zachowanie, ale indeks równy długości ciągu jest prawidłowym indeksem dla ciągów const, a operator zwraca znak null po przekazaniu tego indeksu.

Zwrócone odwołanie może zostać unieważnione przez reallocations ciągu lub modyfikacje dla ciągów innychconst niż ciągi.

Podczas kompilowania z ustawioną wartością _ITERATOR_DEBUG_LEVEL 1 lub 2 w przypadku próby uzyskania dostępu do elementu spoza granic ciągu wystąpi błąd środowiska uruchomieniowego. Aby uzyskać więcej informacji, zobacz Sprawdzono iteratory.

Przykład

// 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, który dostarcza wskaźnik do elementu znaku w ciągu lub tablicy znaków.

typedef typename allocator_type::pointer pointer;

Uwagi

Typ jest synonimem .allocator_type::pointer

Dla typu stringjest to odpowiednik char *.

Przykład

// 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`

Usuwa ostatni element ciągu.

void pop_back();

Uwagi

Ta funkcja składowa skutecznie wywołuje erase(size() - 1) metodę wymazania ostatniego elementu sekwencji, który musi być niepusty.

`basic_string::push_back`

Dodaje element na końcu ciągu.

void push_back(value_type char_value);

Parametry

char_value
Znak, który ma zostać dodany na końcu ciągu.

Uwagi

Funkcja składowa skutecznie wywołuje funkcję insert( end, char_value ). Aby uzyskać więcej informacji, zobacz tematy insert oraz end.

Przykład

// 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`

Zwraca iterator do pierwszego elementu w odwróconym ciągu.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Wartość zwracana

Zwraca iterator dostępu losowego do pierwszego elementu w odwróconym ciągu, zwracając się do tego, co byłoby ostatnim elementem w odpowiadającym niereversed ciągu.

Uwagi

rbegin jest używany z odwróconym ciągiem, tak jak begin jest używany z ciągiem.

Jeśli wartość zwracana rbegin elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu ciągu. Jeśli zwracana wartość rbegin elementu jest przypisana do reverse_iteratorobiektu , można zmodyfikować obiekt ciągu.

rbegin można użyć do zainicjowania iteracji za pomocą ciągu wstecz.

Przykład

// 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, który zawiera odwołanie do elementu przechowywanego w ciągu.

typedef typename allocator_type::reference reference;

Uwagi

reference Typ może służyć do modyfikowania wartości elementu.

Typ jest synonimem .allocator_type::reference

Dla typu stringjest to odpowiednik chr&.

Przykład

Zobacz przykład, aby zapoznać się z przykładem at sposobu deklarowania i używania elementu reference.

`basic_string::rend`

Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym ciągu.

const_reverse_iterator rend() const;

reverse_iterator rend();

Wartość zwracana

Iterator odwrotnego dostępu losowego, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym ciągu.

Uwagi

rend jest używany z odwróconym ciągiem, tak jak end jest używany z ciągiem.

Jeśli wartość zwracana rend elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu ciągu. Jeśli zwracana wartość rend elementu jest przypisana do reverse_iteratorobiektu , można zmodyfikować obiekt ciągu.

rend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec jego ciągu.

Wartość zwracana przez rend nie powinna być wyłuszczone.

Przykład

// 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`

Zastępuje elementy w ciągu na określonej pozycji określonymi znakami lub znakami skopiowanymi z innych zakresów, ciągów lub ciągów 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
Ciąg, który ma być źródłem znaków dla ciągu operandu.

position_1
Indeks ciągu operandu, w którym rozpoczyna się zamiana.

number_1
Maksymalna liczba znaków do zastąpienia w ciągu operandu.

position_2
Indeks ciągu parametru, w którym rozpoczyna się kopiowanie.

number_2
Maksymalna liczba znaków do użycia z parametru C-string.

ptr
Ciąg C, który ma być źródłem znaków dla ciągu operandu.

char_value
Znak, który ma zostać skopiowany do ciągu operandu.

first0
Iterator odnoszący się do pierwszego znaku, który ma zostać usunięty w ciągu operandu.

last0
Iterator odnoszący się do ostatniego znaku, który ma zostać usunięty w ciągu operandu.

first
Iterator, const_pointer lub const_iterator adresowanie pierwszego znaku do skopiowania w ciągu parametru.

last
Iterator, const_pointer lub const_iterator odnoszący się do ostatniego znaku, który ma zostać skopiowany w ciągu parametru.

count
Liczba operacji char_value jest kopiowana do ciągu operandu.

Wartość zwracana

Ciąg operandu ze wykonanym zastąpieniem.

Przykład

// 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`

Ustawia pojemność ciągu na liczbę co najmniej tak dużą, jak określona liczba.

void reserve(size_type count = 0);

Parametry

count
Liczba znaków, dla których pamięć jest zarezerwowana.

Uwagi

Posiadanie wystarczającej pojemności jest ważne, ponieważ lokalizacja rzeczywista jest czasochłonnym procesem. Ponadto unieważnia wszystkie odwołania, wskaźniki i iteratory odwołujące się do znaków w ciągu.

Koncepcja pojemności typów obiektów ciągów jest taka sama jak w przypadku obiektów typu vector. W przeciwieństwie do vectorfunkcji reserve składowej może być wywoływana w celu zmniejszenia pojemności obiektu. Żądanie jest niezwiązane i może się zdarzyć lub nie. Ponieważ wartość domyślna parametru to zero, wywołanie reserve metody jest żądaniem niewiążącym, aby zmniejszyć pojemność ciągu, aby dopasować liczbę znaków aktualnie w ciągu. Pojemność nigdy nie jest zmniejszana poniżej bieżącej liczby znaków.

Wywołanie reserve to jedyny możliwy sposób zmniejszania pojemności ciągu. Jak wspomniano powyżej, to żądanie nie jest jednak wiązane i może się nie zdarzyć.

Przykład

// 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`

Określa nowy rozmiar ciągu, dołączanie lub wymazywanie elementów zgodnie z potrzebami.

void resize(
    size_type count,);

void resize(
    size_type count,
    value_type char_value);

Parametry

count
Nowy rozmiar ciągu.

char_value
Wartość, z którą dołączane znaki są inicjowane, jeśli jest wymagana większa liczba elementów.

Uwagi

Jeśli wynikowy rozmiar przekracza maksymalną liczbę znaków, formularz zgłasza wartość length_error.

Przykład

// 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, który zawiera odwołanie do elementu przechowywanego w ciągu.

typedef std::reverse_iterator<iterator> reverse_iterator;

Uwagi

Typ reverse_iterator może służyć do modyfikowania wartości znaku i służy do iterowania przez ciąg odwrotnie.

Przykład

Zobacz przykład, aby zapoznać się z przykładem rbegin sposobu deklarowania i używania elementu reverse_iterator.

`basic_string::rfind`

Wyszukuje ciąg w kierunku wstecznym dla pierwszego wystąpienia podciągów, który pasuje do określonej sekwencji znaków.

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
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks pozycji, w której ma rozpocząć się wyszukiwanie.

ptr
Ciąg C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczając do przodu od pierwszego znaku, w ciągu C, dla którego ma być wyszukiwana funkcja składowa.

str
Ciąg, dla którego ma być wyszukiwana funkcja składowa.

Wartość zwracana

Indeks ostatniego wystąpienia, podczas wyszukiwania do tyłu, pierwszego znaku podciągów po pomyślnym zakończeniu; w przeciwnym razie npos.

Przykład

// 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`

Odrzuca nadmiarową pojemność ciągu.

void shrink_to_fit();

Uwagi

Ta funkcja składowa eliminuje wszelkie niepotrzebne magazyny w kontenerze.

`basic_string::size`

Zwraca bieżącą liczbę elementów w ciągu.

size_type size() const;

Wartość zwracana

Długość ciągu.

Przykład

// 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`

Niepodpisany typ liczb całkowitych, który może reprezentować liczbę elementów i indeksów w ciągu.

typedef typename allocator_type::size_type size_type;

Uwagi

jest ona równoważna .allocator_type::size_type

Dla typu stringjest to odpowiednik size_t.

Przykład

// 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`

Sprawdź, czy ciąg rozpoczyna się od określonego prefiksu.

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
Prefiks pojedynczego znaku do wyszukania.

sv
Widok ciągu zawierający prefiks do wyszukania.
Można przekazać element std::basic_string, który konwertuje na widok ciągu.

x
Ciąg znaków o wartości null zawierający prefiks do wyszukania.

Wartość zwracana

true jeśli ciąg rozpoczyna się od określonego prefiksu; false inaczej.

Uwagi

starts_with() jest nowy w języku C++20. Aby go użyć, określ lub nowszą /std:c++20 opcję kompilatora.

Zobacz ends_with , czy ciąg kończy się określonym sufiksem.

Przykład

// 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`

Kopiuje podciąg z co najwyżej pewnej liczby znaków z ciągu rozpoczynającego się od określonej pozycji.

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

Parametry

offset
Indeks lokalizujący element na pozycji, z której jest wykonana kopia ciągu, z wartością domyślną 0.

count
Liczba znaków, które mają zostać skopiowane, jeśli są obecne.

Wartość zwracana

Obiekt podciągowy, który jest kopią elementów operandu ciągów, zaczynając od pozycji określonej przez pierwszy argument.

Przykład

// 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`

Wymiana zawartości dwóch ciągów.

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

Parametry

str
Ciąg źródłowy, którego elementy mają być wymieniane z elementami w ciągu docelowym.

Uwagi

Jeśli zamieniane ciągi mają ten sam obiekt alokatora, funkcja składowa swap :

Występuje w stałym czasie.
Nie zgłasza żadnych wyjątków.
Unieważnia brak odwołań, wskaźników ani iteratorów, które wyznaczają elementy w dwóch ciągach.

W przeciwnym razie powoduje, że przypisania elementów i konstruktor wywołuje proporcjonalnie do liczby elementów w dwóch kontrolowanych sekwencjach.

Przykład

// 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 cech znaków elementów przechowywanych w ciągu.

typedef Traits traits_type;

Uwagi

Typ jest synonimem drugiego parametru Traitsszablonu .

Dla typu stringjest to odpowiednik char_traits<char>.

Przykład

Zobacz przykład, aby zapoznać się z przykładem copy sposobu deklarowania i używania elementu traits_type.

`basic_string::value_type`

Typ reprezentujący typ znaków przechowywanych w ciągu.

typedef typename allocator_type::value_type value_type;

Uwagi

Jest ona równoważna obiektom traits_type::char_type typu i jest równoważna char obiektom typu string.

Przykład

// 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.

Zobacz też

<string>
Bezpieczeństwo wątków w standardowej bibliotece języka C++

Udostępnij za pośrednictwem

basic_string Klasa

Składnia

Parametry

Konstruktory

Typedefs

Funkcje składowe

Operatory

Literały

Uwagi

Wymagania

basic_string::allocator_type

Uwagi

Przykład

basic_string::append

Parametry

Wartość zwracana

Uwagi

Przykład

basic_string::assign

Parametry

Wartość zwracana

Uwagi

Przykład

basic_string::at

Parametry

Wartość zwracana

Uwagi

Przykład

basic_string::back

Wartość zwracana

Uwagi

basic_string::basic_string

Parametry

Wartość zwracana

Uwagi

Przykład

basic_string::begin

Wartość zwracana

Przykład

basic_string::c_str

Wartość zwracana

Uwagi

Przykład

basic_string::capacity

Wartość zwracana

Uwagi

Przykład

basic_string::cbegin

Wartość zwracana

Uwagi

basic_string::cend

Wartość zwracana

Uwagi

basic_string::clear

Uwagi

Przykład

basic_string::compare

Parametry

Wartość zwracana

Uwagi

Przykład

basic_string::const_iterator

Uwagi

Przykład

basic_string::const_pointer

Uwagi

Przykład

basic_string::const_reference

Uwagi

Przykład

basic_string::const_reverse_iterator

Uwagi

Przykład

basic_string::copy

Parametry

Wartość zwracana

Uwagi

Przykład

basic_string::crbegin

`basic_string` Klasa

`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`