`<string>`, operatory

Artykuł
08/04/2024

operator!=
operator>
operator>>
operator>=
operator<
operator<<
operator<=
operator+
operator==

operator+

Łączy dwa obiekty ciągów.

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

Parametry

Lewy
Ciąg w stylu C lub obiekt typu basic_string , który ma być połączony.

Prawy
Ciąg w stylu C lub obiekt typu basic_string , który ma być połączony.

Wartość zwracana

Ciąg, który jest połączeniem ciągów wejściowych.

Uwagi

Każde przeciążenie operator+ funkcji w celu połączenia dwóch obiektów szablonu klasy basic_string Klasa. Wszystkie skutecznie zwracają wartość basic_string< CharType, Traits, Allocator>(Left).append(right). Aby uzyskać więcej informacji, zobacz dołączanie.

Przykład

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

Sprawdza, czy obiekt ciągu po lewej stronie operatora nie jest równy obiektowi ciągu po prawej stronie.

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

Parametry

Lewy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Prawy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Wartość zwracana

true jeśli obiekt ciągu po lewej stronie operatora nie jest leksykograficznie równy obiektowi ciągu po prawej stronie; w przeciwnym razie false.

Uwagi

Porównanie obiektów ciągów jest oparte na parzystycznym porównywaniu ich znaków. Dwa ciągi są równe, jeśli mają taką samą liczbę znaków, a ich odpowiednie wartości znaków są takie same. W przeciwnym razie są one nierówne.

Przykład

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

Sprawdza, czy obiekt ciągu po lewej stronie operatora jest równy obiektowi ciągu po prawej stronie.

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

Parametry

Lewy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Prawy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Wartość zwracana

true jeśli obiekt ciągu po lewej stronie operatora jest leksykograficznie równy obiektowi ciągu po prawej stronie; w przeciwnym razie false.

Uwagi

Przykład

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

Sprawdza, czy obiekt ciągu po lewej stronie operatora jest mniejszy niż obiekt ciągu po prawej stronie.

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

Parametry

Lewy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Prawy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Wartość zwracana

true jeśli obiekt ciągu po lewej stronie operatora jest leksykograficznie mniejszy niż obiekt ciągu po prawej stronie; w przeciwnym razie false.

Uwagi

Porównanie leksykograficzne między ciągami porównuje je znak po znaku do:

Znajduje dwa odpowiadające im znaki nierówne, a wynik ich porównania jest traktowany jako wynik porównania między ciągami.
Nie znajduje żadnych nierówności, ale jeden ciąg ma więcej znaków niż drugi, a krótszy ciąg jest uznawany za mniejszy niż dłuższy ciąg.
Nie znajduje nierówności i stwierdza, że ciągi mają taką samą liczbę znaków, więc ciągi są równe.

Przykład

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

Sprawdza, czy obiekt ciągu po lewej stronie operatora jest mniejszy lub równy obiektowi ciągu po prawej stronie.

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

Parametry

Lewy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Prawy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Wartość zwracana

true jeśli obiekt ciągu po lewej stronie operatora jest leksykograficznie mniejszy lub równy obiektowi ciągu po prawej stronie; w przeciwnym razie false.

Uwagi

Porównanie leksykograficzne między ciągami porównuje je znak po znaku do:

Znajduje dwa odpowiadające im znaki nierówne, a wynik ich porównania jest traktowany jako wynik porównania między ciągami.
Nie znajduje żadnych nierówności, ale jeden ciąg ma więcej znaków niż drugi, a krótszy ciąg jest uznawany za mniejszy niż dłuższy ciąg.
Nie znajduje nierówności i stwierdza, że ciągi mają taką samą liczbę znaków, więc ciągi są równe.

Przykład

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

Funkcja szablonu, która zapisuje ciąg w strumieniu wyjściowym.

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

Parametry

_Ostr
Strumień wyjściowy, do który jest zapisywany.

Str
Ciąg, który ma zostać wprowadzony do strumienia wyjściowego.

Wartość zwracana

Zapisuje wartość określonego ciągu w strumieniu wyjściowym _Ostr.

Uwagi

Funkcja szablonu przeciąża operator<< w celu wstawienia ciągu obiektu szablonu klasy basic_string do strumienia _Ostr. Funkcja skutecznie zwraca _Ostr.write( str.c_str, str.size )wartość .

`operator>`

Sprawdza, czy obiekt ciągu po lewej stronie operatora jest większy niż obiekt ciągu po prawej stronie.

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

Parametry

Lewy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Prawy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Wartość zwracana

true jeśli obiekt ciągu po lewej stronie operatora jest leksykograficznie większy niż obiekt ciągu po prawej stronie; w przeciwnym razie false.

Uwagi

Porównanie leksykograficzne między ciągami porównuje je znak po znaku do:

Znajduje dwa odpowiadające im znaki nierówne, a wynik ich porównania jest traktowany jako wynik porównania między ciągami.
Nie znajduje żadnych nierówności, ale jeden ciąg ma więcej znaków niż drugi, a krótszy ciąg jest uznawany za mniejszy niż dłuższy ciąg.
Nie znajduje nierówności i stwierdza, że ciągi mają taką samą liczbę znaków, więc ciągi są równe.

Przykład

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

Sprawdza, czy obiekt ciągu po lewej stronie operatora jest większy lub równy obiektowi ciągu po prawej stronie.

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

Parametry

Lewy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Prawy
Ciąg w stylu C lub obiekt typu basic_string do porównania.

Wartość zwracana

true jeśli obiekt ciągu po lewej stronie operatora jest leksykograficznie większy lub równy obiektowi ciągu po prawej stronie; w przeciwnym razie false.

Uwagi

Porównanie leksykograficzne między ciągami porównuje je znak po znaku do:

Znajduje dwa odpowiadające im znaki nierówne, a wynik ich porównania jest traktowany jako wynik porównania między ciągami.
Nie znajduje żadnych nierówności, ale jeden ciąg ma więcej znaków niż drugi, a krótszy ciąg jest uznawany za mniejszy niż dłuższy ciąg.
Nie znajduje nierówności i stwierdza, że ciągi mają taką samą liczbę znaków, więc ciągi są równe.

Przykład

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

Funkcja szablonu, która odczytuje ciąg ze strumienia wejściowego.

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

Parametry

_Istr
Strumień wejściowy używany do wyodrębniania sekwencji

Prawy
Ciąg wyodrębniony ze strumienia wejściowego.

Wartość zwracana

Odczytuje wartość określonego ciągu z _Istr i zwraca go w prawo.

Uwagi

Operator pomija wiodące białe spacje, chyba że flaga jest ustawiona skipws . Odczytuje wszystkie następujące znaki do momentu, aż następny znak będzie białym znakiem lub osiągnięto koniec pliku.

Operator>> funkcji szablonu przeciąża, aby zastąpić sekwencję kontrolowaną przez prawo sekwencją elementów wyodrębnionych ze strumienia _Istr. Wyodrębnianie zatrzymuje się:

Na końcu pliku.
Po wyodrębnieniu _Istrfunkcji . elementy szerokości , jeśli ta wartość jest niezerowa.

Po wyodrębnieniu _Istrfunkcji . max_size elementów.

Po funkcji wyodrębnia element ch, dla którego use_facet<ctype<CharType>>( ). getloc is( ctype<CharType>:: spacja, ch) ma wartość true, w tym przypadku znak jest umieszczany z powrotem.

Jeśli funkcja nie wyodrębnia żadnych elementów, wywołuje funkcję setstate(ios_base::failbit). W każdym razie wywołuje istr. width(0) i zwraca wartość * this.

Przykład

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

Zobacz też

Udostępnij za pośrednictwem

<string>, operatory

operator+

Parametry

Wartość zwracana

Uwagi

Przykład

operator!=

Parametry

Wartość zwracana

Uwagi

Przykład

operator==

Parametry

Wartość zwracana

Uwagi

Przykład

operator<

Parametry

Wartość zwracana

Uwagi

Przykład

operator<=

Parametry

Wartość zwracana

Uwagi

Przykład

operator<<

Parametry

Wartość zwracana

Uwagi

operator>

Parametry

Wartość zwracana

Uwagi

Przykład

operator>=

Parametry

Wartość zwracana

Uwagi

Przykład

operator>>

Parametry

Wartość zwracana

Uwagi

Przykład

Zobacz też

Opinia

Dodatkowe zasoby

`<string>`, operatory

`operator<`

`operator<=`

`operator<<`

`operator>`

`operator>=`

`operator>>`