`<string>` operatörer

2025-06-12

Rubriken <string> innehåller följande operatorer:

operator+

Sammanfogar två strängobjekt.

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator> operator+(
    const basic_string<CharType, Traits, Allocator>& left,
    const basic_string<CharType, Traits, Allocator>& right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator> operator+(
    const basic_string<CharType, Traits, Allocator>& left,
    const CharType* right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator> operator+(
    const basic_string<CharType, Traits, Allocator>& left,
    const CharType right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator> operator+(
    const CharType* left,
    const basic_string<CharType, Traits, Allocator>& right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator> operator+(
    const CharType left,
    const basic_string<CharType, Traits, Allocator>& right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator>&& operator+(
    const basic_string<CharType, Traits, Allocator>& left,
    const basic_string<CharType, Traits, Allocator>&& right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator>&& operator+(
    const basic_string<CharType, Traits, Allocator>&& left,
    const basic_string<CharType, Traits, Allocator>& right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator>&& operator+(
    const basic_string<CharType, Traits, Allocator>&& left,
    const basic_string<CharType, Traits, Allocator>&& right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator>&& operator+(
    const basic_string<CharType, Traits, Allocator>&& left,
    const CharType* right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator>&& operator+(
    const basic_string<CharType, Traits, Allocator>&& left,
    CharType right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator>&& operator+(
    const CharType* left,
    const basic_string<CharType, Traits, Allocator>&& right);

template <class CharType, class Traits, class Allocator>
basic_string<CharType, Traits, Allocator>&& operator+(
    CharType left,
    const basic_string<CharType, Traits, Allocator>&& right);

Parameterar

vänster
En C-sträng eller ett objekt av typen basic_string som ska sammanfogas.

rätt
En C-sträng eller ett objekt av typen basic_string som ska sammanfogas.

Returvärde

Strängen som är sammanlänkningen av indatasträngarna.

Anmärkningar

Funktionerna för varje överlagring operator+ för att sammanfoga två objekt i klassmallen basic_string. Alla returnerar basic_string< CharType, Traits, Allocator>(Left).append(right)effektivt . Mer information finns i tillägg.

Exempel

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

int main( )
{
   using namespace std;
   // Declaring an object of type basic_string<char>
   string s1 ( "anti" );
   string s2 ( "gravity" );
   cout << "The basic_string s1 = " << s1 << "." << endl;
   cout << "The basic_string s2 = " << s2 << "." << endl;

   // Declaring a C-style string
   char *s3 = "heroine";
   cout << "The C-style string s3 = " << s3 << "." << endl;

   // Declaring a character constant
   char c1 = '!';
   cout << "The character constant c1 = " << c1 << "." << endl;

   // First member function: concatenates an  object
   // of type basic_string with an object of type basic_string
   string s12 = s1 + s2;
   cout << "The string concatenating s1 & s2 is: " << s12 << endl;

   // Second & fourth member functions: concatenate an object
   // of type basic_string with an object of C-syle string type
   string s1s3 = s1 + s3;
   cout << "The string concatenating s1 & s3 is: " << s1s3 << endl;

   // Third & fifth member functions: concatenate an object
   // of type basic_string with a character constant
   string s1s3c1 = s1s3 + c1;
   cout << "The string concatenating s1 & s3 is: " << s1s3c1 << endl;
}

The basic_string s1 = anti.
The basic_string s2 = gravity.
The C-style string s3 = heroine.
The character constant c1 = !.
The string concatenating s1 & s2 is: antigravity
The string concatenating s1 & s3 is: antiheroine
The string concatenating s1 & s3 is: antiheroine!

operator!=

Testar om strängobjektet till vänster om operatorn inte är lika med strängobjektet till höger.

template <class CharType, class Traits, class Allocator>
bool operator!=(
    const basic_string<CharType, Traits, Allocator>& left,
    const basic_string<CharType, Traits, Allocator>& right);

template <class CharType, class Traits, class Allocator>
bool operator!=(
    const basic_string<CharType, Traits, Allocator>& left,
const CharType* right);

template <class CharType, class Traits, class Allocator>
bool operator!=(
    const CharType* left,
    const basic_string<CharType, Traits, Allocator>& right);

Parameterar

vänster
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

rätt
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

Returvärde

true om strängobjektet till vänster om operatorn inte är lexicographically lika med strängobjektet på höger sida; annars false.

Anmärkningar

Jämförelsen mellan strängobjekt baseras på en parvis lexicographical jämförelse av deras tecken. Två strängar är lika med om de har samma antal tecken och deras respektive teckenvärden är desamma. Annars är de ojämlika.

Exempel

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

int main( )
{
   using namespace std;

   // Declaring an objects of type basic_string<char>
   string s1 ( "pluck" );
   string s2 ( "strum" );
   cout << "The basic_string s1 = " << s1 << "." << endl;
   cout << "The basic_string s2 = " << s2 << "." << endl;

   // Declaring a C-style string
   char *s3 = "pluck";
   cout << "The C-style string s3 = " << s3 << "." << endl;

   // First member function: comparison between left-side object
   // of type basic_string & right-side object of type basic_string
   if ( s1 != s2 )
      cout << "The strings s1 & s2 are not equal." << endl;
   else
      cout << "The strings s1 & s2 are equal." << endl;

   // Second member function: comparison between left-side object
   // of type basic_string & right-side object of C-syle string type
   if ( s1 != s3 )
      cout << "The strings s1 & s3 are not equal." << endl;
   else
      cout << "The strings s1 & s3 are equal." << endl;

   // Third member function: comparison between left-side object
   // of C-syle string type & right-side object of type basic_string
   if ( s3 != s2 )
      cout << "The strings s3 & s2 are not equal." << endl;
   else
      cout << "The strings s3 & s2 are equal." << endl;
}

The basic_string s1 = pluck.
The basic_string s2 = strum.
The C-style string s3 = pluck.
The strings s1 & s2 are not equal.
The strings s1 & s3 are equal.
The strings s3 & s2 are not equal.

operator==

Testar om strängobjektet till vänster om operatorn är lika med strängobjektet till höger.

template <class CharType, class Traits, class Allocator>
bool operator==(
    const basic_string<CharType, Traits, Allocator>& left,
    const basic_string<CharType, Traits, Allocator>& right);

template <class CharType, class Traits, class Allocator>
bool operator==(
    const basic_string<CharType, Traits, Allocator>& left,
    const CharType* right);

template <class CharType, class Traits, class Allocator>
bool operator==(
    const CharType* left,
    const basic_string<CharType, Traits, Allocator>& right);

Parameterar

vänster
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

rätt
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

Returvärde

true om strängobjektet till vänster om operatorn är lexiktografiskt lika med strängobjektet på höger sida; annars false.

Anmärkningar

Exempel

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

int main( )
{
   using namespace std;

   // Declaring an objects of type basic_string<char>
   string s1 ( "pluck" );
   string s2 ( "strum" );
   cout << "The basic_string s1 = " << s1 << "." << endl;
   cout << "The basic_string s2 = " << s2 << "." << endl;

   // Declaring a C-style string
   char *s3 = "pluck";
   cout << "The C-style string s3 = " << s3 << "." << endl;

   // First member function: comparison between left-side object
   // of type basic_string & right-side object of type basic_string
   if ( s1 == s2 )
      cout << "The strings s1 & s2 are equal." << endl;
   else
      cout << "The strings s1 & s2 are not equal." << endl;

   // Second member function: comparison between left-side object
   // of type basic_string & right-side object of C-syle string type
   if ( s1 == s3 )
      cout << "The strings s1 & s3 are equal." << endl;
   else
      cout << "The strings s1 & s3 are not equal." << endl;

   // Third member function: comparison between left-side object
   // of C-syle string type & right-side object of type basic_string
   if ( s3 == s2 )
      cout << "The strings s3 & s2 are equal." << endl;
   else
      cout << "The strings s3 & s2 are not equal." << endl;
}

The basic_string s1 = pluck.
The basic_string s2 = strum.
The C-style string s3 = pluck.
The strings s1 & s2 are not equal.
The strings s1 & s3 are equal.
The strings s3 & s2 are not equal.

`operator<`

Testar om strängobjektet till vänster om operatorn är mindre än strängobjektet till höger.

template <class CharType, class Traits, class Allocator>
bool operator<(
    const basic_string<CharType, Traits, Allocator>& left,
    const basic_string<CharType, Traits, Allocator>& right);

template <class CharType, class Traits, class Allocator>
bool operator<(
    const basic_string<CharType, Traits, Allocator>& left,
    const CharType* right);

template <class CharType, class Traits, class Allocator>
bool operator<(
    const CharType* left,
    const basic_string<CharType, Traits, Allocator>& right);

Parameterar

vänster
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

rätt
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

Returvärde

true om strängobjektet till vänster om operatorn är lexicographically mindre än strängobjektet på höger sida; annars false.

Anmärkningar

En lexicographical jämförelse mellan strängar jämför dem tecken efter tecken tills:

Den hittar två motsvarande tecken som är olika och resultatet av deras jämförelse tas som ett resultat av jämförelsen mellan strängarna.
Den hittar inga skillnader, men den ena strängen har fler tecken än den andra, och den kortare strängen anses vara mindre än den längre strängen.
Den hittar inga skillnader och upptäcker att strängarna har samma antal tecken, och därför är strängarna lika.

Exempel

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

int main( )
{
   using namespace std;
   // Declaring an objects of type basic_string<char>
   string s1 ( "strict" );
   string s2 ( "strum" );
   cout << "The basic_string s1 = " << s1 << "." << endl;
   cout << "The basic_string s2 = " << s2 << "." << endl;

   // Declaring a C-style string
   char *s3 = "strict";
   cout << "The C-style string s3 = " << s3 << "." << endl;

   // First member function: comparison between left-side object
   // of type basic_string & right-side object of type basic_string
   if ( s1 < s2 )
      cout << "The string s1 is less than the string s2." << endl;
   else
      cout << "The string s1 is not less than the string s2." << endl;

   // Second member function: comparison between left-hand object
   // of type basic_string & right-hand object of C-syle string type
   if ( s1 < s3 )
      cout << "The string s1 is less than the string s3." << endl;
   else
      cout << "The string s1 is not less than the string s3." << endl;

   // Third member function: comparison between left-hand object
   // of C-syle string type & right-hand object of type basic_string
   if ( s3 < s2 )
      cout << "The string s3 is less than the string s2." << endl;
   else
      cout << "The string s3 is not less than the string s2." << endl;
}

The basic_string s1 = strict.
The basic_string s2 = strum.
The C-style string s3 = strict.
The string s1 is less than the string s2.
The string s1 is not less than the string s3.
The string s3 is less than the string s2.

`operator<=`

Testar om strängobjektet till vänster om operatorn är mindre än eller lika med strängobjektet till höger.

template <class CharType, class Traits, class Allocator>
bool operator<=(
    const basic_string<CharType, Traits, Allocator>& left,
    const basic_string<CharType, Traits, Allocator>& right);

template <class CharType, class Traits, class Allocator>
bool operator<=(
    const basic_string<CharType, Traits, Allocator>& left,
    const CharType* right);

template <class CharType, class Traits, class Allocator>
bool operator<=(
    const CharType* left,
    const basic_string<CharType, Traits, Allocator>& right);

Parameterar

vänster
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

rätt
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

Returvärde

true om strängobjektet till vänster om operatorn är lexicographically mindre än eller lika med strängobjektet på höger sida; annars false.

Anmärkningar

En lexicographical jämförelse mellan strängar jämför dem tecken efter tecken tills:

Den hittar två motsvarande tecken som är olika och resultatet av deras jämförelse tas som ett resultat av jämförelsen mellan strängarna.
Den hittar inga skillnader, men den ena strängen har fler tecken än den andra, och den kortare strängen anses vara mindre än den längre strängen.
Den hittar inga skillnader och upptäcker att strängarna har samma antal tecken, så strängarna är lika.

Exempel

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

int main( )
{
   using namespace std;

   // Declaring an objects of type basic_string<char>
   string s1 ( "strict" );
   string s2 ( "strum" );
   cout << "The basic_string s1 = " << s1 << "." << endl;
   cout << "The basic_string s2 = " << s2 << "." << endl;

   // Declaring a C-style string
   char *s3 = "strict";
   cout << "The C-style string s3 = " << s3 << "." << endl;

   // First member function: comparison between left-side object
   // of type basic_string & right-side object of type basic_string
   if ( s1 <= s2 )
      cout << "The string s1 is less than or equal to "
           << "the string s2." << endl;
   else
      cout << "The string s1 is greater than "
           << "the string s2." << endl;

   // Second member function: comparison between left-side object
   // of type basic_string & right-side object of C-syle string type
   if ( s1 <= s3 )
      cout << "The string s1 is less than or equal to "
           << "the string s3." << endl;
   else
      cout << "The string s1 is greater than "
           << "the string s3." << endl;

   // Third member function: comparison between left-side object
   // of C-syle string type  & right-side object of type basic_string
   if ( s2 <= s3 )
      cout << "The string s2 is less than or equal to "
           << "the string s3." << endl;
   else
      cout << "The string s2 is greater than "
           << "the string s3." << endl;
}

The basic_string s1 = strict.
The basic_string s2 = strum.
The C-style string s3 = strict.
The string s1 is less than or equal to the string s2.
The string s1 is less than or equal to the string s3.
The string s2 is greater than the string s3.

`operator<<`

En mallfunktion som skriver en sträng i utdataströmmen.

template <class CharType, class Traits, class Allocator>
basic_ostream<CharType, Traits>& operator<<(
    basic_ostream<CharType, Traits>& _Ostr,
    const basic_string<CharType, Traits, Allocator>& str);

Parameterar

_Ostr
Utdataströmmen som skrivs till.

Str
Strängen som ska anges i utdataströmmen.

Returvärde

Skriver värdet för den angivna strängen till utdataströmmen _Ostr.

Anmärkningar

Mallfunktionen överbelastar operatorn<< för att infoga en objektsträng av klassmallen basic_string i dataströmmen _Ostr. Funktionen returnerar _Ostr.write( str.c_str, str.size )effektivt .

`operator>`

Testar om strängobjektet till vänster om operatorn är större än strängobjektet till höger.

template <class CharType, class Traits, class Allocator>
bool operator>(
    const basic_string<CharType, Traits, Allocator>& left,
    const basic_string<CharType, Traits, Allocator>& right);

template <class CharType, class Traits, class Allocator>
bool operator>(
    const basic_string<CharType, Traits, Allocator>& left,
    const CharType* right);

template <class CharType, class Traits, class Allocator>
bool operator>(
    const CharType* left,
    const basic_string<CharType, Traits, Allocator>& right);

Parameterar

vänster
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

rätt
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

Returvärde

true om strängobjektet till vänster om operatorn är lexicographically större än strängobjektet på höger sida; annars false.

Anmärkningar

En lexicographical jämförelse mellan strängar jämför dem tecken efter tecken tills:

Den hittar två motsvarande tecken som är olika och resultatet av deras jämförelse tas som ett resultat av jämförelsen mellan strängarna.
Den hittar inga skillnader, men den ena strängen har fler tecken än den andra, och den kortare strängen anses vara mindre än den längre strängen.
Den hittar inga skillnader och upptäcker att strängarna har samma antal tecken, och därför är strängarna lika.

Exempel

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

int main( )
{
   using namespace std;

   // Declaring an objects of type basic_string<char>
   string s1 ( "strict" );
   string s2 ( "strum" );
   cout << "The basic_string s1 = " << s1 << "." << endl;
   cout << "The basic_string s2 = " << s2 << "." << endl;

   // Declaring a C-style string
   char *s3 = "stricture";
   cout << "The C-style string s3 = " << s3 << "." << endl;

   // First member function: comparison between left-side object
   // of type basic_string & right-side object of type basic_string
   if ( s1 > s2 )
      cout << "The string s1 is greater than "
           << "the string s2." << endl;
   else
      cout << "The string s1 is not greater than "
           << "the string s2." << endl;

   // Second member function: comparison between left-side object
   // of type basic_string & right-side object of C-syle string type
   if ( s3 > s1 )
      cout << "The string s3 is greater than "
           << "the string s1." << endl;
   else
      cout << "The string s3 is not greater than "
           << "the string s1." << endl;

   // Third member function: comparison between left-side object
   // of C-syle string type & right-side object of type basic_string
   if ( s2 > s3 )
      cout << "The string s2 is greater than "
           << "the string s3." << endl;
   else
      cout << "The string s2 is not greater than "
           << "the string s3." << endl;
}

The basic_string s1 = strict.
The basic_string s2 = strum.
The C-style string s3 = stricture.
The string s1 is not greater than the string s2.
The string s3 is greater than the string s1.
The string s2 is greater than the string s3.

`operator>=`

Testar om strängobjektet till vänster om operatorn är större än eller lika med strängobjektet till höger.

template <class CharType, class Traits, class Allocator>
bool operator>=(
    const basic_string<CharType, Traits, Allocator>& left,
    const basic_string<CharType, Traits, Allocator>& right);

template <class CharType, class Traits, class Allocator>
bool operator>=(
    const basic_string<CharType, Traits, Allocator>& left,
    const CharType* right);

template <class CharType, class Traits, class Allocator>
bool operator>=(
    const CharType* left,
    const basic_string<CharType, Traits, Allocator>& right);

Parameterar

vänster
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

rätt
En C-sträng eller ett objekt av typen basic_string som ska jämföras.

Returvärde

true om strängobjektet till vänster om operatorn är lexicographically större än eller lika med strängobjektet på höger sida; annars false.

Anmärkningar

En lexicographical jämförelse mellan strängar jämför dem tecken efter tecken tills:

Den hittar två motsvarande tecken som är olika och resultatet av deras jämförelse tas som ett resultat av jämförelsen mellan strängarna.
Den hittar inga skillnader, men den ena strängen har fler tecken än den andra, och den kortare strängen anses vara mindre än den längre strängen.
Den hittar inga skillnader och finner att strängarna har samma antal tecken, så strängarna är lika.

Exempel

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

int main( )
{
   using namespace std;

   // Declaring an objects of type basic_string<char>
   string s1 ( "strict" );
   string s2 ( "strum" );
   cout << "The basic_string s1 = " << s1 << "." << endl;
   cout << "The basic_string s2 = " << s2 << "." << endl;

   // Declaring a C-style string
   char *s3 = "stricture";
   cout << "The C-style string s3 = " << s3 << "." << endl;

   // First member function: comparison between left-side object
   // of type basic_string & right-side object of type basic_string
   if ( s1 >= s2 )
      cout << "The string s1 is greater than or equal to "
           << "the string s2." << endl;
   else
      cout << "The string s1 is less than "
           << "the string s2." << endl;

   // Second member function: comparison between left-side object
   // of type basic_string & right-side object of C-syle string type
   if ( s3 >= s1 )
      cout << "The string s3 is greater than or equal to "
           << "the string s1." << endl;
   else
      cout << "The string s3 is less than "
           << "the string s1." << endl;

   // Third member function: comparison between left-side object
   // of C-syle string type & right-side object of type basic_string
   if ( s2 >= s3 )
      cout << "The string s2 is greater than or equal to "
           << "the string s3." << endl;
   else
      cout << "The string s2 is less than "
           << "the string s3." << endl;
}

The basic_string s1 = strict.
The basic_string s2 = strum.
The C-style string s3 = stricture.
The string s1 is less than the string s2.
The string s3 is greater than or equal to the string s1.
The string s2 is greater than or equal to the string s3.

`operator>>`

En mallfunktion som läser en sträng från en indataström.

template <class CharType, class Traits, class Allocator>
basic_istream<CharType, Traits>& operator>>(
    basic_istream<CharType, Traits>& _Istr,
    basic_string<CharType, Traits, Allocator>& right);

Parameterar

_Istr
Indataströmmen som används för att extrahera sekvensen

rätt
Strängen som extraheras från indataströmmen.

Returvärde

Läser värdet för den angivna strängen från _Istr och returnerar den till höger.

Anmärkningar

Operatorn hoppar över de inledande blankstegen skipws om inte flaggan har angetts. Det läser alla följande tecken tills nästa tecken är ett tomt utrymme eller slutet av filen har nåtts.

Mallfunktionen överbelastar operatorn>> för att ersätta sekvensen som styrs av höger med en sekvens med element som extraherats från strömmen _Istr. Extraheringsstopp:

I slutet av filen.
När funktionen har extraherats _Istr. breddelement , om värdet inte är noll.

När funktionen har extraherats _Istr. max_size element.

När funktionen extraherar ett element ch som use_facet<ctype<CharType>>(getloc). is( ctype<CharType>:: space, ch) is true, i vilket fall tecknet sätts tillbaka.

Om funktionen inte extraherar några element anropas setstate(ios_base::failbit). I vilket fall som helst anropas istr. width(0) och returnerar * this.

Exempel

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

int main( )
{
   using namespace std;

   string c0;
   cout << "Input a string c0 ( try: Fibonacci numbers ): ";
   cin >> c0;
   cout << "The string entered is c0 = " << c0 << endl;
}

Se även

<sträng>

Feedback

Var den här sidan till hjälp?

Dela via

<string> operatörer

operator+

Parameterar

Returvärde

Anmärkningar

Exempel

operator!=

Parameterar

Returvärde

Anmärkningar

Exempel

operator==

Parameterar

Returvärde

Anmärkningar

Exempel

operator<

Parameterar

Returvärde

Anmärkningar

Exempel

operator<=

Parameterar

Returvärde

Anmärkningar

Exempel

operator<<

Parameterar

Returvärde

Anmärkningar

operator>

Parameterar

Returvärde

Anmärkningar

Exempel

operator>=

Parameterar

Returvärde

Anmärkningar

Exempel

operator>>

Parameterar

Returvärde

Anmärkningar

Exempel

Se även

Feedback

Ytterligare resurser

`<string>` operatörer

`operator<`

`operator<=`

`operator<<`

`operator>`

`operator>=`

`operator>>`