basic_string osztály

A típusobjektum basic_string által vezérelt sorozatok a Standard C++ sztringosztályok, amelyeket sztringeknek neveznek, de nem szabad összetéveszteni őket a C++ standard kódtárban használt null értékű C-stílusú sztringekkel. A Standard C++ sztring egy tároló, amely lehetővé teszi a sztringek normál típusként való használatát, például összehasonlítási és összefűzési műveleteket, iterátorokat, C++ standard kódtáralgoritmusokat, valamint osztályelosztó által felügyelt memóriával végzett másolást és hozzárendelést. Ha egy standard C++ sztringet null értékű C-stílusú sztringgé kell alakítania, használja a basic_string::c_str tagot.

Szemantika

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

Paraméterek

CharType
A sztringben tárolandó egyetlen karakter adattípusa. A C++ standard kódtár az osztálysablon specializációit tartalmazza, a típusdefiníciókat string a char, wstring, wchar_t, u16stringchar16_tés u32stringchar32_t.

Traits
A basic_string specializáció elemeinek különböző fontos tulajdonságait CharType az osztály Traitsírja le. Az alapértelmezett érték a következő char_traits<CharType>: .

Allocator
Az a típus, amely a tárolt kiosztó objektumot jelöli, amely a sztring lefoglalásával és a memória felszabadítással kapcsolatos részleteket foglalja magában. Az alapértelmezett érték a allocator<CharType>.

Konstruktorok

Konstruktor	Leírás
basic_string	Olyan sztringet hoz létre, amely üres vagy adott karakterek által inicializálva van, vagy egy másik sztringobjektum vagy C-sztring egészének vagy egy részének másolata.

Typedefs

Típus neve	Leírás
allocator_type	Egy sztringobjektum osztályát képviselő allocator típus.
const_iterator	Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely hozzáfér a sztring egy const eleméhez, és beolvassa azt.
const_pointer	Olyan típus, amely mutatót ad egy sztring egy const eleméhez.
const_reference	Olyan típus, amely egy sztringben const tárolt elemre mutató hivatkozást tartalmaz olvasási és műveletek végrehajtásához const .
const_reverse_iterator	Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes beolvasni a sztring bármely const elemét.
difference_type	Olyan típus, amely két olyan iterátor közötti különbséget biztosít, amelyek ugyanazon sztring elemeire hivatkoznak.
iterator	Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes a sztring bármely elemének olvasására vagy módosítására.
npos	A -1 inicializált aláíratlan integrálatlan érték, amely "nem található" vagy "az összes fennmaradó karaktert" jelzi, ha egy keresési függvény meghiúsul.
pointer	Olyan típus, amely egy sztring vagy karaktertömb egyik karakterelemére mutat.
reference	Olyan típus, amely egy sztringben tárolt elemre mutató hivatkozást tartalmaz.
reverse_iterator	Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes olvasni vagy módosítani egy elemet egy fordított sztringben.
size_type	Egy sztring elemeinek számához tartozó aláíratlan integráltípus.
traits_type	A sztringben tárolt elemek karaktertulajdonságainak típusa.
value_type	A sztringben tárolt karakterek típusát jelképező típus.

Tagfüggvények

Tagfüggvény	Leírás
append	Karaktereket ad hozzá egy sztring végéhez.
assign	Új karakterértékeket rendel egy sztring tartalmához.
at	A sztring egy megadott helyén lévő elemre mutató hivatkozást ad vissza.
back	A sztring utolsó elemére mutató hivatkozást ad vissza.
begin	Egy iterátort ad vissza, amely a sztring első elemét kezeli.
c_str	A sztring tartalmát C stílusú, null értékű sztringként konvertálja.
capacity	A sztringben tárolható elemek legnagyobb számát adja vissza a sztring memóriafoglalásának növelése nélkül.
cbegin	Egy konstans iterátort ad vissza, amely a sztring első elemét kezeli.
cend	Egy konstans iterátort ad vissza, amely a sztring utolsó elemét követő helyet kezeli.
clear	Törli a sztring összes elemét.
compare	Összehasonlít egy sztringet egy megadott sztringgel annak megállapításához, hogy a két sztring egyenlő-e, vagy hogy az egyik lexikálisan kisebb-e a másiknál.
copy	Legfeljebb egy megadott számú karaktert másol egy forrássztring indexelt pozíciójából egy cél karaktertömbbe. Elavult vagy megszüntetett. A basic_string::_Copy_s használható helyette.
crbegin	Egy konstans iterátort ad vissza, amely egy fordított sztring első elemét kezeli.
crend	Egy konstans iterátort ad vissza, amely egy fordított sztring utolsó elemét követő helyet kezeli.
_Copy_s	Microsoft-specifikus: Legfeljebb egy megadott számú karaktert másol egy forrássztring indexelt pozíciójából egy célkarakterekbe.
data	Egy sztring tartalmát karaktertömbökké alakítja.
empty	Ellenőrzi, hogy a sztring tartalmaz-e karaktereket.
end	Egy olyan iterátort ad vissza, amely a sztring utolsó elemét követő helyet kezeli.
ends_with C++20	Ellenőrzi, hogy a sztring a megadott utótaggal végződik-e.
erase	Eltávolít egy elemet vagy elemtartományt egy sztringben egy adott pozícióból.
find	Egy sztringet előrefelé keres egy adott karaktersorozatnak megfelelő részstring első előfordulására.
find_first_not_of	Sztringen keresztül keres olyan első karaktert, amely nem része egy adott sztringnek.
find_first_of	A megadott sztring bármely elemével egyező első karaktert keres egy sztringben.
find_last_not_of	Egy sztringben megkeresi az utolsó karaktert, amely nem egy adott sztring egyik eleme sem.
find_last_of	Sztringen keresztül keres egy adott sztring egyik eleméhez tartozó utolsó karaktert.
front	Egy sztring első elemére mutató hivatkozást ad vissza.
get_allocator	Visszaadja a allocator sztring létrehozásához használt objektum másolatát.
insert	Egy elemet, több elemet vagy elemtartományt szúr be a sztringbe egy megadott pozícióban.
length	Egy sztring elemeinek aktuális számát adja vissza.
max_size	A sztringben szereplő karakterek maximális számát adja eredményül.
pop_back	Törli a sztring utolsó elemét.
push_back	Hozzáad egy elemet a sztring végéhez.
rbegin	Egy iterátort ad vissza egy fordított sztring első elemének.
rend	Egy olyan iterátort ad vissza, amely a fordított sztring utolsó elemére mutat.
replace	A megadott pozícióban lévő sztring elemeit más tartományokból, sztringekből vagy C-sztringekből másolt megadott karakterekre vagy karakterekre cseréli.
reserve	A sztring kapacitását egy olyan számra állítja be, amely legalább akkora, mint egy megadott szám.
resize	Szükség szerint új méretet ad meg egy sztringhez, hozzáfűzve vagy törölve az elemeket.
rfind	Visszafelé keres egy sztringet egy adott karaktersorozatnak megfelelő részstring első előfordulására.
shrink_to_fit	Elveti a sztring többletkapacitását.
size	Egy sztring elemeinek aktuális számát adja vissza.
starts_with C++20	Ellenőrzi, hogy a sztring a megadott előtaggal kezdődik-e.
substr	Legfeljebb néhány karakterből álló részsztringet másol egy megadott pozícióból kezdődő sztringből.
swap	Cserélje le két sztring tartalmát.

Működtetők

Operátor	Leírás
operator+=	Karakterek hozzáfűzése egy sztringhez.
operator=	Új karakterértékeket rendel egy sztring tartalmához.
operator[]	Egy karakterlánc megadott indexével rendelkező karakterre mutató hivatkozást tartalmaz.

Literálok

A definiáló basic_string fejlécek a következő felhasználó által definiált literálokat is definiálják, amelyek a bemeneti paraméterekből létrehoznak egy megadott típusú sztringet.

Nyilatkozat	Leírás
inline string operator"" s(const char* str, size_t len)	Visszatér: string(str, len)
inline string operator"" s(const wchar_t* str, size_t len)	Visszatér: wstring(str, len)
inline basic_string<char8_t> operator"" s(const char8_t* str, size_t len)	Visszatér: basic_string<char8_t>(str, len)
inline u16string operator"" s(const char16_t* str, size_t len)	Visszatér: u16string(str, len)
inline u32string operator"" s(const char32_t* str, size_t len)	Visszatér: u32string(str, len)

Megjegyzések

Ha egy függvénynek az elemeknél max_size hosszabb sorozatot kell létrehoznia, a függvény hosszhibát jelez egy típusú length_errorobjektum dobásával.

A szabályozott sorozat elemeit kijelölő hivatkozások, mutatók és iterátorok érvénytelenné válhatnak a szabályozott sorrendet módosító függvények hívása után vagy egy nemconst tagfüggvény első hívása után.

Követelmények

Fejléc:<húr>

Névtér: std

basic_string::allocator_type

Olyan típus, amely egy sztringobjektum kiosztóosztályát jelöli.

typedef Allocator allocator_type;

Megjegyzések

A típus a Allocatorsablonparaméter szinonimája.

példa

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

Karaktereket ad hozzá egy sztring végéhez.

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);

Paraméterek

ptr
A hozzáfűzendő C-sztring.

str
A sztring, amelynek karaktereit hozzá kell fűzni.

offset
A forrássztring azon részének indexe, amely a hozzáfűzendő karaktereket tartalmazza.

count
Legfeljebb a forrássztringből hozzáfűzendő karakterek száma.

char_value
A hozzáfűzendő karakterérték.

first
Egy bemeneti iterátor, amely a hozzáfűzendő tartomány első elemét kezeli.

last
Egy bemeneti iterátor, const_pointervagy const_iterator a hozzáfűzendő tartomány utolsó elemén túli helyzetének kezelése.

Visszaadott érték

Hivatkozás a tagfüggvény által átadott karakterekkel kiegészített sztringobjektumra.

Megjegyzések

A karakterek egy sztringhez fűzhetők a operator+= tagfüggvények vagy a tagfüggvények append használatával push_back. operator+= összefűzi az egy argumentumból álló értékeket, míg a több argumentumból append álló tagfüggvény lehetővé teszi egy sztring adott részének megadását a hozzáadáshoz.

példa

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

Új karakterértékeket rendel egy sztring tartalmához.

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);

Paraméterek

ptr
Mutató a célsztringhez hozzárendelendő C-sztring karaktereihez.

count
A forrássztringből hozzárendelendő karakterek száma.

str
A forrássztring, amelynek karaktereit hozzá kell rendelni a célsztringhez.

char_value
A hozzárendelni kívánt karakterérték.

first
Bemeneti iterátor, const_pointer vagy const_iterator, amely a céltartományhoz rendelendő forrássztring tartományának első karakterét kezeli.

last
Bemeneti iterátor, const_pointer vagy const_iterator, amely a céltartományhoz hozzárendelendő forrássztring tartományának utolsó karakterén túli karaktert kezeli.

off
Az a pozíció, ahol az új karakterek hozzá lesznek rendelve.

Visszaadott érték

Hivatkozás arra a sztringobjektumra, amelyet a tagfüggvény új karakterekhez rendel.

Megjegyzések

A sztringek új karakterértékekhez rendelhetők. Az új érték lehet sztring és C-sztring, vagy egy karakter. Ez operator= akkor használható, ha az új érték egyetlen paraméterrel írható le; ellenkező esetben a több paramétert tartalmazó tagfüggvény assignsegítségével megadhatja, hogy a sztring melyik része legyen hozzárendelve egy célsztringhez.

példa

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

Egy karakterlánc megadott indexével rendelkező karakterre mutató hivatkozást tartalmaz.

const_reference at(size_type offset) const;

reference at(size_type offset);

Paraméterek

offset
A hivatkozni kívánt elem pozíciójának indexe.

Visszaadott érték

Hivatkozás a sztring karakterére a paraméterindex által megadott helyen.

Megjegyzések

A sztring első eleme nulla indexű, a következő elemeket pedig egymás után indexelik a pozitív egész számok, így az n hosszúságú sztring n-edikelemét az n - 1 szám indexeli.

A tag operator[] gyorsabb, mint a tagfüggvény at , amely olvasási és írási hozzáférést biztosít egy sztring elemeihez.

A tag operator[] nem ellenőrzi, hogy a paraméterként átadott index érvényes-e, de a tagfüggvény at igen, ezért akkor kell használni, ha az érvényesség nem biztos. A tagfüggvénynek at átadott érvénytelen index, amely egy olyan index, amely nem nulla vagy nagyobb, mint a sztring mérete, osztálykivételt out_of_range eredményez. Érvénytelen indexet ad át az operator[] eredményeknek meghatározatlan viselkedéssel, de a sztring hosszával egyenlő index érvényes index a const sztringekhez, az operátor pedig null karaktert ad vissza az index átadásakor.

A visszaadott hivatkozás érvényteleníthető a nem sztringek karakterlánc-újraelosztásávalconst vagy módosításával.

példa

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

A sztring utolsó elemére mutató hivatkozást ad vissza.

const_reference back() const;

reference back();

Visszaadott érték

A sztring utolsó elemére mutató hivatkozás, amelynek nem szabad üresnek lennie.

Megjegyzések

basic_string::basic_string

Üres, meghatározott karakterek által inicializált, vagy egy másik sztringobjektum vagy C típusú (null értékű) sztring egészének vagy egy részének másolata.

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);

Paraméterek

ptr
Az a C-sztring, amelynek karaktereit a string létrehozandó szöveg inicializálásához kell használni. Ez az érték csak akkor lehet null mutató, ha count nulla.

alloc_type
A létrehozandó sztringobjektum tárolóelosztó osztálya.

count
Az inicializálandó karakterek száma.

right
A létrehozandó sztring inicializálására vonatkozó karakterlánc.

right_offset
Egy sztringben lévő karakter indexe, amely elsőként használható a létrehozott sztring karakterértékeinek inicializálására.

char_value
A létrehozandó sztringbe másolandó karakterérték.

first
Bemeneti iterátor, const_pointer vagy const_iterator a beszúrni kívánt forrástartomány első elemével.

last
Bemeneti iterátor, const_pointer vagy const_iterator a beszúrni kívánt forrástartomány utolsó elemén túli helyzetével foglalkozik.

Visszaadott érték

Hivatkozás a konstruktorok által létrehozott sztringobjektumra.

Megjegyzések

Minden konstruktor tárol egy basic_string::allocator_type és inicializálja a szabályozott sorozatot. A kiosztó objektum az argumentum al, ha van ilyen. A másolási konstruktorhoz ez right.get_allocator()egy hívás basic_string::get_allocator. Ellenkező esetben a kiosztó a Alloc().

A szabályozott sorozat inicializálása a többi operandus által megadott operandus-sorozat egy példányára történik. Az operandus nélküli konstruktor üres kezdeti vezérelt sorozatot ad meg. Ha InputIterator egy sablonkonstruktor egész számtípusa, az operandus-sorozat first, last ugyanúgy viselkedik, mint (size_type) first, (value_type) lasta .

példa

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

Egy iterátort ad vissza, amely a sztring első elemét kezeli.

const_iterator begin() const;

iterator begin();

Visszaadott érték

Véletlenszerű hozzáférésű iterátor, amely a sorozat első elemével foglalkozik, vagy csak egy üres sorozat végén.

példa

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

Egy sztring tartalmát C stílusú, null értékű sztringként alakítja át.

const value_type *c_str() const;

Visszaadott érték

Az invokáló sztring C-stílusú verziójára mutató mutató. A mutató értéke nem érvényes, ha nem függvénytconst hív meg, beleértve a destruktort is az basic_string objektum osztályában.

Megjegyzések

Az osztálysablonhoz basic_string<char> tartozó típussztring-objektumok nem feltétlenül null értékűek. A null karakter '\0' egy C-sztring speciális karaktereként használatos a sztring végének megjelöléséhez, de nincs különleges jelentése egy sztring típusú objektumban, és a sztring része lehet, mint bármely más karakter. A sztringek automatikusan const char * sztringekké alakulnak át, de a sztringosztály nem biztosít automatikus átalakítást C stílusú sztringekből típusú basic_string<char>objektumokká.

A visszaadott C-stílusú sztringet nem szabad módosítani, ami érvénytelenné teheti a sztringre mutató mutatót, vagy törölhető, mivel a sztring élettartama korlátozott, és az osztálysztring tulajdonában van.

példa

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

A sztringben tárolható elemek legnagyobb számát adja vissza a sztring memóriafoglalásának növelése nélkül.

size_type capacity() const;

Visszaadott érték

A memóriában a sztring tárolásához jelenleg lefoglalt tárterület mérete.

Megjegyzések

A tagfüggvény visszaadja a szabályozott sorozat tárolásához jelenleg lefoglalt tárolót, amely legalább akkora, mint sizea .

példa

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

Egy const iterátort ad vissza, amely a tartomány első elemét kezeli.

const_iterator cbegin() const;

Visszaadott érték

Egy const véletlenszerű hozzáférésű iterátor, amely a tartomány első elemére mutat, vagy az üres tartomány végén túl eső helyre (üres tartomány esetén cbegin() == cend()).

Megjegyzések

A cbeginvisszatérési értékével a tartomány elemei nem módosíthatók.

Ezt a tagfüggvényt a begin() tagfüggvény helyett használhatja annak garantálásához, hogy a visszatérési érték const_iterator. Általában a típuslevonási kulcsszóval auto együtt használják, ahogy az az alábbi példában is látható. A példában tekintsük Container úgy, hogy egy módosítható (nemconst) tároló bármilyen típusú, amely támogatja és begin()támogatjacbegin().

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

// i2 is Container<T>::const_iterator

basic_string::cend

Egy const iterátort ad vissza, amely a tartomány utolsó elemén túli helyet kezeli.

const_iterator cend() const;

Visszaadott érték

Véletlenszerű const hozzáférésű iterátor, amely a tartomány végén túlra mutat.

Megjegyzések

cend annak ellenőrzésére szolgál, hogy egy iterátor teljesítette-e a tartomány végét.

Ezt a tagfüggvényt a end() tagfüggvény helyett használhatja annak garantálásához, hogy a visszatérési érték const_iterator. Általában a típuslevonási kulcsszóval auto együtt használják, ahogy az az alábbi példában is látható. A példában tekintsük Container úgy, hogy egy módosítható (nemconst) tároló bármilyen típusú, amely támogatja és end()támogatjacend().

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

// i2 is Container<T>::const_iterator

A cend által visszaadott értéket nem szabad elhalasztani.

basic_string::clear

Törli a sztring összes elemét.

void clear();

Megjegyzések

A tagfüggvényt meghívó sztring üres lesz.

példa

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

A megadott sztringekkel való kis- és nagybetűk megkülönböztetése határozza meg, hogy a két sztring egyenlő-e, vagy az egyik lexikálisan kisebb-e a másiknál.

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;

Paraméterek

str
Az operandus sztringgel összehasonlítandó sztring.

position_1
Annak az operandus-sztringnek az indexe, amelyen az összehasonlítás megkezdődik.

number_1
Az összehasonlítandó operandus sztring karaktereinek maximális száma.

number_2
Az összehasonlítandó paramétersztring karaktereinek maximális száma.

offset
Annak a paramétersztringnek az indexe, amelynél az összehasonlítás megkezdődik.

count
Az összehasonlítandó paramétersztring karaktereinek maximális száma.

ptr
Az operandus sztringhez hasonlítandó C-sztring.

Visszaadott érték

Negatív érték, ha az operandus sztring kisebb, mint a paramétersztring; nulla, ha a két sztring egyenlő; vagy pozitív értéket, ha az operandus sztring nagyobb, mint a paramétersztring.

Megjegyzések

A compare tagfüggvények a paraméter és az operandus sztringek egészét vagy egy részét hasonlítják össze attól függően, hogy melyikben használják.

Az összehasonlítás megkülönbözteti a kis- és nagybetűkét.

példa

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

Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely hozzáfér a sztring egy const eleméhez, és beolvassa azt.

typedef implementation-defined const_iterator;

Megjegyzések

A típus const_iterator nem használható egy karakter értékének módosítására, és a sztringek előrefelé történő iterálására szolgál.

példa

A deklarálásához és használatához beginlásd a példátconst_iterator.

basic_string::const_pointer

Olyan típus, amely mutatót ad egy sztring egy const eleméhez.

typedef typename allocator_type::const_pointer const_pointer;

Megjegyzések

A típus a szinonimája.allocator_type::const_pointer

Típus stringesetén ez egyenértékű a következőval char*: .

A const deklarált mutatókat inicializálni kell a deklaráláskor. A const-mutatók mindig ugyanarra a memóriahelyre mutatnak, és állandó vagy nem állandó adatokra mutathatnak.

példa

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

Olyan típus, amely egy sztringben const tárolt elemre mutató hivatkozást tartalmaz olvasási és műveletek végrehajtásához const .

typedef typename allocator_type::const_reference const_reference;

Megjegyzések

Egy const_reference típus nem használható elem értékének módosítására.

A típus a szinonimája.allocator_type::const_reference Típus stringesetén ez a const értéknek felel meg char&.

példa

A deklarálásához és használatához atlásd a példátconst_reference.

basic_string::const_reverse_iterator

Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes beolvasni a sztring bármely const elemét.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Megjegyzések

A típus const_reverse_iterator nem tudja módosítani egy karakter értékét, és fordított sztringen keresztüli iterálásra szolgál.

példa

A deklarálásához és használatához rbeginlásd a példátconst_reverse_iterator.

basic_string::copy

Legfeljebb egy megadott számú karaktert másol egy forrássztring indexelt pozíciójából egy cél karaktertömbbe.

Ez a módszer potenciálisan nem biztonságos, mivel a hívóra támaszkodva ellenőrzi, hogy az átadott értékek helyesek-e. Fontolja meg inkább a basic_string::_Copy_s használatát.

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

Paraméterek

ptr
A cél karaktertömb, amelybe az elemeket át szeretné másolni.

count Legfeljebb a forrássztringből másolandó karakterek száma.

offset
A forrássztring kezdőpozíciója, amelyből másolatokat szeretne készíteni.

Visszaadott érték

A másolt karakterek száma.

Megjegyzések

A program nem fűz hozzá null karaktert a másolat végéhez.

példa

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

Egy konstans iterátort ad vissza, amely egy fordított sztring első elemét kezeli.

const_reverse_iterator crbegin() const;

Visszaadott érték

Fordított iterátor, amely a sztring végén túlra mutat. A pozíció a fordított sztring elejét jelöli.

basic_string::crend

Egy olyan iterátort const ad vissza, amely a fordított sztring utolsó elemét követő helyet kezeli.

const_reverse_iterator crend() const;

Visszaadott érték

Fordított const iterátor, amely egy fordított sztring utolsó elemét (a fordított sztring első elemét megelőző helyet) kezeli.

Megjegyzések

basic_string::_Copy_s

Legfeljebb egy megadott számú karaktert másol egy forrássztring indexelt pozíciójából egy cél karaktertömbbe.

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

Paraméterek

dest
A cél karaktertömb, amelybe az elemeket át szeretné másolni.

dest_size
A dest mérete.

count Legfeljebb a forrássztringből másolandó karakterek száma.

offset
A forrássztring kezdőpozíciója, amelyből másolatokat szeretne készíteni.

Visszaadott érték

A másolt karakterek száma.

Megjegyzések

A program nem fűz hozzá null karaktert a másolat végéhez. Ez a függvény Microsoft-specifikus.

példa

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

A sztring tartalmát null értékű karaktertömbté alakítja.

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

Visszaadott érték

A sztring tartalmát tartalmazó null értékű tömb első elemére mutató mutató. Üres sztring esetén a mutató egyetlen null karakterre mutat, amely egyenlő.value_type()

Megjegyzések

A mutató egy érvényes tartományban datalévő pontok által [data(), data() + size()] visszaadott mutató. A tartomány minden eleme megfelel a sztring aktuális adatainak. Vagyis a tartomány minden érvényes eltolásáhozn. data() + n == addressof(operator[](n))

Ha módosítja a túlterhelés constáltal visszaadott sztring data tartalmát, a viselkedés nincs meghatározva. Nem definiált viselkedést is kaphat, ha a terminál null karaktere bármilyen más értékre módosul. A visszaadott mutató érvényteleníthető, ha a sztringre nemconst mutató hivatkozást ad át egy szabványos kódtárfüggvénynek. A nem tagfüggvényekconst hívása is érvényteleníthető. Meghívja a tagokat at, back, begin, end, front, rbegin, , , rend, és operator[] ne érvénytelenítse az egérmutatót.

A C++11 előtt nem garantálták, data hogy a visszaadott sztring null értékű volt. Mivel a C++11, data és c_str mindkettő null értékű sztringet ad vissza, és gyakorlatilag megegyeznek.

A nem túlterheltségconst új a C++17-ben. A használatához adja meg a /std:c++17 vagy újabb fordító lehetőséget.

példa

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

Olyan típus, amely két olyan iterátor közötti különbséget biztosít, amelyek ugyanazon sztring elemeire hivatkoznak.

typedef typename allocator_type::difference_type difference_type;

Megjegyzések

Az aláírt egész szám típusa olyan objektumot ír le, amely a szabályozott sorozat két elemének címe közötti különbséget jelentheti.

Típus stringesetén ez egyenértékű a következőval ptrdiff_t: .

példa

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

Ellenőrzi, hogy a sztring tartalmaz-e karaktereket.

bool empty() const;

Visszaadott érték

true ha a sztringobjektum nem tartalmaz karaktereket; false ha legalább egy karakterből áll.

Megjegyzések

A tagfüggvény == 0-nak felel meg size .

példa

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

Egy olyan iterátort ad vissza, amely a sztring utolsó elemét követő helyet kezeli.

const_iterator end() const;

iterator end();

Visszaadott érték

Egy véletlenszerű hozzáférésű iterátort ad vissza, amely a sztring utolsó elemét követő helyet kezeli.

Megjegyzések

end gyakran használják annak tesztelésére, hogy egy iterátor elérte-e a sztring végét. A end által visszaadott értéket nem szabad elhalasztani.

Ha a visszaadott end érték egy const_iteratoradotthoz van rendelve, a sztringobjektum nem módosítható. Ha a visszatérési end érték egy adotthoz van rendelve, a sztringobjektum iteratormódosítható.

példa

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

Ellenőrizze, hogy a sztring a megadott utótaggal végződik-e.

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;

Paraméterek

c
A keresendő egyetlen karakter utótagja.

sv
A keresendő utótagot tartalmazó sztringnézet.
Átadhatja a sztringnézetté std::basic_stringkonvertált elemeket.

x
A keresendő utótagot tartalmazó null értékű karaktersztring.

Visszaadott érték

true ha a sztring a megadott utótaggal végződik; false egyébként.

Megjegyzések

ends_with() a C++20-ban új. A használatához adja meg a /std:c++20 vagy újabb fordító lehetőséget.

Ellenőrizze starts_with , hogy egy sztring a megadott előtaggal kezdődik-e.

példa

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

Eltávolít egy elemet vagy elemtartományt egy sztringben egy adott pozícióból.

iterator erase(
    iterator first,
    iterator last);

iterator erase(
    iterator iter);

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

Paraméterek

first
A törölni kívánt tartomány első elemének pozícióját megadó iterátor.

last
Egy iterátor, amely a törölni kívánt tartomány utolsó elemét megelőző pozíciót kezeli.

iter
A törölni kívánt sztring elemének pozícióját megadó iterátor.

offset
Az eltávolítandó sztring első karakterének indexe.

count
Az eltávolítandó elemek száma, ha a sztring tartományában a következővel kezdődik offset: .

Visszaadott érték

Az első két tagfüggvény esetében egy iterátor, amely a tagfüggvény által eltávolított utolsó karakter után az első karaktert kezeli. A harmadik tagfüggvény esetében egy hivatkozás arra a sztringobjektumra, amelyből az elemek törlődtek.

Megjegyzések

A harmadik tagfüggvény ad *thisvissza.

példa

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

Egy sztringet előrefelé keres egy adott karaktersorozatnak megfelelő részstring első előfordulására.

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;

Paraméterek

char_value
Az a karakterérték, amelyre a tagfüggvény keres.

offset
A keresés megkezdéséhez használt pozíció indexe.

ptr
Az a C-sztring, amelyre a tagfüggvény keres.

count
Az első karaktertől előre számolt karakterek száma abban a C-sztringben, amelyben a tagfüggvény keres.

str
Az a sztring, amelyre a tagfüggvény keres.

Visszaadott érték

Az alsztring első karakterének indexe, amelyet sikeresség esetén keresnek; egyéb esetben npos.

példa

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

Egy sztringen keresztül keres olyan első karaktert, amely nem egy adott sztring eleme.

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;

Paraméterek

char_value
Az a karakterérték, amelyre a tagfüggvény keres.

offset
A keresés megkezdéséhez használt pozíció indexe.

ptr
Az a C-sztring, amelyre a tagfüggvény keres.

count
Az első karaktertől előre számolt karakterek száma abban a C-sztringben, amelyben a tagfüggvény keres.

str
Az a sztring, amelyre a tagfüggvény keres.

Visszaadott érték

Az alsztring első karakterének indexe, amelyet sikeresség esetén keresnek; egyéb esetben npos.

példa

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

A megadott sztring bármely elemével egyező első karaktert keres egy sztringben.

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;

Paraméterek

char_value
Az a karakterérték, amelyre a tagfüggvény keres.

offset
A keresés megkezdéséhez használt pozíció indexe.

ptr
Az a C-sztring, amelyre a tagfüggvény keres.

count
Az első karaktertől előre számolt karakterek száma abban a C-sztringben, amelyben a tagfüggvény keres.

str
Az a sztring, amelyre a tagfüggvény keres.

Visszaadott érték

Az alsztring első karakterének indexe, amelyet sikeresség esetén keresnek; egyéb esetben npos.

példa

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

Egy sztringben megkeresi az utolsó karaktert, amely nem egy adott sztring egyik eleme sem.

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;

Paraméterek

char_value
Az a karakterérték, amelyre a tagfüggvény keres.

offset
A keresés befejezéséhez használt pozíció indexe.

ptr
Az a C-sztring, amelyre a tagfüggvény keres.

count
Az első karaktertől előre számolt karakterek száma abban a C-sztringben, amelyben a tagfüggvény keres.

str
Az a sztring, amelyre a tagfüggvény keres.

Visszaadott érték

Az alsztring első karakterének indexe, amelyet sikeresség esetén keresnek; egyéb esetben npos.

példa

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

Egy adott sztring bármely elemének megfelelő utolsó karaktert keres egy sztringben.

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;

Paraméterek

char_value
Az a karakterérték, amelyre a tagfüggvény keres.

offset
A keresés befejezéséhez használt pozíció indexe.

ptr
Az a C-sztring, amelyre a tagfüggvény keres.

count
Az első karaktertől előre számolt karakterek száma abban a C-sztringben, amelyben a tagfüggvény keres.

str
Az a sztring, amelyre a tagfüggvény keres.

Visszaadott érték

A sikeres keresés során keresett alsztring utolsó karakterének indexe; egyéb esetben npos.

példa

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

Egy sztring első elemére mutató hivatkozást ad vissza.

const_reference front() const;

reference front();

Visszaadott érték

A sztring első elemére mutató hivatkozás, amelynek nem szabad üresnek lennie.

Megjegyzések

basic_string::get_allocator

A sztring létrehozásához használt kiosztó objektum másolatát adja vissza.

allocator_type get_allocator() const;

Visszaadott érték

A sztring által használt kiosztó.

Megjegyzések

A tagfüggvény visszaadja a tárolt kiosztó objektumot.

A sztringosztály kiosztói határozzák meg, hogy az osztály hogyan kezeli a tárterületet. A tárolóosztályokhoz megadott alapértelmezett kiosztók elegendőek a legtöbb programozási igényhez. A saját kiosztóosztály írása és használata egy speciális C++ funkció.

példa

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

Egy elemet, több elemet vagy elemtartományt szúr be a sztringbe egy megadott pozícióban.

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,
    value_type char_value);

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);

Paraméterek

position
Az új karakterek beszúrási pontja mögötti pozíció indexe.

ptr
A teljes egészében vagy részben a sztringbe beszúrandó C-sztring.

count
A beszúrandó karakterek száma.

str
A célsztringbe részben vagy egészben beillesztendő sztring.

offset
A forrássztring azon részének indexe, amely a hozzáfűzendő karaktereket tartalmazza.

char_value
A beszúrni kívánt elemek karakterértéke.

iter
Egy iterátor, amely azt a pozíciót kezeli, amely mögé be kell szúrni egy karaktert.

first
Bemeneti iterátor, const_pointervagy const_iterator a beszúrni kívánt forrástartomány első elemének kezelése.

last
Bemeneti iterátor, const_pointervagy const_iterator a beszúrni kívánt forrástartomány utolsó elemén túli helyzetének kezelése.

Visszaadott érték

Az értéket visszaadó függvények a következők:

• Az eredeti sztringet basic_string és az új karaktereket tartalmazó hivatkozás.
• Egy iterátor a beszúrt karakter(ek) elején.

példa

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

Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely hozzáfér a sztring egy const eleméhez, és beolvassa azt.

typedef implementation-defined iterator;

Megjegyzések

Egy karakter értékének módosítására használható típus iterator , amely egy sztring előrefelé irányuló iterációjára szolgál.

példa

A deklarálásához és használatához beginlásd a példátiterator.

basic_string::length

Egy sztring elemeinek aktuális számát adja vissza.

size_type length() const;

Megjegyzések

A tagfüggvény megegyezik sizea .

példa

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

A sztringben szereplő karakterek maximális számát adja eredményül.

size_type max_size() const;

Visszaadott érték

Az a maximális karakterszám, ahány karaktert tartalmazhat egy sztring.

Megjegyzések

Az osztálytípuslength_error kivétele akkor fordul elő, ha egy művelet a maximális méretnél nagyobb hosszúságú sztringet hoz létre.

példa

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

A -1 inicializált aláíratlan integrálatlan érték, amely "nem található" vagy "az összes fennmaradó karaktert" jelzi, ha egy keresési függvény meghiúsul.

static const size_type npos = -1;

Megjegyzések

Ha a visszatérési értéket ellenőrizni kell az npos értéknél, előfordulhat, hogy nem működik, ha a visszatérési érték típusú size_type , és nem vagy intunsigned.

példa

A deklarálásához és használatához findlásd a példátnpos.

basic_string::operator+=

Karakterek hozzáfűzése egy sztringhez.

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);

Paraméterek

char_value
A hozzáfűzendő karakter.

ptr
A hozzáfűzendő C-sztring karakterei.

right
A hozzáfűzendő sztring karakterei.

Visszaadott érték

Hivatkozás a tagfüggvény által átadott karakterekkel kiegészített sztringobjektumra.

Megjegyzések

A karakterek egy sztringhez fűzhetők a operator+= tagfüggvények vagy a tagfüggvények append használatával push_back. A operator+= hozzáfűzők egy argumentumból álló értékeket fűznek össze, míg a több argumentumot hozzáfűző tagfüggvény lehetővé teszi egy sztring adott részének megadását a hozzáadáshoz.

példa

// 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 string 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 string str1 is: Hello Wide World.

basic_string::operator=

Új karakterértékeket rendel egy sztring tartalmához.

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);

Paraméterek

char_value
A hozzárendelni kívánt karakterérték.

ptr
Mutató a célsztringhez hozzárendelendő C-sztring karaktereihez.

right
A forrássztring, amelynek karaktereit hozzá kell rendelni a célsztringhez.

Visszaadott érték

Hivatkozás arra a sztringobjektumra, amelyet a tagfüggvény új karakterekhez rendel.

Megjegyzések

A sztringek új karakterértékeket is hozzárendelhetnek. Az új érték lehet sztring és C-sztring, vagy egy karakter. A operator= függvény akkor használható, ha az új érték egyetlen paraméterrel írható le, ellenkező esetben a több paramétert tartalmazó tagfüggvény assignhasználatával megadhatja, hogy a sztring melyik része legyen hozzárendelve egy célsztringhez.

példa

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

Egy karakterlánc megadott indexével rendelkező karakterre mutató hivatkozást tartalmaz.

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

Paraméterek

offset
A hivatkozni kívánt elem pozíciójának indexe.

Visszaadott érték

Hivatkozás a sztring karakterére a paraméterindex által megadott helyen.

Megjegyzések

A sztring első eleme nulla indexű, a következő elemeket pedig egymás után indexelik a pozitív egész számok. Ez azt jelenti, hogy az n hosszúságú sztring n-edikelemét az n - 1 szám indexeli.

operator[] gyorsabb, mint a tagfüggvény at , amely olvasási és írási hozzáférést biztosít egy sztring elemeihez.

operator[] nem ellenőrzi, hogy a paraméterként átadott index érvényes-e, de a tagfüggvény at igen, és így kell használni az érvényességben, nem biztos benne. A tagfüggvénynek at átadott érvénytelen index (a sztring méreténél kisebb vagy kisebb index) osztálykivételt out_of_range eredményez. A megadott operator[] érvénytelen index nem definiált viselkedést eredményez, de a sztring hosszával egyenlő index érvényes index a const sztringekhez, az operátor pedig a null karaktert adja vissza az index átadásakor.

A visszaadott hivatkozás érvényteleníthető a nem sztringek karakterlánc-újraelosztásávalconst vagy módosításával.

Az 1 vagy 2 beállítással történő _ITERATOR_DEBUG_LEVEL összeállításkor futásidejű hiba lép fel, ha a sztring határain kívüli elemet próbál elérni. További információ: Ellenőrzött iterátorok.

példa

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

Olyan típus, amely egy sztring vagy karaktertömb egyik karakterelemére mutat.

typedef typename allocator_type::pointer pointer;

Megjegyzések

A típus a szinonimája.allocator_type::pointer

Típus stringesetén ez egyenértékű a következőval char *: .

példa

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

Törli a sztring utolsó elemét.

void pop_back();

Megjegyzések

Ez a tagfüggvény gyakorlatilag a sorozat utolsó elemének törlését kéri erase(size() - 1) , amelynek nem szabad üresnek lennie.

basic_string::push_back

Hozzáad egy elemet a sztring végéhez.

void push_back(value_type char_value);

Paraméterek

char_value
A sztring végéhez hozzáadni kívánt karakter.

Megjegyzések

A tagfüggvény hatékonyan hívja meg a következőt insert( end, char_value ): . További információ: insert és end.

példa

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

Egy iterátort ad vissza egy fordított sztring első elemének.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Visszaadott érték

Véletlenszerű hozzáférésű iterátort ad vissza egy fordított sztring első eleméhez, amely a megfelelő nem fordított sztring utolsó elemének felel meg.

Megjegyzések

rbegin a sztringhez hasonlóan begin fordított sztringgel is használható.

Ha a visszaadott rbegin érték egy const_reverse_iteratoradotthoz van rendelve, a sztringobjektum nem módosítható. Ha a visszatérési rbegin érték egy adotthoz van rendelve, a sztringobjektum reverse_iteratormódosítható.

rbegin használatával inicializálhat egy iterációt egy sztringgel visszafelé.

példa

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

Olyan típus, amely egy sztringben tárolt elemre mutató hivatkozást tartalmaz.

typedef typename allocator_type::reference reference;

Megjegyzések

Egy elem értékének módosítására reference típus használható.

A típus a szinonimája.allocator_type::reference

Típus stringesetén ez egyenértékű a következőval chr&: .

példa

A deklarálásához és használatához atlásd a példátreference.

basic_string::rend

Egy olyan iterátort ad vissza, amely a fordított sztring utolsó elemét követő helyet kezeli.

const_reverse_iterator rend() const;

reverse_iterator rend();

Visszaadott érték

Fordított véletlenszerű hozzáférésű iterátor, amely egy fordított sztring utolsó elemét követő helyet kezeli.

Megjegyzések

rend a sztringhez hasonlóan end fordított sztringgel is használható.

Ha a visszaadott rend érték egy const_reverse_iteratoradotthoz van rendelve, a sztringobjektum nem módosítható. Ha a visszatérési rend érték egy adotthoz van rendelve, a sztringobjektum reverse_iteratormódosítható.

rend segítségével tesztelhető, hogy egy fordított iterátor elérte-e a sztring végét.

A rend által visszaadott értéket nem szabad elhalasztani.

példa

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

A megadott pozícióban lévő sztring elemeit lecseréli megadott karakterekre, vagy más tartományokból, sztringekből vagy C-sztringekből másolt karakterekre.

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);

Paraméterek

str
Az operandus sztring karakterforrása.

position_1
Annak az operandus-sztringnek az indexe, amelyen a csere megkezdődik.

number_1
Az operandus sztringben lecserélendő karakterek maximális száma.

position_2
Annak a paramétersztringnek az indexe, amelyen a másolás megkezdődik.

number_2
A C-sztring paraméterből használandó karakterek maximális száma.

ptr
A C-sztring, amely az operandus sztring karakterforrása lesz.

char_value
Az operandus sztringbe másolandó karakter.

first0
Az operandus sztringben eltávolítandó első karaktert megszólító iterátor.

last0
Az operandus sztringben eltávolítandó utolsó karaktert megszólító iterátor.

first
Egy iterátor, const_pointer vagy const_iterator, amely a paramétersztringbe másolandó első karaktert kezeli.

last
Egy iterátor, const_pointer vagy const_iterator, amely a paramétersztringbe másolandó utolsó karaktert kezeli.

count
Az operandus sztringbe másolt példányok char_value száma.

Visszaadott érték

Az operandus sztring a csere kész.

példa

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

A sztring kapacitását egy olyan számra állítja be, amely legalább akkora, mint egy megadott szám.

void reserve(size_type count = 0);

Paraméterek

count
Azoknak a karaktereknek a száma, amelyek számára a memória foglalt.

Megjegyzések

A megfelelő kapacitás azért fontos, mert az újraelosztás időigényes folyamat. Érvényteleníti az összes olyan hivatkozást, mutatót és iterátort, amely egy sztringben szereplő karakterekre hivatkozik.

A sztringobjektum-típusok kapacitásának fogalma megegyezik a típusobjektumok kapacitásával vector. Ellentétben vectora tagfüggvény reserve meghívásával csökkenthető egy objektum kapacitása. A kérelem nem kötött, és előfordulhat, hogy nem történik meg. Mivel a paraméter alapértelmezett értéke nulla, a hívás reserve nem kötési kérés, amely csökkenti a sztring kapacitását a sztringben jelenleg szereplő karakterek számának megfelelően. A kapacitás soha nem csökken a karakterek aktuális száma alatt.

A sztringek kapacitásának csökkentése csak a hívással reserve lehetséges. Azonban, mint fentebb említettük, ez a kérés nem kapcsolódik, és előfordulhat, hogy nem történik meg.

példa

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

Szükség szerint új méretet ad meg egy sztringhez, hozzáfűzve vagy törölve az elemeket.

void resize(
    size_type count);

void resize(
    size_type count,
    value_type char_value);

Paraméterek

count
A sztring új mérete.

char_value
A hozzáfűzött karakterek inicializálásának értéke, ha további elemekre van szükség.

Megjegyzések

Ha az eredményként kapott méret meghaladja a karakterek maximális számát, az űrlap dob length_error.

példa

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

Olyan típus, amely egy sztringben tárolt elemre mutató hivatkozást tartalmaz.

typedef std::reverse_iterator<iterator> reverse_iterator;

Megjegyzések

Egy karakter értékének módosítására egy típus reverse_iterator használható, amely egy sztring megfordítására szolgál.

példa

A deklarálásához és használatához rbeginlásd a példátreverse_iterator.

basic_string::rfind

Visszafelé keres egy sztringet egy adott karaktersorozatnak megfelelő részstring első előfordulására.

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;

Paraméterek

char_value
Az a karakterérték, amelyre a tagfüggvény keres.

offset
A keresés megkezdéséhez használt pozíció indexe.

ptr
Az a C-sztring, amelyre a tagfüggvény keres.

count
Az első karaktertől előre számolt karakterek száma abban a C-sztringben, amelyben a tagfüggvény keres.

str
Az a sztring, amelyre a tagfüggvény keres.

Visszaadott érték

A visszafelé történő kereséskor az utolsó előfordulás indexe az alsztring első karakterének sikeressége esetén; egyéb esetben npos.

példa

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

Elveti a sztring többletkapacitását.

void shrink_to_fit();

Megjegyzések

Ez a tagfüggvény kiküszöböli a tároló szükségtelen tárolóit.

basic_string::size

Egy sztring elemeinek aktuális számát adja vissza.

size_type size() const;

Visszaadott érték

A sztring hossza.

példa

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

Egy nem aláírt egész számtípus, amely egy sztring elemeinek és indexeinek számát jelölheti.

typedef typename allocator_type::size_type size_type;

Megjegyzések

ez egyenértékű a allocator_type::size_type.

Típus stringesetén ez egyenértékű a következőval size_t: .

példa

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

Ellenőrizze, hogy a sztring a megadott előtaggal kezdődik-e.

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;

Paraméterek

c
A keresendő egyetlen karakteres előtag.

sv
A keresendő előtagot tartalmazó sztringnézet.
Átadhatja a sztringnézetté std::basic_stringkonvertált elemeket.

x
A keresendő előtagot tartalmazó null értékű karaktersztring.

Visszaadott érték

true ha a sztring a megadott előtaggal kezdődik; false egyébként.

Megjegyzések

starts_with() a C++20-ban új. A használatához adja meg a /std:c++20 vagy újabb fordító lehetőséget.

Ellenőrizze ends_with , hogy egy sztring a megadott utótaggal végződik-e.

példa

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

Legfeljebb néhány karakterből álló részsztringet másol egy megadott pozícióból kezdődő sztringből.

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

Paraméterek

offset
Egy index, amely az elemet azon a helyen helyezi el, ahonnan a sztring másolatát készítik, alapértelmezett értéke 0.

count
A másolandó karakterek száma, ha jelen vannak.

Visszaadott érték

A sztringoperndus elemeinek másolata, az első argumentum által megadott pozíciótól kezdődően.

példa

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

Cserélje le két sztring tartalmát.

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

Paraméterek

str
A forrássztring, amelynek elemeit a célsztring elemeivel kell kicserélni.

Megjegyzések

Ha a felcserélt sztringek ugyanazzal az elosztóobjektummal rendelkeznek, a swap tagfüggvény:

• Állandó időben történik.
• Nem ad kivételt.
• Érvényteleníti a két sztring elemeit meghatározó hivatkozásokat, mutatókat és iterátorokat.

Ellenkező esetben az elemek hozzárendelése és a konstruktorhívások arányosak a két szabályozott sorozat elemeinek számával.

példa

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

A sztringben tárolt elemek karaktertulajdonságainak típusa.

typedef Traits traits_type;

Megjegyzések

A típus a második sablonparaméter Traitsszinonimája.

Típus stringesetén ez egyenértékű a következőval char_traits<char>: .

példa

A deklarálásához és használatához copylásd a példáttraits_type.

basic_string::value_type

A sztringben tárolt karakterek típusát jelképező típus.

typedef typename allocator_type::value_type value_type;

Megjegyzések

Egyenértékű a traits_type::char_type típusobjektumokkalchar, és azokkal egyenértékűstring.

példa

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

Lásd még

<string>
Szálbiztonság a C++ standard kódtárban